ref(deisctl): remove global variables in backend package

Author: Joshua Anderson

deisctl/backend/fleet/create.go

@@ -60,7 +60,7 @@ func doCreate(c *FleetClient, unit *schema.Unit, wg *sync.WaitGroup, outchan cha
 outerLoop:
 	for {
 		time.Sleep(250 * time.Millisecond)
-		unitStates, err := cAPI.UnitStates()
+		unitStates, err := c.Fleet.UnitStates()
 		if err != nil {
 			errchan <- err
 		}

deisctl/backend/fleet/destroy.go

@@ -46,7 +46,7 @@ func doDestroy(c *FleetClient, target string, wg *sync.WaitGroup, outchan chan s
 outerLoop:
 	for {
 		time.Sleep(250 * time.Millisecond)
-		unitStates, err := cAPI.UnitStates()
+		unitStates, err := c.Fleet.UnitStates()
 		if err != nil {
 			errchan <- err
 		}

deisctl/backend/fleet/fleet.go

@@ -1,10 +1,16 @@
 package fleet
 
-import "github.com/coreos/fleet/client"
+import (
+	"github.com/coreos/fleet/client"
+	"github.com/coreos/fleet/machine"
+)
 
 // FleetClient used to wrap Fleet API calls
 type FleetClient struct {
 	Fleet client.API
+
+	// used to cache MachineStates
+	machineStates map[string]*machine.MachineState
 }
 
 // NewClient returns a client used to communicate with Fleet
@@ -14,7 +20,5 @@ func NewClient() (*FleetClient, error) {
 	if err != nil {
 		return nil, err
 	}
-	// set global client
-	cAPI = client
 	return &FleetClient{Fleet: client}, nil
 }

deisctl/backend/fleet/journal.go

@@ -11,19 +11,19 @@ func (c *FleetClient) Journal(target string) (err error) {
 		return
 	}
 	for _, unit := range units {
-		runJournal(unit)
+		runJournal(c, unit)
 	}
 	return
 }
 
 // runJournal tails the systemd journal for a given unit
-func runJournal(name string) (exit int) {
-	machineID, err := findUnit(name)
+func runJournal(c *FleetClient, name string) (exit int) {
+	machineID, err := findUnit(c, name)
 
 	if err != nil {
 		return 1
 	}
 
 	command := fmt.Sprintf("journalctl --unit %s --no-pager -n 40 -f", name)
-	return runCommand(command, machineID)
+	return runCommand(c, command, machineID)
 }

deisctl/backend/fleet/list_unit_files.go

@@ -18,43 +18,43 @@ const (
 
 var (
 	listUnitFilesFields = map[string]unitToField{
-		"unit": func(u schema.Unit, full bool) string {
+		"unit": func(c *FleetClient, u schema.Unit, full bool) string {
 			return u.Name
 		},
-		"global": func(u schema.Unit, full bool) string {
+		"global": func(c *FleetClient, u schema.Unit, full bool) string {
 			return strconv.FormatBool(suToGlobal(u))
 		},
-		"dstate": func(u schema.Unit, full bool) string {
+		"dstate": func(c *FleetClient, u schema.Unit, full bool) string {
 			if u.DesiredState == "" {
 				return "-"
 			}
 			return u.DesiredState
 		},
-		"tmachine": func(u schema.Unit, full bool) string {
+		"tmachine": func(c *FleetClient, u schema.Unit, full bool) string {
 			if suToGlobal(u) || u.MachineID == "" {
 				return "-"
 			}
-			ms := cachedMachineState(u.MachineID)
+			ms := cachedMachineState(c, u.MachineID)
 			if ms == nil {
 				ms = &machine.MachineState{ID: u.MachineID}
 			}
 
 			return machineFullLegend(*ms, full)
 		},
-		"state": func(u schema.Unit, full bool) string {
+		"state": func(c *FleetClient, u schema.Unit, full bool) string {
 			if suToGlobal(u) || u.CurrentState == "" {
 				return "-"
 			}
 			return u.CurrentState
 		},
-		"hash": func(u schema.Unit, full bool) string {
+		"hash": func(c *FleetClient, u schema.Unit, full bool) string {
 			uf := schema.MapSchemaUnitOptionsToUnitFile(u.Options)
 			if !full {
 				return uf.Hash().Short()
 			}
 			return uf.Hash().String()
 		},
-		"desc": func(u schema.Unit, full bool) string {
+		"desc": func(c *FleetClient, u schema.Unit, full bool) string {
 			uf := schema.MapSchemaUnitOptionsToUnitFile(u.Options)
 			d := uf.Description()
 			if d == "" {
@@ -65,14 +65,14 @@ var (
 	}
 )
 
-type unitToField func(u schema.Unit, full bool) string
+type unitToField func(c *FleetClient, u schema.Unit, full bool) string
 
 // ListUnitFiles prints all Deis-related unit files to Stdout
 func (c *FleetClient) ListUnitFiles() (err error) {
 	var sortable sort.StringSlice
 	units := make(map[string]*schema.Unit, 0)
 
-	us, err := cAPI.Units()
+	us, err := c.Fleet.Units()
 	if err != nil {
 		return err
 	}
@@ -84,12 +84,12 @@ func (c *FleetClient) ListUnitFiles() (err error) {
 		}
 	}
 	sortable.Sort()
-	printUnitFiles(units, sortable)
+	printUnitFiles(c, units, sortable)
 	return
 }
 
 // printUnitFiles writes unit files to stdout using a tabwriter
-func printUnitFiles(units map[string]*schema.Unit, sortable sort.StringSlice) {
+func printUnitFiles(client *FleetClient, units map[string]*schema.Unit, sortable sort.StringSlice) {
 	cols := strings.Split(defaultListUnitFilesFields, ",")
 	for _, s := range cols {
 		if _, ok := listUnitsFields[s]; !ok {
@@ -101,7 +101,7 @@ func printUnitFiles(units map[string]*schema.Unit, sortable sort.StringSlice) {
 		var f []string
 		u := units[name]
 		for _, c := range cols {
-			f = append(f, listUnitFilesFields[c](*u, false))
+			f = append(f, listUnitFilesFields[c](client, *u, false))
 		}
 		fmt.Fprintln(out, strings.Join(f, "\t"))
 	}

deisctl/backend/fleet/list_units.go

@@ -22,46 +22,46 @@ const (
 	defaultListUnitsFields = "unit,machine,load,active,sub"
 )
 
-type usToField func(us *schema.UnitState, full bool) string
+type usToField func(c *FleetClient, us *schema.UnitState, full bool) string
 
 var (
 	out             *tabwriter.Writer
 	listUnitsFields = map[string]usToField{
-		"unit": func(us *schema.UnitState, full bool) string {
+		"unit": func(c *FleetClient, us *schema.UnitState, full bool) string {
 			if us == nil {
 				return "-"
 			}
 			return us.Name
 		},
-		"load": func(us *schema.UnitState, full bool) string {
+		"load": func(c *FleetClient, us *schema.UnitState, full bool) string {
 			if us == nil {
 				return "-"
 			}
 			return us.SystemdLoadState
 		},
-		"active": func(us *schema.UnitState, full bool) string {
+		"active": func(c *FleetClient, us *schema.UnitState, full bool) string {
 			if us == nil {
 				return "-"
 			}
 			return us.SystemdActiveState
 		},
-		"sub": func(us *schema.UnitState, full bool) string {
+		"sub": func(c *FleetClient, us *schema.UnitState, full bool) string {
 			if us == nil {
 				return "-"
 			}
 			return us.SystemdSubState
 		},
-		"machine": func(us *schema.UnitState, full bool) string {
+		"machine": func(c *FleetClient, us *schema.UnitState, full bool) string {
 			if us == nil || us.MachineID == "" {
 				return "-"
 			}
-			ms := cachedMachineState(us.MachineID)
+			ms := cachedMachineState(c, us.MachineID)
 			if ms == nil {
 				ms = &machine.MachineState{ID: us.MachineID}
 			}
 			return machineFullLegend(*ms, full)
 		},
-		"hash": func(us *schema.UnitState, full bool) string {
+		"hash": func(c *FleetClient, us *schema.UnitState, full bool) string {
 			if us == nil || us.Hash == "" {
 				return "-"
 			}
@@ -77,7 +77,7 @@ var (
 func (c *FleetClient) ListUnits() (err error) {
 	var states []*schema.UnitState
 
-	unitStates, err := cAPI.UnitStates()
+	unitStates, err := c.Fleet.UnitStates()
 	if err != nil {
 		return err
 	}
@@ -90,12 +90,12 @@ func (c *FleetClient) ListUnits() (err error) {
 			}
 		}
 	}
-	printUnits(states)
+	printUnits(c, states)
 	return
 }
 
 // printUnits writes units to stdout using a tabwriter
-func printUnits(states []*schema.UnitState) {
+func printUnits(client *FleetClient, states []*schema.UnitState) {
 	cols := strings.Split(defaultListUnitsFields, ",")
 	for _, s := range cols {
 		if _, ok := listUnitsFields[s]; !ok {
@@ -106,7 +106,7 @@ func printUnits(states []*schema.UnitState) {
 	for _, us := range states {
 		var f []string
 		for _, c := range cols {
-			f = append(f, listUnitsFields[c](us, false))
+			f = append(f, listUnitsFields[c](client, us, false))
 		}
 		fmt.Fprintln(out, strings.Join(f, "\t"))
 	}

deisctl/backend/fleet/registry.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/coreos/fleet/client"
 	"github.com/coreos/fleet/etcd"
-	"github.com/coreos/fleet/machine"
 	"github.com/coreos/fleet/pkg"
 	"github.com/coreos/fleet/registry"
 	"github.com/coreos/fleet/ssh"
@@ -41,13 +40,6 @@ recommended to upgrade fleetctl to prevent incompatibility issues.
 `
 )
 
-// global API client used by commands
-var cAPI client.API
-
-// used to cache MachineStates
-var machineStates map[string]*machine.MachineState
-var requestTimeout = time.Duration(10) * time.Second
-
 func getTunnelFlag() string {
 	tun := Flags.Tunnel
 	if tun != "" && !strings.Contains(tun, ":") {

deisctl/backend/fleet/ssh.go

@@ -18,7 +18,7 @@ func (c *FleetClient) SSH(name string) (err error) {
 
 	timeout := time.Duration(Flags.SSHTimeout*1000) * time.Millisecond
 
-	ms, err := machineState(name)
+	ms, err := machineState(c, name)
 	if err != nil {
 		return err
 	}
@@ -31,13 +31,13 @@ func (c *FleetClient) SSH(name string) (err error) {
 			return err
 		}
 
-		machID, err := findUnit(units[0])
+		machID, err := findUnit(c, units[0])
 
 		if err != nil {
 			return err
 		}
 
-		ms, err = machineState(machID)
+		ms, err = machineState(c, machID)
 
 		if err != nil || ms == nil {
 			return err
@@ -62,15 +62,15 @@ func (c *FleetClient) SSH(name string) (err error) {
 
 // runCommand will attempt to run a command on a given machine. It will attempt
 // to SSH to the machine if it is identified as being remote.
-func runCommand(cmd string, machID string) (retcode int) {
+func runCommand(c *FleetClient, cmd string, machID string) (retcode int) {
 	var err error
 	if machine.IsLocalMachineID(machID) {
 		retcode, err = runLocalCommand(cmd)
 		if err != nil {
 			fmt.Printf("Error running local command: %v\n", err)
 		}
 	} else {
-		ms, err := machineState(machID)
+		ms, err := machineState(c, machID)
 		if err != nil || ms == nil {
 			fmt.Printf("Error getting machine IP: %v\n", err)
 		} else {
@@ -125,8 +125,8 @@ func runRemoteCommand(cmd string, addr string, timeout time.Duration) (exit int,
 }
 
 // findUnits returns the machine ID of a running unit
-func findUnit(name string) (machID string, err error) {
-	u, err := cAPI.Unit(name)
+func findUnit(c *FleetClient, name string) (machID string, err error) {
+	u, err := c.Fleet.Unit(name)
 	if err != nil {
 		return "", fmt.Errorf("Error retrieving Unit %s: %v", name, err)
 	}
@@ -142,8 +142,8 @@ func findUnit(name string) (machID string, err error) {
 	return u.MachineID, nil
 }
 
-func machineState(machID string) (*machine.MachineState, error) {
-	machines, err := cAPI.Machines()
+func machineState(c *FleetClient, machID string) (*machine.MachineState, error) {
+	machines, err := c.Fleet.Machines()
 	if err != nil {
 		return nil, err
 	}
@@ -158,16 +158,16 @@ func machineState(machID string) (*machine.MachineState, error) {
 // cachedMachineState makes a best-effort to retrieve the MachineState of the given machine ID.
 // It memoizes MachineState information for the life of a fleetctl invocation.
 // Any error encountered retrieving the list of machines is ignored.
-func cachedMachineState(machID string) (ms *machine.MachineState) {
-	if machineStates == nil {
-		machineStates = make(map[string]*machine.MachineState)
-		ms, err := cAPI.Machines()
+func cachedMachineState(c *FleetClient, machID string) (ms *machine.MachineState) {
+	if c.machineStates == nil {
+		c.machineStates = make(map[string]*machine.MachineState)
+		ms, err := c.Fleet.Machines()
 		if err != nil {
 			return nil
 		}
 		for i, m := range ms {
-			machineStates[m.ID] = &ms[i]
+			c.machineStates[m.ID] = &ms[i]
 		}
 	}
-	return machineStates[machID]
+	return c.machineStates[machID]
 }

deisctl/backend/fleet/status.go

@@ -12,15 +12,15 @@ func (c *FleetClient) Status(target string) (err error) {
 		return
 	}
 	for _, unit := range units {
-		printUnitStatus(unit)
+		printUnitStatus(c, unit)
 		fmt.Println()
 	}
 	return
 }
 
 // printUnitStatus displays the systemd status for a given unit
-func printUnitStatus(name string) int {
-	u, err := cAPI.Unit(name)
+func printUnitStatus(c *FleetClient, name string) int {
+	u, err := c.Fleet.Unit(name)
 	if suToGlobal(*u) {
 		fmt.Fprintf(os.Stderr, "Unable to get status for global unit %s. Check the status on the host using systemctl.\n", name)
 		return 1
@@ -37,5 +37,5 @@ func printUnitStatus(name string) int {
 		return 1
 	}
 	cmd := fmt.Sprintf("systemctl status -l %s", name)
-	return runCommand(cmd, u.MachineID)
+	return runCommand(c, cmd, u.MachineID)
 }