feature: Waypoint Server Upgrade command for supported server platforms

internal/cli/install.go

@@ -366,6 +366,6 @@ deployments. If this is incorrect, manually set it using the CLI command
 "waypoint server config-set".
 
 Advertise Address: %[2]s
-Web UI Address: %[3]s
+ Web UI Address: %[3]s
 `)
 )

internal/cli/main.go

@@ -294,6 +294,11 @@ func Commands(
  baseCommand: baseCommand,
  }, nil
  },
+ "server upgrade": func() (cli.Command, error) {
+ return &ServerUpgradeCommand{
+ baseCommand: baseCommand,
+ }, nil
+ },
  "plugin": func() (cli.Command, error) {
  return &PluginCommand{
  baseCommand: baseCommand,

internal/cli/server_upgrade.go

@@ -0,0 +1,364 @@
+package cli
+
+import (
+ "fmt"
+ "os"
+ "strings"
+ "time"
+
+ "github.com/golang/protobuf/ptypes/empty"
+ "github.com/posener/complete"
+
+ "github.com/hashicorp/waypoint-plugin-sdk/terminal"
+ clientpkg "github.com/hashicorp/waypoint/internal/client"
+ "github.com/hashicorp/waypoint/internal/clierrors"
+ "github.com/hashicorp/waypoint/internal/clisnapshot"
+ "github.com/hashicorp/waypoint/internal/pkg/flag"
+ pb "github.com/hashicorp/waypoint/internal/server/gen"
+ "github.com/hashicorp/waypoint/internal/serverclient"
+ "github.com/hashicorp/waypoint/internal/serverinstall"
+)
+
+type ServerUpgradeCommand struct {
+ *baseCommand
+
+ platform string
+ contextName string
+ snapshotName string
+ skipSnapshot bool
+ confirm bool
+}
+
+func (c *ServerUpgradeCommand) Run(args []string) int {
+ ctx := c.Ctx
+ log := c.Log.Named("upgrade")
+ defer c.Close()
+
+ // Initialize. If we fail, we just exit since Init handles the UI.
+ if err := c.Init(
+ WithArgs(args),
+ WithFlags(c.Flags()),
+ WithNoConfig(),
+ ); err != nil {
+ return 1
+ }
+
+ // Error handling from input
+
+ if !c.confirm {
+ c.ui.Output(confirmReqMsg, terminal.WithErrorStyle())
+ return 1
+ }
+
+ if c.platform == "" {
+ c.ui.Output(
+ "A platform is required and must match the server context",
+ terminal.WithErrorStyle(),
+ )
+ return 1
+ }
+
+ p, ok := serverinstall.Platforms[strings.ToLower(c.platform)]
+ if !ok {
+ c.ui.Output(
+ "Error upgrading server on %s: unsupported platform",
+ c.platform,
+ terminal.WithErrorStyle(),
+ )
+
+ return 1
+ }
+
+ // Finish error handling
+
+ // Get Server config to preserve existing configurations from context
+ var ctxName string
+ if c.contextName != "" {
+ ctxName = c.contextName
+ } else {
+ defaultName, err := c.contextStorage.Default()
+ if err != nil {
+ c.ui.Output(
+ "Error getting default context: %s",
+ clierrors.Humanize(err),
+ terminal.WithErrorStyle(),
+ )
+ return 1
+ }
+ ctxName = defaultName
+ }
+
+ originalCfg, err := c.contextStorage.Load(ctxName)
+ if err != nil {
+ c.ui.Output(
+ "Error loading the context %q: %s",
+ ctxName,
+ clierrors.Humanize(err),
+ terminal.WithErrorStyle(),
+ )
+ return 1
+ }
+
+ // Upgrade waypoint server
+ sg := c.ui.StepGroup()
+ defer sg.Wait()
+
+ s := sg.Add("Validating server context: %q", ctxName)
+ defer func() { s.Abort() }()
+
+ conn, err := serverclient.Connect(ctx, serverclient.FromContextConfig(originalCfg))
+ if err != nil {
+ c.ui.Output(
+ "Error connecting with context %q: %s",
+ ctxName,
+ clierrors.Humanize(err),
+ terminal.WithErrorStyle(),
+ )
+ return 1
+ }
+
+ s.Update("Verifying connection is valid for context %q...", ctxName)
+
+ client := pb.NewWaypointClient(conn)
+ // validate API compat here with new clientpkg
+ if _, err := clientpkg.New(ctx,
+ clientpkg.WithLogger(c.Log),
+ clientpkg.WithClient(client),
+ ); err != nil {
+ c.ui.Output(
+ "Error connecting with context %q: %s",
+ ctxName,
+ clierrors.Humanize(err),
+ terminal.WithErrorStyle(),
+ )
+ return 1
+ }
+
+ resp, err := client.GetVersionInfo(ctx, &empty.Empty{})
+ if err != nil {
+ c.ui.Output(
+ "Error retrieving server version info: %s", clierrors.Humanize(err),
+ terminal.WithErrorStyle())
+ return 1
+ }
+
+ initServerVersion := resp.Info.Version
+
+ s.Update("Context %q validated and connected successfully.", ctxName)
+ s.Done()
+
+ s = sg.Add("Starting server snapshots")
+
+ // Snapshot server before upgrade
+ if !c.skipSnapshot {
+ s.Update("Taking server snapshot before upgrading")
+
+ snapshotName := c.snapshotName
+ if c.snapshotName == defaultSnapshotName {
+ // Append timestamps on default snapshot names
+ snapshotName = fmt.Sprintf("%s-%d", c.snapshotName, time.Now().Unix())
+ }
+
+ s.Update("Taking snapshot of server with name: '%s'", snapshotName)
+ writer, err := os.Create(snapshotName)
+ if err != nil {
+ s.Update("Failed to take server snapshot")
+ s.Status(terminal.StatusError)
+ s.Done()
+
+ c.ui.Output(fmt.Sprintf("Error opening output: %s", err), terminal.WithErrorStyle())
+ return 1
+ }
+
+ err = clisnapshot.WriteSnapshot(c.Ctx, c.project.Client(), writer)
+ writer.Close()
+
+ if err != nil {
+ s.Update("Failed to take server snapshot")
+ s.Status(terminal.StatusError)
+ s.Done()
+
+ c.ui.Output(fmt.Sprintf("Error generating Snapshot: %s", err), terminal.WithErrorStyle())
+ return 1
+ }
+
+ s.Update("Snapshot of server written to: '%s'", snapshotName)
+ s.Done()
+ } else {
+ s.Update("Server snapshot disabled on request, this means no snapshot will be taken before upgrades")
+ s.Status(terminal.StatusWarn)
+ s.Done()
+ log.Warn("Server snapshot disabled on request from user, skipping")
+ }
+
+ c.ui.Output("Upgrading...", terminal.WithHeaderStyle())
+
+ c.ui.Output("Waypoint server will now upgrade from version %q",
+ initServerVersion, terminal.WithInfoStyle())
+
+ // Upgrade in place
+ result, err := p.Upgrade(ctx, &serverinstall.InstallOpts{
+ Log: log,
+ UI: c.ui,
+ }, originalCfg.Server)
+ if err != nil {
+ c.ui.Output(
+ "Error upgrading server on %s: %s", c.platform, clierrors.Humanize(err),
+ terminal.WithErrorStyle())
+
+ c.ui.Output(upgradeFailHelp)
+
+ return 1
+ }
+
+ contextConfig := result.Context
+ advertiseAddr := result.AdvertiseAddr
+ httpAddr := result.HTTPAddr
+
+ // We update the context config if the server addr has changed between upgrades
+ if originalCfg.Server.Address != contextConfig.Server.Address {
+ originalCfg.Server.Address = contextConfig.Server.Address
+
+ if err := c.contextStorage.Set(ctxName, originalCfg); err != nil {
+ c.ui.Output(
+ "Error setting the CLI context: %s\n\n%s",
+ clierrors.Humanize(err),
+ errInstallRunning,
+ terminal.WithErrorStyle(),
+ )
+ return 1
+ }
+
+ c.ui.Output("Server address has changed after upgrade. This client will "+
+ "update its context with the new address, however any other clients "+
+ "using this server must manually update their server address listed below "+
+ "or find the address from `waypoint context list` which lists context %q address",
+ ctxName,
+ terminal.WithWarningStyle())
+ }
+
+ // Connect
+ log.Info("connecting to the server so we can verify the server upgrade", "addr", originalCfg.Server.Address)
+ conn, err = serverclient.Connect(ctx,
+ serverclient.FromContextConfig(originalCfg),
+ serverclient.Timeout(5*time.Minute),
+ )
+ if err != nil {
+ c.ui.Output(
+ "Error connecting to server: %s\n\n%s",
+ clierrors.Humanize(err),
+ errInstallRunning,
+ terminal.WithErrorStyle(),
+ )
+ return 1
+ }
+ client = pb.NewWaypointClient(conn)
+
+ resp, err = client.GetVersionInfo(ctx, &empty.Empty{})
+ if err != nil {
+ c.ui.Output(
+ "Error retrieving server version info: %s", clierrors.Humanize(err),
+ terminal.WithErrorStyle())
+ return 1
+ }
+
+ c.ui.Output("\nServer upgrade for platform %q context %q complete!",
+ c.platform, ctxName, terminal.WithSuccessStyle())
+
+ c.ui.Output("Waypoint has finished upgrading the server to version %q\n",
+ resp.Info.Version, terminal.WithSuccessStyle())
+
+ c.ui.Output(addrSuccess, advertiseAddr.Addr, "https://"+httpAddr,
+ terminal.WithSuccessStyle())
+
+ return 0
+}
+
+func (c *ServerUpgradeCommand) Flags() *flag.Sets {
+ return c.flagSet(0, func(set *flag.Sets) {
+ f := set.NewSet("Command Options")
+ f.BoolVar(&flag.BoolVar{
+ Name: "auto-approve",
+ Target: &c.confirm,
+ Default: false,
+ Usage: "Confirm server upgrade.",
+ })
+ f.StringVar(&flag.StringVar{
+ Name: "context-name",
+ Target: &c.contextName,
+ Default: "",
+ Usage: "Waypoint server context to upgrade.",
+ })
+ f.StringVar(&flag.StringVar{
+ Name: "platform",
+ Target: &c.platform,
+ Default: "",
+ Usage: "Platform to upgrade the Waypoint server from.",
+ })
+ f.StringVar(&flag.StringVar{
+ Name: "snapshot-name",
+ Target: &c.snapshotName,
+ Default: defaultSnapshotName,
+ Usage: "Filename to write the snapshot to. If no name is specified, by" +
+ " default a timestamp will be appended to the default snapshot name.",
+ })
+ f.BoolVar(&flag.BoolVar{
+ Name: "skip-snapshot",
+ Target: &c.skipSnapshot,
+ Default: false,
+ Usage: "Skip creating a snapshot of the Waypoint server.",
+ })
+
+ for name, platform := range serverinstall.Platforms {
+ platformSet := set.NewSet(name + " Options")
+ platform.UpgradeFlags(platformSet)
+ }
+ })
+}
+
+func (c *ServerUpgradeCommand) AutocompleteArgs() complete.Predictor {
+ return complete.PredictNothing
+}
+
+func (c *ServerUpgradeCommand) AutocompleteFlags() complete.Flags {
+ return c.Flags().Completions()
+}
+
+func (c *ServerUpgradeCommand) Synopsis() string {
+ return "Upgrades Waypoint server in the current context to the latest version"
+}
+
+func (c *ServerUpgradeCommand) Help() string {
+ return formatHelp(`
+Usage: waypoint server upgrade [options]
+
+ Upgrade Waypoint server in the current context to the latest version or the
+ server image version specified. By default, Waypoint will upgrade to server
+ version "hashicorp/waypoint:latest". Before upgrading, a snapshot of the
+ server will be taken in case of any upgrade failures.
+
+` + c.Flags().Help())
+}
+
+var (
+ defaultSnapshotName = "waypoint-server-snapshot"
+ confirmReqMsg = strings.TrimSpace(`
+Upgrading Waypoint server requires confirmation.
+Rerun the command with '-auto-approve' to continue with the upgrade.
+`)
+ upgradeFailHelp = strings.TrimSpace(`
+Upgrading Waypoint server has failed. To restore from a snapshot, use the command:
+
+waypoint server restore [snapshot-name]
+
+Where 'snapshot-name' is the name of the snapshot taken prior to the upgrade.
+
+More information can be found by runninng 'waypoint server restore -help' or
+following the server maintenence guide for backups and restores:
+https://www.waypointproject.io/docs/server/run/maintenance#backup-restore
+`)
+ addrSuccess = strings.TrimSpace(`
+Advertise Address: %[1]s
+ Web UI Address: %[2]s
+`)
+)