Application maintenance mode

apps.go

@@ -85,6 +85,9 @@ type App struct {
 
 	// The time that this application was created.
 	CreatedAt *time.Time
+
+	// Maintenance defines whether the app is in maintenance mode or not.
+	Maintenance bool
 }
 
 // IsValid returns an error if the app isn't valid.

certs.go

@@ -26,7 +26,7 @@ func (s *certsService) CertsAttach(ctx context.Context, db *gorm.DB, opts CertsA
 		return err
 	}
 
-	if err := s.releases.Restart(ctx, db, app); err != nil {
+	if err := s.releases.ReleaseApp(ctx, db, app, nil); err != nil {
 		if err == ErrNoReleases {
 			return nil
 		}

cmd/emp/info.go

@@ -18,6 +18,7 @@ func runInfo(cmd *Command, args []string) {
 	app, err := client.AppInfo(mustApp())
 	must(err)
 	fmt.Printf("Name: %s\n", app.Name)
-	fmt.Printf("ID:   %s\n", app.Id)
+	fmt.Printf("ID: %s\n", app.Id)
+	fmt.Printf("Maintenance: %s\n", fmtMaintenance(app.Maintenance))
 	fmt.Printf("Cert: %s\n", app.Cert)
 }

cmd/emp/main.go

@@ -150,6 +150,9 @@ var commands = []*Command{
 	cmdGet,
 	cmdLogin,
 	cmdLogout,
+	cmdMaintenance,
+	cmdMaintenanceEnable,
+	cmdMaintenanceDisable,
 	cmdSSL,
 	cmdSSLCertAdd,
 	cmdSSLCertRollback,

cmd/emp/maintenance.go

@@ -0,0 +1,94 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+
+	"github.com/remind101/empire/pkg/heroku"
+)
+
+var cmdMaintenance = &Command{
+	Run:      runMaintenance,
+	Usage:    "maintenance",
+	NeedsApp: true,
+	Category: "app",
+	Short:    "show app maintenance mode" + extra,
+	Long: `
+Maintenance shows the current maintenance mode state of an app.
+Example:
+    $ emp maintenance -a <myapp>
+    enabled
+`,
+}
+
+func runMaintenance(cmd *Command, args []string) {
+	if len(args) != 0 {
+		cmd.PrintUsage()
+		os.Exit(2)
+	}
+	app, err := client.AppInfo(mustApp())
+	must(err)
+	fmt.Println(fmtMaintenance(app.Maintenance))
+}
+
+var cmdMaintenanceEnable = &Command{
+	Run:      maybeMessage(runMaintenanceEnable),
+	Usage:    "maintenance-enable",
+	NeedsApp: true,
+	Category: "app",
+	Short:    "enable maintenance mode" + extra,
+	Long: `
+Enables maintenance mode on an app.
+Example:
+    $ emp maintenance-enable -a <myapp>
+    Enabled maintenance mode on myapp.
+`,
+}
+
+func runMaintenanceEnable(cmd *Command, args []string) {
+	message := getMessage()
+	if len(args) != 0 {
+		cmd.PrintUsage()
+		os.Exit(2)
+	}
+	newmode := true
+	app, err := client.AppUpdate(mustApp(), &heroku.AppUpdateOpts{Maintenance: &newmode}, message)
+	must(err)
+	log.Printf("Enabled maintenance mode on %s.", app.Name)
+}
+
+var cmdMaintenanceDisable = &Command{
+	Run:      maybeMessage(runMaintenanceDisable),
+	Usage:    "maintenance-disable",
+	NeedsApp: true,
+	Category: "app",
+	Short:    "disable maintenance mode" + extra,
+	Long: `
+Disables maintenance mode on an app.
+Example:
+    $ emp maintenance-disable -a <myapp>
+    Disabled maintenance mode on myapp.
+`,
+}
+
+func runMaintenanceDisable(cmd *Command, args []string) {
+	message := getMessage()
+	if len(args) != 0 {
+		cmd.PrintUsage()
+		os.Exit(2)
+	}
+	newmode := false
+	app, err := client.AppUpdate(mustApp(), &heroku.AppUpdateOpts{Maintenance: &newmode}, message)
+	must(err)
+	log.Printf("Disabled maintenance mode on %s.", app.Name)
+}
+
+type fmtMaintenance bool
+
+func (f fmtMaintenance) String() string {
+	if f {
+		return "enabled"
+	}
+	return "disabled"
+}

cmd/emp/rename.go

@@ -22,10 +22,11 @@ Example:
 }
 
 func runRename(cmd *Command, args []string) {
+	message := getMessage()
 	cmd.AssertNumArgsCorrect(args)
 
 	oldname, newname := args[0], args[1]
-	app, err := client.AppUpdate(oldname, &heroku.AppUpdateOpts{Name: &newname})
+	app, err := client.AppUpdate(oldname, &heroku.AppUpdateOpts{Name: &newname}, message)
 	must(err)
 	log.Printf("Renamed %s to %s.", oldname, app.Name)
 	log.Println("Ensure you update your git remote URL.")

empire.go

@@ -250,6 +250,68 @@ func (e *Empire) Config(app *App) (*Config, error) {
 	return c, nil
 }
 
+type SetMaintenanceModeOpts struct {
+	// User performing the action.
+	User *User
+
+	// The associated app.
+	App *App
+
+	// Wheather maintenance mode should be enabled or not.
+	Maintenance bool
+
+	// Commit message
+	Message string
+}
+
+func (opts SetMaintenanceModeOpts) Event() MaintenanceEvent {
+	return MaintenanceEvent{
+		User:        opts.User.Name,
+		App:         opts.App.Name,
+		Maintenance: opts.Maintenance,
+	}
+}
+
+func (opts SetMaintenanceModeOpts) Validate(e *Empire) error {
+	return e.requireMessages(opts.Message)
+}
+
+// SetMaintenanceMode enables or disables "maintenance mode" on the app. When an
+// app is in maintenance mode, all processes will be scaled down to 0. When
+// taken out of maintenance mode, all processes will be scaled up back to their
+// existing values.
+func (e *Empire) SetMaintenanceMode(ctx context.Context, opts SetMaintenanceModeOpts) error {
+	if err := opts.Validate(e); err != nil {
+		return err
+	}
+
+	tx := e.db.Begin()
+
+	app := opts.App
+
+	app.Maintenance = opts.Maintenance
+
+	if err := appsUpdate(tx, app); err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	if err := e.releases.ReleaseApp(ctx, tx, app, nil); err != nil {
+		tx.Rollback()
+		if err == ErrNoReleases {
+			return nil
+		}
+
+		return err
+	}
+
+	if err := tx.Commit().Error; err != nil {
+		return err
+	}
+
+	return e.PublishEvent(opts.Event())
+}
+
 // SetOpts are options provided when setting new config vars on an app.
 type SetOpts struct {
 	// User performing the action.

events.go

@@ -86,6 +86,30 @@ func (e RestartEvent) GetApp() *App {
 	return e.app
 }
 
+type MaintenanceEvent struct {
+	User        string
+	App         string
+	Maintenance bool
+
+	app *App
+}
+
+func (e MaintenanceEvent) Event() string {
+	return "maintenance"
+}
+
+func (e MaintenanceEvent) String() string {
+	state := "disabled"
+	if e.Maintenance {
+		state = "enabled"
+	}
+	return fmt.Sprintf("%s %s maintenance mode on %s", e.User, state, e.App)
+}
+
+func (e MaintenanceEvent) GetApp() *App {
+	return e.app
+}
+
 type ScaleEventUpdate struct {
 	Process             string
 	Quantity            int

events_test.go

@@ -26,6 +26,10 @@ func TestEvents_String(t *testing.T) {
 		{RestartEvent{User: "ejholmes", App: "acme-inc", Message: "commit message"}, "ejholmes restarted acme-inc: 'commit message'"},
 		{RestartEvent{User: "ejholmes", App: "acme-inc", PID: "abcd", Message: "commit message"}, "ejholmes restarted `abcd` on acme-inc: 'commit message'"},
 
+		// MaintenanceEvent
+		{MaintenanceEvent{User: "ejholmes", App: "acme-inc", Maintenance: false}, "ejholmes disabled maintenance mode on acme-inc"},
+		{MaintenanceEvent{User: "ejholmes", App: "acme-inc", Maintenance: true}, "ejholmes enabled maintenance mode on acme-inc"},
+
 		// ScaleEvent
 		{ScaleEvent{
 			User: "ejholmes",

migrations.go

@@ -612,6 +612,23 @@ ALTER TABLE apps ADD COLUMN exposure TEXT NOT NULL default 'private'`,
 			`ALTER TABLE apps ADD COLUMN cert text`,
 		}),
 	},
+
+	// This migration migrates the cert storage from a single string column
+	// to a mapping of process name to cert name.
+	{
+		ID: 20,
+		Up: func(tx *sql.Tx) error {
+			_, err := tx.Exec(`ALTER TABLE apps ADD COLUMN maintenance bool NOT NULL DEFAULT false`)
+			if err != nil {
+				return fmt.Errorf("error adding maintenance column: %v", err)
+			}
+
+			return nil
+		},
+		Down: migrate.Queries([]string{
+			`ALTER TABLE apps DROP COLUMN maintenance`,
+		}),
+	},
 }
 
 // latestSchema returns the schema version that this version of Empire should be

migrations_test.go

@@ -30,7 +30,7 @@ func TestMigrations(t *testing.T) {
 }
 
 func TestLatestSchema(t *testing.T) {
-	assert.Equal(t, 19, latestSchema())
+	assert.Equal(t, 20, latestSchema())
 }
 
 func TestNoDuplicateMigrations(t *testing.T) {

pkg/heroku/app.go

@@ -128,9 +128,10 @@ func (c *Client) AppList(lr *ListRange) ([]App, error) {
 //
 // appIdentity is the unique identifier of the App. options is the struct of
 // optional parameters for this action.
-func (c *Client) AppUpdate(appIdentity string, options *AppUpdateOpts) (*App, error) {
+func (c *Client) AppUpdate(appIdentity string, options *AppUpdateOpts, message string) (*App, error) {
+	rh := RequestHeaders{CommitMessage: message}
 	var appRes App
-	return &appRes, c.Patch(&appRes, "/apps/"+appIdentity, options)
+	return &appRes, c.PatchWithHeaders(&appRes, "/apps/"+appIdentity, options, rh.Headers())
 }
 
 // AppUpdateOpts holds the optional parameters for AppUpdate

pkg/heroku/app_test.go

@@ -280,7 +280,7 @@ func TestAppUpdateSuccess(t *testing.T) {
 	ts, handler, c := newTestServerAndClient(t, appUpdateRequest)
 	defer ts.Close()
 
-	app, err := c.AppUpdate("example", &appUpdateRequestOptions)
+	app, err := c.AppUpdate("example", &appUpdateRequestOptions, "message")
 	if err != nil {
 		t.Fatal(err)
 	}

releases.go

@@ -168,6 +168,23 @@ func (s *releasesService) Release(ctx context.Context, release *Release, ss twel
 	return s.Scheduler.Submit(ctx, a, ss)
 }
 
+func (s *releasesService) ReleaseApp(ctx context.Context, db *gorm.DB, app *App, ss twelvefactor.StatusStream) error {
+	release, err := releasesFind(db, ReleasesQuery{App: app})
+	if err != nil {
+		if err == gorm.RecordNotFound {
+			return ErrNoReleases
+		}
+
+		return err
+	}
+
+	if release == nil {
+		return nil
+	}
+
+	return s.Release(ctx, release, ss)
+}
+
 // Restart will find the last release for an app and submit it to the scheduler
 // to restart the app.
 func (s *releasesService) Restart(ctx context.Context, db *gorm.DB, app *App) error {
@@ -361,13 +378,18 @@ func newSchedulerProcess(release *Release, name string, p Process) (*twelvefacto
 		}
 	}
 
+	quantity := p.Quantity
+	if release.App.Maintenance {
+		quantity = 0
+	}
+
 	return &twelvefactor.Process{
 		Type:      name,
 		Env:       env,
 		Labels:    labels,
 		Command:   []string(p.Command),
 		Image:     release.Slug.Image,
-		Quantity:  p.Quantity,
+		Quantity:  quantity,
 		Memory:    uint(p.Memory),
 		CPUShares: uint(p.CPUShare),
 		Nproc:     uint(p.Nproc),