diff --git a/cmd/uncloud/machine/init.go b/cmd/uncloud/machine/init.go index d6c8d317..0464b536 100644 --- a/cmd/uncloud/machine/init.go +++ b/cmd/uncloud/machine/init.go @@ -1,7 +1,9 @@ package machine import ( + "context" "fmt" + "github.com/docker/compose/v2/pkg/progress" "github.com/spf13/cobra" "net/netip" "uncloud/internal/cli" @@ -12,6 +14,7 @@ import ( type initOptions struct { name string network string + noCaddy bool sshKey string cluster string } @@ -39,19 +42,22 @@ func NewInitCommand() *cobra.Command { KeyPath: opts.sshKey, } } - netPrefix, err := netip.ParsePrefix(opts.network) - if err != nil { - return fmt.Errorf("parse network CIDR: %w", err) - } - return uncli.InitCluster(cmd.Context(), remoteMachine, opts.cluster, opts.name, netPrefix) + return initCluster(cmd.Context(), uncli, remoteMachine, opts) }, } - cmd.Flags().StringVarP(&opts.name, "name", "n", "", "Assign a name to the machine.") + cmd.Flags().StringVarP( + &opts.name, "name", "n", "", + "Assign a name to the machine.", + ) cmd.Flags().StringVar( &opts.network, "network", cluster.DefaultNetwork.String(), "IPv4 network CIDR to use for machines and services.", ) + cmd.Flags().BoolVar( + &opts.noCaddy, "no-caddy", false, + "Don't deploy Caddy reverse proxy service to the machine.", + ) cmd.Flags().StringVarP( &opts.sshKey, "ssh-key", "i", "", "path to SSH private key for SSH remote login. (default ~/.ssh/id_*)", @@ -63,3 +69,37 @@ func NewInitCommand() *cobra.Command { return cmd } + +func initCluster(ctx context.Context, uncli *cli.CLI, remoteMachine *cli.RemoteMachine, opts initOptions) error { + netPrefix, err := netip.ParsePrefix(opts.network) + if err != nil { + return fmt.Errorf("parse network CIDR: %w", err) + } + + client, err := uncli.InitCluster(ctx, remoteMachine, opts.cluster, opts.name, netPrefix) + if err != nil { + return err + } + defer client.Close() + + if opts.noCaddy { + return nil + } + + // Deploy the Caddy service to the initialised machine. + // The creation of a deployment plan talks to cluster API. Since the API needs a few moments to become available + // after cluster initialisation, we keep the user informed during this wait. + fmt.Println("Waiting for the cluster to be ready...") + + d, err := client.NewCaddyDeployment("", nil) + if err != nil { + return fmt.Errorf("create caddy deployment: %w", err) + } + + return progress.RunWithTitle(ctx, func(ctx context.Context) error { + if _, err = d.Run(ctx); err != nil { + return fmt.Errorf("deploy caddy: %w", err) + } + return nil + }, uncli.ProgressOut(), fmt.Sprintf("Deploying service %s", d.Spec.Name)) +} diff --git a/internal/cli/cli.go b/internal/cli/cli.go index 3a95249e..4cc95935 100644 --- a/internal/cli/cli.go +++ b/internal/cli/cli.go @@ -109,40 +109,47 @@ func (cli *CLI) ConnectCluster(ctx context.Context, clusterName string) (*client return nil, errors.New("no valid connection configuration found for the cluster") } +// InitCluster initialises a new cluster on a remote machine and returns a client to interact with the cluster. +// The client should be closed after use by the caller. func (cli *CLI) InitCluster( ctx context.Context, remoteMachine *RemoteMachine, clusterName, machineName string, netPrefix netip.Prefix, -) error { +) (*client.Client, error) { if remoteMachine != nil { return cli.initRemoteMachine(ctx, *remoteMachine, clusterName, machineName, netPrefix) } // TODO: implement local machine initialisation - return fmt.Errorf("local machine initialisation is not implemented yet") + return nil, fmt.Errorf("local machine initialisation is not implemented yet") } func (cli *CLI) initRemoteMachine( ctx context.Context, remoteMachine RemoteMachine, clusterName, machineName string, netPrefix netip.Prefix, -) error { +) (*client.Client, error) { if clusterName == "" { clusterName = defaultClusterName } if _, ok := cli.config.Clusters[clusterName]; ok { - return fmt.Errorf("cluster %q already exists", clusterName) + return nil, fmt.Errorf("cluster %q already exists", clusterName) } machineClient, err := cli.provisionRemoteMachine(ctx, remoteMachine) if err != nil { - return err + return nil, err } - defer machineClient.Close() + // Ensure machineClient is closed on error. + defer func() { + if err != nil { + machineClient.Close() + } + }() // Check if the machine is already initialised as a cluster member and prompt the user to reset it first. minfo, err := machineClient.Inspect(ctx, &emptypb.Empty{}) if err != nil { - return fmt.Errorf("inspect machine: %w", err) + return nil, fmt.Errorf("inspect machine: %w", err) } if minfo.Id != "" { if err = cli.promptResetMachine(); err != nil { - return err + return nil, err } } @@ -152,17 +159,17 @@ func (cli *CLI) initRemoteMachine( } resp, err := machineClient.InitCluster(ctx, req) if err != nil { - return fmt.Errorf("init cluster: %w", err) + return nil, fmt.Errorf("init cluster: %w", err) } fmt.Printf("Cluster %q initialised with machine %q\n", clusterName, resp.Machine.Name) if err = cli.CreateCluster(clusterName); err != nil { - return fmt.Errorf("save cluster to config: %w", err) + return nil, fmt.Errorf("save cluster to config: %w", err) } // Set the current cluster to the just created one if it is the only cluster in the config. if len(cli.config.Clusters) == 1 { if err = cli.SetCurrentCluster(clusterName); err != nil { - return fmt.Errorf("set current cluster: %w", err) + return nil, fmt.Errorf("set current cluster: %w", err) } } @@ -173,9 +180,9 @@ func (cli *CLI) initRemoteMachine( } cli.config.Clusters[clusterName].Connections = append(cli.config.Clusters[clusterName].Connections, connCfg) if err = cli.config.Save(); err != nil { - return fmt.Errorf("save config: %w", err) + return nil, fmt.Errorf("save config: %w", err) } - return nil + return machineClient, nil } func (cli *CLI) AddMachine(ctx context.Context, remoteMachine RemoteMachine, clusterName, machineName string) error { diff --git a/internal/cli/client/caddy.go b/internal/cli/client/caddy.go index f08e5c40..80b6cda2 100644 --- a/internal/cli/client/caddy.go +++ b/internal/cli/client/caddy.go @@ -32,6 +32,7 @@ func (cli *Client) NewCaddyDeployment(image string, filter MachineFilter) (*Depl image = reference.FamiliarString(latest) } + // TODO: set restart policy to always. https://github.com/psviderski/uncloud/issues/26 spec := api.ServiceSpec{ Container: api.ContainerSpec{ Command: []string{"caddy", "run", "-c", "/config/caddy.json", "--watch"}, diff --git a/internal/cli/client/deploy.go b/internal/cli/client/deploy.go index 7e7ff173..793e8ef2 100644 --- a/internal/cli/client/deploy.go +++ b/internal/cli/client/deploy.go @@ -129,7 +129,7 @@ func (d *Deployment) Validate(ctx context.Context) error { func (d *Deployment) Run(ctx context.Context) (string, error) { plan, err := d.Plan(ctx) if err != nil { - return "", fmt.Errorf("plan: %w", err) + return "", fmt.Errorf("create plan: %w", err) } return plan.ServiceID, plan.Execute(ctx, d.cli)