feat: Phase 3 — PostgreSQL provider

cmd/deploy_postgresql.go

@@ -0,0 +1,92 @@
+package cmd
+
+import (
+	"fmt"
+	"path"
+
+	"github.com/ProxySQL/dbdeployer/common"
+	"github.com/ProxySQL/dbdeployer/defaults"
+	"github.com/ProxySQL/dbdeployer/providers"
+	"github.com/ProxySQL/dbdeployer/providers/postgresql"
+	"github.com/spf13/cobra"
+)
+
+func deploySandboxPostgreSQL(cmd *cobra.Command, args []string) {
+	version := args[0]
+	flags := cmd.Flags()
+	skipStart, _ := flags.GetBool("skip-start")
+
+	p, err := providers.DefaultRegistry.Get("postgresql")
+	if err != nil {
+		common.Exitf(1, "PostgreSQL provider not available: %s", err)
+	}
+
+	if err := p.ValidateVersion(version); err != nil {
+		common.Exitf(1, "invalid version: %s", err)
+	}
+
+	if _, err := p.FindBinary(version); err != nil {
+		common.Exitf(1, "PostgreSQL binaries not found: %s\nRun: dbdeployer unpack --provider=postgresql <server.deb> <client.deb>", err)
+	}
+
+	port, err := postgresql.VersionToPort(version)
+	if err != nil {
+		common.Exitf(1, "error computing port: %s", err)
+	}
+	freePort, portErr := common.FindFreePort(port, []int{}, 1)
+	if portErr == nil {
+		port = freePort
+	}
+
+	sandboxHome := defaults.Defaults().SandboxHome
+	sandboxDir := path.Join(sandboxHome, fmt.Sprintf("pg_sandbox_%d", port))
+
+	if common.DirExists(sandboxDir) {
+		common.Exitf(1, "sandbox directory %s already exists", sandboxDir)
+	}
+
+	config := providers.SandboxConfig{
+		Version:    version,
+		Dir:        sandboxDir,
+		Port:       port,
+		Host:       "127.0.0.1",
+		DbUser:     "postgres",
+		DbPassword: "",
+		Options:    map[string]string{},
+	}
+
+	if _, err := p.CreateSandbox(config); err != nil {
+		common.Exitf(1, "error creating PostgreSQL sandbox: %s", err)
+	}
+
+	if !skipStart {
+		if err := p.StartSandbox(sandboxDir); err != nil {
+			common.Exitf(1, "error starting PostgreSQL: %s", err)
+		}
+	}
+
+	fmt.Printf("PostgreSQL %s sandbox deployed in %s (port: %d)\n", version, sandboxDir, port)
+}
+
+var deployPostgreSQLCmd = &cobra.Command{
+	Use:   "postgresql version",
+	Short: "deploys a PostgreSQL sandbox",
+	Long: `postgresql deploys a standalone PostgreSQL instance as a sandbox.
+It creates a sandbox directory with data, configuration, start/stop scripts, and a
+psql client script.
+
+Requires PostgreSQL binaries to be extracted first:
+    dbdeployer unpack --provider=postgresql postgresql-16_*.deb postgresql-client-16_*.deb
+
+Example:
+    dbdeployer deploy postgresql 16.13
+    dbdeployer deploy postgresql 17.1 --skip-start
+`,
+	Args: cobra.ExactArgs(1),
+	Run:  deploySandboxPostgreSQL,
+}
+
+func init() {
+	deployCmd.AddCommand(deployPostgreSQLCmd)
+	deployPostgreSQLCmd.Flags().Bool("skip-start", false, "Do not start PostgreSQL after deployment")
+}

cmd/export_test.go

@@ -165,7 +165,7 @@ func TestExportImport(t *testing.T) {
 			subCommandName:      "",
 			expectedName:        "deploy",
 			expectedAncestors:   2,
-			expectedSubCommands: 4,
+			expectedSubCommands: 5,
 			expectedArgument:    "",
 		},
 		{
@@ -192,6 +192,14 @@ func TestExportImport(t *testing.T) {
 			expectedSubCommands: 0,
 			expectedArgument:    globals.ExportVersionDir,
 		},
+		{
+			commandName:         "deploy",
+			subCommandName:      "postgresql",
+			expectedName:        "postgresql",
+			expectedAncestors:   3,
+			expectedSubCommands: 0,
+			expectedArgument:    "",
+		},
 		{
 			commandName:         "export",
 			subCommandName:      "",

cmd/multiple.go

@@ -16,17 +16,106 @@
 package cmd
 
 import (
+	"fmt"
+	"os"
+	"path"
+	"strings"
+
 	"github.com/ProxySQL/dbdeployer/common"
+	"github.com/ProxySQL/dbdeployer/defaults"
 	"github.com/ProxySQL/dbdeployer/globals"
 	"github.com/ProxySQL/dbdeployer/providers"
+	"github.com/ProxySQL/dbdeployer/providers/postgresql"
 	"github.com/ProxySQL/dbdeployer/sandbox"
 	"github.com/spf13/cobra"
 )
 
+func deployMultipleNonMySQL(cmd *cobra.Command, args []string, providerName string) {
+	flags := cmd.Flags()
+	version := args[0]
+	nodes, _ := flags.GetInt(globals.NodesLabel)
+
+	p, err := providers.DefaultRegistry.Get(providerName)
+	if err != nil {
+		common.Exitf(1, "provider error: %s", err)
+	}
+
+	flavor, _ := flags.GetString(globals.FlavorLabel)
+	if flavor != "" {
+		common.Exitf(1, "--flavor is only valid with --provider=mysql")
+	}
+
+	if !providers.ContainsString(p.SupportedTopologies(), "multiple") {
+		common.Exitf(1, "provider %q does not support topology \"multiple\"\nSupported topologies: %s",
+			providerName, strings.Join(p.SupportedTopologies(), ", "))
+	}
+
+	if err := p.ValidateVersion(version); err != nil {
+		common.Exitf(1, "version validation failed: %s", err)
+	}
+
+	if _, err := p.FindBinary(version); err != nil {
+		common.Exitf(1, "binaries not found: %s", err)
+	}
+
+	basePort := p.DefaultPorts().BasePort
+	if providerName == "postgresql" {
+		basePort, _ = postgresql.VersionToPort(version)
+	}
+
+	sandboxHome := defaults.Defaults().SandboxHome
+	topologyDir := path.Join(sandboxHome, fmt.Sprintf("%s_multi_%d", providerName, basePort))
+	if common.DirExists(topologyDir) {
+		common.Exitf(1, "sandbox directory %s already exists", topologyDir)
+	}
+	os.MkdirAll(topologyDir, 0755)
+
+	skipStart, _ := flags.GetBool(globals.SkipStartLabel)
+
+	for i := 1; i <= nodes; i++ {
+		port := basePort + i
+		freePort, err := common.FindFreePort(port, []int{}, 1)
+		if err == nil {
+			port = freePort
+		}
+
+		nodeDir := path.Join(topologyDir, fmt.Sprintf("node%d", i))
+		config := providers.SandboxConfig{
+			Version: version,
+			Dir:     nodeDir,
+			Port:    port,
+			Host:    "127.0.0.1",
+			DbUser:  "postgres",
+			Options: map[string]string{},
+		}
+
+		if _, err := p.CreateSandbox(config); err != nil {
+			common.Exitf(1, "error creating node %d: %s", i, err)
+		}
+
+		if !skipStart {
+			if err := p.StartSandbox(nodeDir); err != nil {
+				common.Exitf(1, "error starting node %d: %s", i, err)
+			}
+		}
+
+		fmt.Printf("  Node %d deployed in %s (port: %d)\n", i, nodeDir, port)
+	}
+
+	fmt.Printf("%s multiple sandbox (%d nodes) deployed in %s\n", providerName, nodes, topologyDir)
+}
+
 func multipleSandbox(cmd *cobra.Command, args []string) {
+	flags := cmd.Flags()
+	providerName, _ := flags.GetString(globals.ProviderLabel)
+
+	if providerName != "mysql" {
+		deployMultipleNonMySQL(cmd, args, providerName)
+		return
+	}
+
 	var sd sandbox.SandboxDef
 	common.CheckOrigin(args)
-	flags := cmd.Flags()
 	sd, err := fillSandboxDefinition(cmd, args, false)
 	common.ErrCheckExitf(err, 1, "error filling sandbox definition")
 	// Validate version with provider
@@ -69,4 +158,5 @@
 func init() {
 	deployCmd.AddCommand(multipleCmd)
 	multipleCmd.PersistentFlags().IntP(globals.NodesLabel, "n", globals.NodesValue, "How many nodes will be installed")
+	multipleCmd.PersistentFlags().String(globals.ProviderLabel, globals.ProviderValue, "Database provider (mysql, postgresql)")
 }