add new packages

Author: Gabriel Monroy

client/api.go

@@ -0,0 +1,12 @@
+package client
+
+// Client interface used to interact with the cluster control plane
+type Client interface {
+	Create(string, bool) error
+	Destroy(string) error
+	Start(string, bool) error
+	Stop(string) error
+	Scale(string, int) error
+	List() error
+	Status(string) error
+}

client/create.go

@@ -0,0 +1,77 @@
+package client
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/coreos/fleet/job"
+	"github.com/coreos/fleet/unit"
+)
+
+// Create schedules a new unit for the given component
+// and blocks until the unit is loaded
+func (c *FleetClient) Create(component string, data bool) (err error) {
+	var (
+		unitName string
+		unitPtr  *unit.Unit
+	)
+	// create unit
+	if data == true {
+		unitName, unitPtr, err = c.createDataUnit(component)
+	} else {
+		unitName, unitPtr, err = c.createServiceUnit(component)
+	}
+	if err != nil {
+		return err
+	}
+	// schedule job
+	j := job.NewJob(unitName, *unitPtr)
+	if err := c.Fleet.CreateJob(j); err != nil {
+		return fmt.Errorf("failed creating job %s: %v", unitName, err)
+	}
+	newState := job.JobStateLoaded
+	err = c.Fleet.SetJobTargetState(unitName, newState)
+	if err != nil {
+		return err
+	}
+	errchan := waitForJobStates([]string{unitName}, testJobStateLoaded, 0, os.Stdout)
+	for err := range errchan {
+		return fmt.Errorf("error waiting for job %s: %v", unitName, err)
+	}
+	return nil
+}
+
+// Create normal service unit
+func (c *FleetClient) createServiceUnit(component string) (unitName string, unitPtr *unit.Unit, err error) {
+	num, err := c.nextUnit(component)
+	if err != nil {
+		return
+	}
+	unitName, err = formatUnitName(component, num)
+	if err != nil {
+		return
+	}
+	unitPtr, err = NewUnit(component)
+	if err != nil {
+		return
+	}
+	return unitName, unitPtr, nil
+}
+
+// Create data container unit
+func (c *FleetClient) createDataUnit(component string) (unitName string, unitPtr *unit.Unit, err error) {
+	unitName, err = formatUnitName(component, 0)
+	if err != nil {
+		return
+	}
+	machineID, err := randomMachineID(c)
+	if err != nil {
+		return
+	}
+	unitPtr, err = NewDataUnit(component, machineID)
+	if err != nil {
+		return
+	}
+	return unitName, unitPtr, nil
+
+}

client/destroy.go

@@ -0,0 +1,27 @@
+package client
+
+import "fmt"
+
+// Destroy unschedules one unit for a given component type
+func (c *FleetClient) Destroy(component string) (err error) {
+	num, err := c.lastUnit(component)
+	if err != nil {
+		return
+	}
+	if num == 0 {
+		return fmt.Errorf("no units to destroy")
+	}
+	unitName, err := formatUnitName(component, num)
+	if err != nil {
+		return
+	}
+	_, err = c.Fleet.Job(unitName)
+	if err != nil {
+		return
+	}
+	if err = c.Fleet.DestroyJob(unitName); err != nil {
+		return fmt.Errorf("failed destroying job %s: %v", unitName, err)
+	}
+	fmt.Printf("Destroyed Unit %s\n", unitName)
+	return
+}

client/fleet.go

@@ -0,0 +1,33 @@
+package client
+
+import "github.com/coreos/fleet/client"
+
+// FleetClient used to wrap Fleet API calls
+type FleetClient struct {
+	Fleet client.API
+}
+
+// NewClient returns a client used to communicate with Fleet
+// using the Registry API
+func NewClient() (*FleetClient, error) {
+	client, err := getRegistryClient()
+	if err != nil {
+		return nil, err
+	}
+	// set global client
+	cAPI = client
+	return &FleetClient{Fleet: client}, nil
+}
+
+// randomMachineID return a random machineID from the Fleet cluster
+func randomMachineID(c *FleetClient) (machineID string, err error) {
+	machineState, err := c.Fleet.Machines()
+	if err != nil {
+		return "", err
+	}
+	var machineIDs []string
+	for _, ms := range machineState {
+		machineIDs = append(machineIDs, ms.ID)
+	}
+	return randomValue(machineIDs), nil
+}

client/list.go

@@ -0,0 +1,160 @@
+package client
+
+import (
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/coreos/fleet/job"
+	"github.com/coreos/fleet/machine"
+)
+
+// initialize tabwriter on stdout
+func init() {
+	out = new(tabwriter.Writer)
+	out.Init(os.Stdout, 0, 8, 1, '\t', 0)
+}
+
+const (
+	defaultListUnitFields = "unit,state,load,active,sub,desc,machine"
+)
+
+type jobToField func(j *job.Job, full bool) string
+
+var (
+	out             *tabwriter.Writer
+	listUnitsFields = map[string]jobToField{
+		"unit": func(j *job.Job, full bool) string {
+			return j.Name
+		},
+		"state": func(j *job.Job, full bool) string {
+			js := j.State
+			if js != nil {
+				return string(*js)
+			}
+			return "-"
+		},
+		"dstate": func(j *job.Job, full bool) string {
+			return string(j.TargetState)
+		},
+		"load": func(j *job.Job, full bool) string {
+			us := j.UnitState
+			if us == nil {
+				return "-"
+			}
+			return us.LoadState
+		},
+		"active": func(j *job.Job, full bool) string {
+			us := j.UnitState
+			if us == nil {
+				return "-"
+			}
+			return us.ActiveState
+		},
+		"sub": func(j *job.Job, full bool) string {
+			us := j.UnitState
+			if us == nil {
+				return "-"
+			}
+			return us.SubState
+		},
+		"desc": func(j *job.Job, full bool) string {
+			d := j.Unit.Description()
+			if d == "" {
+				return "-"
+			}
+			return d
+		},
+		"machine": func(j *job.Job, full bool) string {
+			us := j.UnitState
+			if us == nil || us.MachineID == "" {
+				return "-"
+			}
+			ms := cachedMachineState(us.MachineID)
+			if ms == nil {
+				ms = &machine.MachineState{ID: us.MachineID}
+			}
+			return machineFullLegend(*ms, full)
+		},
+		"tmachine": func(j *job.Job, full bool) string {
+			if j.TargetMachineID == "" {
+				return "-"
+			}
+			ms := cachedMachineState(j.TargetMachineID)
+			if ms == nil {
+				ms = &machine.MachineState{ID: j.TargetMachineID}
+			}
+			return machineFullLegend(*ms, full)
+		},
+		"hash": func(j *job.Job, full bool) string {
+			us := j.UnitState
+			if us == nil || us.UnitHash == "" {
+				return "-"
+			}
+			if !full {
+				return us.UnitHash[:7]
+			}
+			return us.UnitHash
+		},
+	}
+)
+
+// List prints all Deis-related units to Stdout
+func (c *FleetClient) List() (err error) {
+
+	var jobs map[string]job.Job
+	var sortable sort.StringSlice
+
+	jobs = make(map[string]job.Job, 0)
+	jj, err := c.Fleet.Jobs()
+	if err != nil {
+		return err
+	}
+	for _, j := range jj {
+		if strings.HasPrefix(j.Name, "deis-") {
+			jobs[j.Name] = j
+			sortable = append(sortable, j.Name)
+		}
+	}
+	sortable.Sort()
+	printList(jobs, sortable)
+	return
+}
+
+// printList writes units to stdout using a tabwriter
+func printList(jobs map[string]job.Job, sortable sort.StringSlice) {
+	cols := strings.Split(defaultListUnitFields, ",")
+	for _, s := range cols {
+		if _, ok := listUnitsFields[s]; !ok {
+			fmt.Fprintf(os.Stderr, "Invalid key in output format: %q\n", s)
+		}
+	}
+	fmt.Fprintln(out, strings.ToUpper(strings.Join(cols, "\t")))
+	for _, name := range sortable {
+		var f []string
+		j := jobs[name]
+		for _, c := range cols {
+			f = append(f, listUnitsFields[c](&j, false))
+		}
+		fmt.Fprintln(out, strings.Join(f, "\t"))
+	}
+	out.Flush()
+}
+
+func machineIDLegend(ms machine.MachineState, full bool) string {
+	legend := ms.ID
+	if !full {
+		legend = fmt.Sprintf("%s...", ms.ShortID())
+	}
+	return legend
+}
+
+func machineFullLegend(ms machine.MachineState, full bool) string {
+	legend := machineIDLegend(ms, full)
+	if len(ms.PublicIP) > 0 {
+		legend = fmt.Sprintf("%s/%s", legend, ms.PublicIP)
+	}
+	return legend
+}

client/registry.go

@@ -0,0 +1,80 @@
+package client
+
+import (
+	"crypto/tls"
+	"fmt"
+	"net"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/coreos/fleet/client"
+	"github.com/coreos/fleet/machine"
+	"github.com/coreos/fleet/registry"
+	"github.com/coreos/fleet/ssh"
+)
+
+// Flags used for Fleet API connectivity
+var Flags = struct {
+	Debug                 bool
+	Verbosity             int
+	Version               bool
+	Endpoint              string
+	EtcdKeyPrefix         string
+	UseAPI                bool
+	KnownHostsFile        string
+	StrictHostKeyChecking bool
+	Tunnel                string
+}{}
+
+// 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, ":") {
+		tun += ":22"
+	}
+	return tun
+}
+
+func getChecker() *ssh.HostKeyChecker {
+	if !Flags.StrictHostKeyChecking {
+		return nil
+	}
+	keyFile := ssh.NewHostKeyFile(Flags.KnownHostsFile)
+	return ssh.NewHostKeyChecker(keyFile)
+}
+
+func getFakeClient() (*registry.FakeRegistry, error) {
+	return registry.NewFakeRegistry(), nil
+}
+
+func getRegistryClient() (client.API, error) {
+	var dial func(string, string) (net.Conn, error)
+	tun := getTunnelFlag()
+	if tun != "" {
+		sshClient, err := ssh.NewSSHClient("core", tun, getChecker(), false)
+		if err != nil {
+			return nil, fmt.Errorf("failed initializing SSH client: %v", err)
+		}
+		dial = func(network, addr string) (net.Conn, error) {
+			tcpaddr, err := net.ResolveTCPAddr(network, addr)
+			if err != nil {
+				return nil, err
+			}
+			return sshClient.DialTCP(network, nil, tcpaddr)
+		}
+	}
+	trans := http.Transport{
+		Dial: dial,
+		TLSClientConfig: &tls.Config{
+			InsecureSkipVerify: true,
+		},
+	}
+	return client.NewRegistryClient(&trans, Flags.Endpoint, Flags.EtcdKeyPrefix, requestTimeout)
+}