Restore code for handling launch of unmanaged PG (#4371)

* restore code for handling launch of unmanaged PG

* don't fetch LD client from ctx (there doesn't seem to be one there), build a new service client instead

Author: asib

internal/command/launch/cmd.go

@@ -23,6 +23,7 @@ import (
 	"github.com/superfly/flyctl/internal/flag"
 	"github.com/superfly/flyctl/internal/flyerr"
 	"github.com/superfly/flyctl/internal/flyutil"
+	"github.com/superfly/flyctl/internal/launchdarkly"
 	"github.com/superfly/flyctl/internal/metrics"
 	"github.com/superfly/flyctl/internal/prompt"
 	"github.com/superfly/flyctl/internal/state"
@@ -40,7 +41,7 @@ func New() (cmd *cobra.Command) {
 	cmd = command.New("launch", short, long, run, command.RequireSession, command.RequireUiex, command.LoadAppConfigIfPresent)
 	cmd.Args = cobra.NoArgs
 
-	flag.Add(cmd,
+	flags := []flag.Flag{
 		// Since launch can perform a deployment, we offer the full set of deployment flags for those using
 		// the launch command in CI environments. We may want to rescind this decision down the line, because
 		// the list of flags is long, but it follows from the precedent of already offering some deployment flags.
@@ -118,11 +119,6 @@ func New() (cmd *cobra.Command) {
 			Description: "Skip automatically provisioning a database",
 			Default:     false,
 		},
-		flag.Bool{
-			Name:        "db",
-			Description: "Force provisioning a managed Postgres database",
-			Default:     false,
-		},
 		flag.Bool{
 			Name:        "no-redis",
 			Description: "Skip automatically provisioning a Redis instance",
@@ -150,7 +146,23 @@ func New() (cmd *cobra.Command) {
 			Description: "Automatically suspend the app after a period of inactivity. Valid values are 'off', 'stop', and 'suspend",
 			Default:     "stop",
 		},
-	)
+	}
+
+	ldClient, err := launchdarkly.NewServiceClient()
+	if err != nil {
+		return nil
+	}
+
+	managedPostgresEnabled := ldClient.ManagedPostgresEnabled()
+	if managedPostgresEnabled {
+		flags = append(flags, flag.Bool{
+			Name:        "db",
+			Description: "Force provisioning a managed Postgres database",
+			Default:     false,
+		})
+	}
+
+	flag.Add(cmd, flags...)
 
 	cmd.AddCommand(NewPlan())
 

internal/command/launch/describe_plan.go

@@ -17,7 +17,6 @@ import (
 const descriptionNone = "<none>"
 
 func describePostgresPlan(launchPlan *plan.LaunchPlan) (string, error) {
-
 	switch provider := launchPlan.Postgres.Provider().(type) {
 	case *plan.FlyPostgresPlan:
 		return describeFlyPostgresPlan(provider)

internal/command/launch/launch_databases.go

@@ -7,10 +7,12 @@ import (
 
 	"github.com/samber/lo"
 	fly "github.com/superfly/fly-go"
+	"github.com/superfly/flyctl/flypg"
 	"github.com/superfly/flyctl/gql"
 	extensions_core "github.com/superfly/flyctl/internal/command/extensions/core"
 	"github.com/superfly/flyctl/internal/command/launch/plan"
 	"github.com/superfly/flyctl/internal/command/mpg"
+	"github.com/superfly/flyctl/internal/command/postgres"
 	"github.com/superfly/flyctl/internal/command/redis"
 	"github.com/superfly/flyctl/internal/flyutil"
 	"github.com/superfly/flyctl/internal/uiex"
@@ -74,124 +76,90 @@ func (state *launchState) createDatabases(ctx context.Context) error {
 
 func (state *launchState) createFlyPostgres(ctx context.Context) error {
 	var (
-		io         = iostreams.FromContext(ctx)
-		pgPlan     = state.Plan.Postgres.FlyPostgres
-		uiexClient = uiexutil.ClientFromContext(ctx)
+		pgPlan    = state.Plan.Postgres.FlyPostgres
+		apiClient = flyutil.ClientFromContext(ctx)
+		io        = iostreams.FromContext(ctx)
 	)
 
-	// Get org and region
-	org, err := state.Org(ctx)
-	if err != nil {
-		return err
-	}
-	region, err := state.Region(ctx)
-	if err != nil {
-		return err
-	}
-
-	var slug string
-	if org.Slug == "personal" {
-		genqClient := flyutil.ClientFromContext(ctx).GenqClient()
-
-		// For ui-ex request we need the real org slug
-		var fullOrg *gql.GetOrganizationResponse
-		if fullOrg, err = gql.GetOrganization(ctx, genqClient, org.Slug); err != nil {
-			return fmt.Errorf("failed fetching org: %w", err)
-		}
-
-		slug = fullOrg.Organization.RawSlug
-	} else {
-		slug = org.Slug
-	}
-
-	// Create new managed Postgres cluster
-	input := uiex.CreateClusterInput{
-		Name:    pgPlan.AppName,
-		Region:  region.Code,
-		Plan:    "basic", // Default plan for now
-		OrgSlug: slug,
-	}
-
-	fmt.Fprintf(io.Out, "Provisioning Postgres cluster...\n")
+	attachToExisting := false
 
-	response, err := uiexClient.CreateCluster(ctx, input)
-	if err != nil {
-		return fmt.Errorf("failed creating managed postgres cluster: %w", err)
+	if pgPlan.AppName == "" {
+		pgPlan.AppName = fmt.Sprintf("%s-db", state.appConfig.AppName)
 	}
 
-	// Wait for cluster to be ready
-	fmt.Fprintf(io.Out, "Waiting for cluster %s (%s) to be ready...\n", pgPlan.AppName, response.Data.Id)
-	fmt.Fprintf(io.Out, "If this is taking too long, you can press Ctrl+C to continue with deployment.\n")
-	fmt.Fprintf(io.Out, "You can check the status later with 'mpg status' and attach with 'mpg attach'.\n")
-
-	// Create a separate context for the wait loop that won't propagate cancellation
-	waitCtx := context.Background()
-	waitCtx, cancel := context.WithCancel(waitCtx)
-	defer cancel()
-
-	// Channel to signal when cluster is ready
-	ready := make(chan bool, 1)
-	errChan := make(chan error, 1)
-
-	// Start the wait loop in a goroutine
-	go func() {
-		for {
-			select {
-			case <-waitCtx.Done():
-				return
-			default:
-				cluster, err := uiexClient.GetManagedClusterById(ctx, response.Data.Id)
-				if err != nil {
-					errChan <- fmt.Errorf("failed checking cluster status: %w", err)
-					return
-				}
-
-				if cluster.Data.Status == "ready" {
-					ready <- true
-					return
-				}
-
-				if cluster.Data.Status == "error" {
-					errChan <- fmt.Errorf("cluster creation failed")
-					return
-				}
-
-				time.Sleep(5 * time.Second)
+	if apps, err := apiClient.GetApps(ctx, nil); err == nil {
+		for _, app := range apps {
+			if app.Name == pgPlan.AppName {
+				attachToExisting = true
 			}
 		}
-	}()
-
-	// Wait for either ready signal, error, or context cancellation
-	select {
-	case <-ready:
-		// Cluster is ready, continue with user creation
-	case err := <-errChan:
-		return err
-	case <-ctx.Done():
-		fmt.Fprintf(io.Out, "\nContinuing with deployment. You can check the status later with 'mpg status' and attach with 'mpg attach'.\n")
-		// Continue with deployment even if cluster isn't ready
-		return nil
 	}
 
-	// Get the cluster credentials
-	cluster, err := uiexClient.GetManagedClusterById(ctx, response.Data.Id)
-	if err != nil {
-		return fmt.Errorf("failed retrieving cluster credentials: %w", err)
-	}
+	if attachToExisting {
+		// If we try to attach to a PG cluster with the usual username
+		// format, we'll get an error (since that username already exists)
+		// by generating a new username with a sufficiently random number
+		// (in this case, the nanon second that the database is being attached)
+		currentTime := time.Now().Nanosecond()
+		dbUser := fmt.Sprintf("%s-%d", pgPlan.AppName, currentTime)
 
-	// Set the connection string as a secret
-	secrets := map[string]string{
-		"DATABASE_URL": cluster.Credentials.ConnectionUri,
-	}
+		err := postgres.AttachCluster(ctx, postgres.AttachParams{
+			PgAppName: pgPlan.AppName,
+			AppName:   state.Plan.AppName,
+			DbUser:    dbUser,
+		})
 
-	client := flyutil.ClientFromContext(ctx)
-	if _, err := client.SetSecrets(ctx, state.Plan.AppName, secrets); err != nil {
-		return fmt.Errorf("failed setting database secrets: %w", err)
+		if err != nil {
+			msg := "Failed attaching %s to the Postgres cluster %s: %s.\nTry attaching manually with 'fly postgres attach --app %s %s'\n"
+			fmt.Fprintf(io.Out, msg, state.Plan.AppName, pgPlan.AppName, err, state.Plan.AppName, pgPlan.AppName)
+			return err
+		} else {
+			fmt.Fprintf(io.Out, "Postgres cluster %s is now attached to %s\n", pgPlan.AppName, state.Plan.AppName)
+		}
+	} else {
+		// Create new PG cluster
+		org, err := state.Org(ctx)
+		if err != nil {
+			return err
+		}
+		region, err := state.Region(ctx)
+		if err != nil {
+			return err
+		}
+		err = postgres.CreateCluster(ctx, org, &region, &postgres.ClusterParams{
+			PostgresConfiguration: postgres.PostgresConfiguration{
+				Name:               pgPlan.AppName,
+				DiskGb:             pgPlan.DiskSizeGB,
+				InitialClusterSize: pgPlan.Nodes,
+				VMSize:             pgPlan.VmSize,
+				MemoryMb:           pgPlan.VmRam,
+			},
+			ScaleToZero: &pgPlan.AutoStop,
+			Autostart:   true, // TODO(Ali): Do we want this?
+			Manager:     flypg.ReplicationManager,
+		})
+		if err != nil {
+			fmt.Fprintf(io.Out, "Failed creating the Postgres cluster %s: %s\n", pgPlan.AppName, err)
+		} else {
+			err = postgres.AttachCluster(ctx, postgres.AttachParams{
+				PgAppName: pgPlan.AppName,
+				AppName:   state.Plan.AppName,
+				SuperUser: true,
+			})
+
+			if err != nil {
+				msg := "Failed attaching %s to the Postgres cluster %s: %s.\nTry attaching manually with 'fly postgres attach --app %s %s'\n"
+				fmt.Fprintf(io.Out, msg, state.Plan.AppName, pgPlan.AppName, err, state.Plan.AppName, pgPlan.AppName)
+			} else {
+				fmt.Fprintf(io.Out, "Postgres cluster %s is now attached to %s\n", pgPlan.AppName, state.Plan.AppName)
+			}
+		}
+		if err != nil {
+			const msg = "Error creating Postgres database. Be warned that this may affect deploys"
+			fmt.Fprintln(io.Out, io.ColorScheme().Red(msg))
+		}
 	}
 
-	fmt.Fprintf(io.Out, "Postgres cluster %s is ready and attached to %s\n", response.Data.Id, state.Plan.AppName)
-	fmt.Fprintf(io.Out, "The following secret was added to %s:\n  DATABASE_URL=%s\n", state.Plan.AppName, cluster.Credentials.ConnectionUri)
-
 	return nil
 }
 

internal/command/launch/plan/postgres.go

@@ -26,7 +26,18 @@ func (p *PostgresPlan) Provider() any {
 	return nil
 }
 
-func DefaultPostgres(plan *LaunchPlan) PostgresPlan {
+func DefaultPostgres(plan *LaunchPlan, mpgEnabled bool) PostgresPlan {
+	var vmRam, diskSizeGb, price int
+	if mpgEnabled {
+		vmRam = 1024 // 1GB RAM for basic plan
+		diskSizeGb = 10
+		price = 38
+	} else {
+		vmRam = 256
+		diskSizeGb = 1
+		price = -1
+	}
+
 	return PostgresPlan{
 		// TODO: Once supabase is GA, we want to default to Supabase
 		FlyPostgres: &FlyPostgresPlan{
@@ -36,10 +47,10 @@ func DefaultPostgres(plan *LaunchPlan) PostgresPlan {
 			//        so it constructs the name on-the-spot each time it needs it)
 			AppName:    plan.AppName + "-db",
 			VmSize:     "shared-cpu-1x",
-			VmRam:      1024, // 1GB RAM for basic plan
+			VmRam:      vmRam,
 			Nodes:      1,
-			DiskSizeGB: 10,
-			Price:      38,
+			DiskSizeGB: diskSizeGb,
+			Price:      price,
 		},
 	}
 }

internal/command/launch/plan_builder.go

@@ -22,6 +22,7 @@ import (
 	"github.com/superfly/flyctl/internal/flyerr"
 	"github.com/superfly/flyctl/internal/flyutil"
 	"github.com/superfly/flyctl/internal/haikunator"
+	"github.com/superfly/flyctl/internal/launchdarkly"
 	"github.com/superfly/flyctl/internal/prompt"
 	"github.com/superfly/flyctl/iostreams"
 	"github.com/superfly/flyctl/scanner"
@@ -224,12 +225,18 @@ func buildManifest(ctx context.Context, parentConfig *appconfig.Config, recovera
 	}
 
 	if srcInfo != nil {
+		ldClient, err := launchdarkly.NewServiceClient()
+		if err != nil {
+			return nil, nil, err
+		}
+		mpgEnabled := ldClient.ManagedPostgresEnabled()
+
 		lp.ScannerFamily = srcInfo.Family
 		const scannerSource = "determined from app source"
 		if !flag.GetBool(ctx, "no-db") {
 			switch srcInfo.DatabaseDesired {
 			case scanner.DatabaseKindPostgres:
-				lp.Postgres = plan.DefaultPostgres(lp)
+				lp.Postgres = plan.DefaultPostgres(lp, mpgEnabled)
 				planSource.postgresSource = scannerSource
 			case scanner.DatabaseKindMySQL:
 				// TODO
@@ -239,7 +246,7 @@ func buildManifest(ctx context.Context, parentConfig *appconfig.Config, recovera
 		}
 		// Force Postgres provisioning if --db flag is set
 		if flag.GetBool(ctx, "db") {
-			lp.Postgres = plan.DefaultPostgres(lp)
+			lp.Postgres = plan.DefaultPostgres(lp, mpgEnabled)
 			planSource.postgresSource = "forced by --db flag"
 		}
 		if !flag.GetBool(ctx, "no-redis") && srcInfo.RedisDesired {

internal/launchdarkly/launchdarkly.go

@@ -76,6 +76,22 @@ func NewClient(ctx context.Context, userInfo UserInfo) (*Client, error) {
 	return ldClient, nil
 }
 
+func NewServiceClient() (*Client, error) {
+	ctx := context.Background()
+	_, span := tracing.GetTracer().Start(ctx, "new_flyctl_feature_flag_client")
+	defer span.End()
+
+	ldClient := &Client{ldContext: ldcontext.NewWithKind(ldcontext.Kind("service"), "flyctl"), flagsMutex: sync.Mutex{}}
+
+	timeoutCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
+	defer cancel()
+	// we don't really care if this errors or not, but it's good to at least try
+	_ = ldClient.updateFeatureFlags(timeoutCtx)
+
+	go ldClient.monitor(ctx)
+	return ldClient, nil
+}
+
 func (ldClient *Client) monitor(ctx context.Context) {
 	logger := logger.MaybeFromContext(ctx)
 
@@ -177,3 +193,17 @@ func (ldClient *Client) updateFeatureFlags(ctx context.Context) error {
 
 	return nil
 }
+
+func (ldClient *Client) ManagedPostgresEnabled() bool {
+	choice := ldClient.getLaunchPostgresChoiceFlag()
+	return choice == "mpg" || choice == "both"
+}
+
+func (ldClient *Client) UnmanagedPostgresEnabled() bool {
+	choice := ldClient.getLaunchPostgresChoiceFlag()
+	return choice == "unmanaged-pg" || choice == "both"
+}
+
+func (ldClient *Client) getLaunchPostgresChoiceFlag() string {
+	return ldClient.GetFeatureFlagValue("launch-postgres-choice", "unmanaged-pg").(string)
+}