Merge pull request #3106 from johanneswuerbach/mange-all-units

feat(deisctl): start / stop all installed units

Author: carmstrong

deisctl/Makefile

@@ -32,14 +32,16 @@ install:
 	godep go install -v .
 
 setup-root-gotools:
-	sudo GOPATH=/tmp/tmpGOPATH go get -u -v code.google.com/p/go.tools/cmd/cover
-	sudo GOPATH=/tmp/tmpGOPATH go get -u -v code.google.com/p/go.tools/cmd/vet
+	sudo GOPATH=/tmp/tmpGOPATH go get -u -v golang.org/x/tools/cmd/cover
+	sudo GOPATH=/tmp/tmpGOPATH go get -u -v golang.org/x/tools/cmd/vet
 	sudo rm -rf /tmp/tmpGOPATH
 
 setup-gotools:
-	go get -v github.com/golang/lint/golint
+	go get -u github.com/golang/lint/golint
+	go get -u golang.org/x/tools/cmd/cover
+	go get -u golang.org/x/tools/cmd/vet
 
-test: test-style test-unit test-functional
+test: test-style test-unit
 
 test-style:
 # display output, then check

deisctl/backend/fleet/destroy.go

@@ -9,7 +9,14 @@ import (
 
 // Destroy units for a given target
 func (c *FleetClient) Destroy(targets []string, wg *sync.WaitGroup, outchan chan string, errchan chan error) {
-	for _, target := range targets {
+	// expand @* targets
+	expandedTargets, err := expandTargets(c, targets)
+	if err != nil {
+		errchan <- err
+		return
+	}
+
+	for _, target := range expandedTargets {
 		wg.Add(1)
 		go doDestroy(c, target, wg, outchan, errchan)
 	}

deisctl/backend/fleet/start.go

@@ -10,7 +10,14 @@ import (
 
 // Start units and wait for their desiredState
 func (c *FleetClient) Start(targets []string, wg *sync.WaitGroup, outchan chan string, errchan chan error) {
-	for _, target := range targets {
+	// expand @* targets
+	expandedTargets, err := expandTargets(c, targets)
+	if err != nil {
+		errchan <- err
+		return
+	}
+
+	for _, target := range expandedTargets {
 		wg.Add(1)
 		go doStart(c, target, wg, outchan, errchan)
 	}

deisctl/backend/fleet/stop.go

@@ -10,7 +10,14 @@ import (
 
 // Stop units and wait for their desiredState
 func (c *FleetClient) Stop(targets []string, wg *sync.WaitGroup, outchan chan string, errchan chan error) {
-	for _, target := range targets {
+	// expand @* targets
+	expandedTargets, err := expandTargets(c, targets)
+	if err != nil {
+		errchan <- err
+		return
+	}
+
+	for _, target := range expandedTargets {
 		wg.Add(1)
 		go doStop(c, target, wg, outchan, errchan)
 	}

deisctl/backend/fleet/unit.go

@@ -78,6 +78,7 @@ func NewUnit(component string) (uf *unit.UnitFile, err error) {
 // formatUnitName returns a properly formatted systemd service name
 // using the given component type and number
 func formatUnitName(component string, num int) (unitName string, err error) {
+	component = strings.TrimPrefix(component, "deis-")
 	if num == 0 {
 		return "deis-" + component + ".service", nil
 	}

deisctl/backend/fleet/utils.go

@@ -6,6 +6,7 @@ import (
 	"regexp"
 	"sort"
 	"strconv"
+	"strings"
 	"time"
 )
 
@@ -66,10 +67,10 @@ func splitJobName(component string) (c string, num int, err error) {
 
 func splitTarget(target string) (component string, num int, err error) {
 	// see if we were provided a specific target
-	r := regexp.MustCompile(`^([a-z-]+)(@\d+)?$`)
+	r := regexp.MustCompile(`^([a-z-]+)(@\d+)?(\.service)?$`)
 	match := r.FindStringSubmatch(target)
 	// check for failed match
-	if len(match) != 3 {
+	if len(match) < 3 {
 		err = fmt.Errorf("Could not parse target: %v", target)
 		return
 	}
@@ -84,6 +85,29 @@ func splitTarget(target string) (component string, num int, err error) {
 	return match[1], num, err
 }
 
+// expand a target to all installed units
+func expandTargets(c *FleetClient, targets []string) (expandedTargets []string, err error) {
+	for _, t := range targets {
+		if strings.HasSuffix(t, "@*") {
+			var targets []string
+			targets, err = expandTarget(c, strings.TrimSuffix(t, "@*"))
+			if err != nil {
+				return
+			}
+			expandedTargets = append(expandedTargets, targets...)
+		} else {
+			expandedTargets = append(expandedTargets, t)
+		}
+
+	}
+	return
+}
+
+func expandTarget(c *FleetClient, target string) (targets []string, err error) {
+	targets, err = c.Units(target)
+	return
+}
+
 // randomValue returns a random string from a slice of string
 func randomValue(src []string) string {
 	s := rand.NewSource(int64(time.Now().Unix()))

deisctl/backend/fleet/utils_test.go

@@ -1,6 +1,13 @@
 package fleet
 
-import "testing"
+import (
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/coreos/fleet/machine"
+	"github.com/coreos/fleet/schema"
+)
 
 func TestNextComponent(t *testing.T) {
 	// test first component
@@ -87,3 +94,66 @@ func TestSplitTarget(t *testing.T) {
 	}
 
 }
+
+type stubFleetClient struct{}
+
+var (
+	units []*schema.Unit
+)
+
+func (c stubFleetClient) Machines() ([]machine.MachineState, error) {
+	return []machine.MachineState{}, nil
+}
+func (c stubFleetClient) Unit(string) (*schema.Unit, error) {
+	return nil, nil
+}
+func (c stubFleetClient) Units() ([]*schema.Unit, error) {
+	return units, nil
+}
+func (c stubFleetClient) UnitStates() ([]*schema.UnitState, error) {
+	return []*schema.UnitState{}, nil
+}
+func (c stubFleetClient) SetUnitTargetState(name, target string) error {
+	return fmt.Errorf("SetUnitTargetState not implemented yet.")
+}
+func (c stubFleetClient) CreateUnit(*schema.Unit) error {
+	return fmt.Errorf("CreateUnit not implemented yet.")
+}
+func (c stubFleetClient) DestroyUnit(string) error {
+	return fmt.Errorf("DestroyUnit not implemented yet.")
+}
+
+var fc stubFleetClient
+
+func TestExpandTargets(t *testing.T) {
+	units = []*schema.Unit{
+		&schema.Unit{
+			Name: "deis-router@1.service",
+		},
+		&schema.Unit{
+			Name: "deis-router@2.service",
+		},
+		&schema.Unit{
+			Name: "deis-store-gateway@1.service",
+		},
+		&schema.Unit{
+			Name: "deis-controller.service",
+		},
+	}
+	c := &FleetClient{Fleet: fc}
+
+	targets := []string{"deis-router@*", "deis-store-gateway@1", "deis-controller"}
+	expandedTargets, err := expandTargets(c, targets)
+	if err != nil {
+		t.Fatal(err)
+	}
+	expectedTargets := []string{
+		"deis-router@1.service",
+		"deis-router@2.service",
+		"deis-store-gateway@1",
+		"deis-controller",
+	}
+	if !reflect.DeepEqual(expandedTargets, expectedTargets) {
+		t.Fatal(expandedTargets)
+	}
+}

deisctl/cmd/cmd.go

@@ -171,7 +171,7 @@ func startDefaultServices(b backend.Backend, wg *sync.WaitGroup, outchan chan st
 	wg.Wait()
 
 	// we start gateway first to give metadata time to come up for volume
-	b.Start([]string{"store-gateway@1"}, wg, outchan, errchan)
+	b.Start([]string{"store-gateway@*"}, wg, outchan, errchan)
 	wg.Wait()
 	b.Start([]string{"store-volume"}, wg, outchan, errchan)
 	wg.Wait()
@@ -188,12 +188,12 @@ func startDefaultServices(b backend.Backend, wg *sync.WaitGroup, outchan chan st
 	b.Start([]string{"cache"}, &_wg, _outchan, _errchan)
 	wg.Wait()
 	b.Start([]string{
-		"database", "registry@1", "controller", "builder",
-		"publisher", "router@1", "router@2", "router@3"},
+		"database", "registry@*", "controller", "builder",
+		"publisher", "router@*"},
 		&_wg, _outchan, _errchan)
 
 	outchan <- fmt.Sprintf("Control plane...")
-	b.Start([]string{"cache", "database", "registry@1", "controller"}, wg, outchan, errchan)
+	b.Start([]string{"cache", "database", "registry@*", "controller"}, wg, outchan, errchan)
 	wg.Wait()
 	b.Start([]string{"builder"}, wg, outchan, errchan)
 	wg.Wait()
@@ -203,7 +203,7 @@ func startDefaultServices(b backend.Backend, wg *sync.WaitGroup, outchan chan st
 	wg.Wait()
 
 	outchan <- fmt.Sprintf("Routing mesh...")
-	b.Start([]string{"router@1", "router@2", "router@3"}, wg, outchan, errchan)
+	b.Start([]string{"router@*"}, wg, outchan, errchan)
 	wg.Wait()
 }
 
@@ -264,15 +264,15 @@ func StopPlatform(b backend.Backend) error {
 func stopDefaultServices(b backend.Backend, wg *sync.WaitGroup, outchan chan string, errchan chan error) {
 
 	outchan <- fmt.Sprintf("Routing mesh...")
-	b.Stop([]string{"router@1", "router@2", "router@3"}, wg, outchan, errchan)
+	b.Stop([]string{"router@*"}, wg, outchan, errchan)
 	wg.Wait()
 
 	outchan <- fmt.Sprintf("Data plane...")
 	b.Stop([]string{"publisher"}, wg, outchan, errchan)
 	wg.Wait()
 
 	outchan <- fmt.Sprintf("Control plane...")
-	b.Stop([]string{"controller", "builder", "database", "registry@1"}, wg, outchan, errchan)
+	b.Stop([]string{"controller", "builder", "database", "registry@*"}, wg, outchan, errchan)
 	wg.Wait()
 	b.Stop([]string{"cache"}, wg, outchan, errchan)
 	wg.Wait()
@@ -282,7 +282,7 @@ func stopDefaultServices(b backend.Backend, wg *sync.WaitGroup, outchan chan str
 	wg.Wait()
 
 	outchan <- fmt.Sprintf("Storage subsystem...")
-	b.Stop([]string{"store-volume", "store-gateway@1"}, wg, outchan, errchan)
+	b.Stop([]string{"store-volume", "store-gateway@*"}, wg, outchan, errchan)
 	wg.Wait()
 	b.Stop([]string{"store-metadata"}, wg, outchan, errchan)
 	wg.Wait()
@@ -508,23 +508,23 @@ func UninstallPlatform(b backend.Backend) error {
 func uninstallAllServices(b backend.Backend, wg *sync.WaitGroup, outchan chan string, errchan chan error) error {
 
 	outchan <- fmt.Sprintf("Routing mesh...")
-	b.Destroy([]string{"router@1", "router@2", "router@3"}, wg, outchan, errchan)
+	b.Destroy([]string{"router@*"}, wg, outchan, errchan)
 	wg.Wait()
 
 	outchan <- fmt.Sprintf("Data plane...")
 	b.Destroy([]string{"publisher"}, wg, outchan, errchan)
 	wg.Wait()
 
 	outchan <- fmt.Sprintf("Control plane...")
-	b.Destroy([]string{"controller", "builder", "cache", "database", "registry@1"}, wg, outchan, errchan)
+	b.Destroy([]string{"controller", "builder", "cache", "database", "registry@*"}, wg, outchan, errchan)
 	wg.Wait()
 
 	outchan <- fmt.Sprintf("Logging subsystem...")
 	b.Destroy([]string{"logger", "logspout"}, wg, outchan, errchan)
 	wg.Wait()
 
 	outchan <- fmt.Sprintf("Storage subsystem...")
-	b.Destroy([]string{"store-volume", "store-gateway@1"}, wg, outchan, errchan)
+	b.Destroy([]string{"store-volume", "store-gateway@*"}, wg, outchan, errchan)
 	wg.Wait()
 	b.Destroy([]string{"store-metadata"}, wg, outchan, errchan)
 	wg.Wait()

deisctl/cmd/cmd_test.go

@@ -0,0 +1,78 @@
+package cmd
+
+import (
+	"fmt"
+	"reflect"
+	"sync"
+	"testing"
+)
+
+type stubBackend struct{}
+
+var (
+	startedUnits   []string
+	stoppedUnits   []string
+	installedUnits []string
+)
+
+func (backend stubBackend) Create([]string, *sync.WaitGroup, chan string, chan error) {
+	return
+}
+func (backend stubBackend) Destroy([]string, *sync.WaitGroup, chan string, chan error) {
+	return
+}
+func (backend stubBackend) Start(targets []string, wg *sync.WaitGroup, outchan chan string, errchan chan error) {
+	startedUnits = targets
+	return
+}
+func (backend stubBackend) Stop(targets []string, wg *sync.WaitGroup, outchan chan string, errchan chan error) {
+	stoppedUnits = targets
+	return
+}
+func (backend stubBackend) Scale(string, int, *sync.WaitGroup, chan string, chan error) {
+	return
+}
+func (backend stubBackend) ListUnits() error {
+	return fmt.Errorf("ListUnits not implemented yet.")
+}
+func (backend stubBackend) ListUnitFiles() error {
+	return fmt.Errorf("ListUnitFiles not implemented yet.")
+}
+func (backend stubBackend) Status(string) error {
+	return fmt.Errorf("Status not implemented yet.")
+}
+func (backend stubBackend) Journal(string) error {
+	return fmt.Errorf("Journal not implemented yet.")
+}
+
+var b stubBackend
+
+// Start units
+func TestStart(t *testing.T) {
+	Start([]string{"start", "router@1", "router@2"}, b)
+
+	if !reflect.DeepEqual(startedUnits, []string{"router@1", "router@2"}) {
+		t.Error(startedUnits)
+	}
+}
+
+// Stop units
+func TestStop(t *testing.T) {
+	Stop([]string{"stop", "router@1", "router@2"}, b)
+
+	if !reflect.DeepEqual(stoppedUnits, []string{"router@1", "router@2"}) {
+		t.Error(stoppedUnits)
+	}
+}
+
+// Restart units
+func TestRestart(t *testing.T) {
+	Restart([]string{"restart", "router@4", "router@5"}, b)
+
+	if !reflect.DeepEqual(stoppedUnits, []string{"router@4", "router@5"}) {
+		t.Error(stoppedUnits)
+	}
+	if !reflect.DeepEqual(startedUnits, []string{"router@4", "router@5"}) {
+		t.Error(startedUnits)
+	}
+}

deisctl/utils/utils.go

@@ -1,5 +1,4 @@
 // Package utils contains commonly useful functions from Deisctl
-
 package utils
 
 import (