Initial commit

vendor/github.com/hyperhq/hypercli/cli/cli.go

@@ -0,0 +1,201 @@
+package cli
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+	"strings"
+
+	flag "github.com/hyperhq/hypercli/pkg/mflag"
+)
+
+// Cli represents a command line interface.
+type Cli struct {
+	Stderr   io.Writer
+	handlers []Handler
+	Usage    func()
+}
+
+// Handler holds the different commands Cli will call
+// It should have methods with names starting with `Cmd` like:
+// 	func (h myHandler) CmdFoo(args ...string) error
+type Handler interface{}
+
+// Initializer can be optionally implemented by a Handler to
+// initialize before each call to one of its commands.
+type Initializer interface {
+	Initialize() error
+}
+
+// New instantiates a ready-to-use Cli.
+func New(handlers ...Handler) *Cli {
+	// make the generic Cli object the first cli handler
+	// in order to handle `docker help` appropriately
+	cli := new(Cli)
+	cli.handlers = append([]Handler{cli}, handlers...)
+	return cli
+}
+
+// initErr is an error returned upon initialization of a handler implementing Initializer.
+type initErr struct{ error }
+
+func (err initErr) Error() string {
+	return err.Error()
+}
+
+func (cli *Cli) command(args ...string) (func(...string) error, error) {
+	for _, c := range cli.handlers {
+		if c == nil {
+			continue
+		}
+		camelArgs := make([]string, len(args))
+		for i, s := range args {
+			if len(s) == 0 {
+				return nil, errors.New("empty command")
+			}
+			s = strings.Replace(s, "-", "_", -1)
+			camelArgs[i] = strings.ToUpper(s[:1]) + strings.ToLower(s[1:])
+		}
+		methodName := "Cmd" + strings.Join(camelArgs, "")
+		method := reflect.ValueOf(c).MethodByName(methodName)
+		if method.IsValid() {
+			if c, ok := c.(Initializer); ok {
+				if err := c.Initialize(); err != nil {
+					return nil, initErr{err}
+				}
+			}
+			return method.Interface().(func(...string) error), nil
+		}
+	}
+	return nil, errors.New("command not found")
+}
+
+// Run executes the specified command.
+func (cli *Cli) Run(args ...string) error {
+	if len(args) > 1 {
+		command, err := cli.command(args[:2]...)
+		switch err := err.(type) {
+		case nil:
+			return command(args[2:]...)
+		case initErr:
+			return err.error
+		}
+	}
+	if len(args) > 0 {
+		command, err := cli.command(args[0])
+		switch err := err.(type) {
+		case nil:
+			return command(args[1:]...)
+		case initErr:
+			return err.error
+		}
+		cli.noSuchCommand(args[0])
+	}
+	return cli.CmdHelp()
+}
+
+func (cli *Cli) noSuchCommand(command string) {
+	if cli.Stderr == nil {
+		cli.Stderr = os.Stderr
+	}
+	fmt.Fprintf(cli.Stderr, "hyper: '%s' is not a hyper command.\nSee 'hyper --help'.\n", command)
+	os.Exit(1)
+}
+
+// CmdHelp displays information on a Docker command.
+//
+// If more than one command is specified, information is only shown for the first command.
+//
+// Usage: docker help COMMAND or docker COMMAND --help
+func (cli *Cli) CmdHelp(args ...string) error {
+	if len(args) > 1 {
+		command, err := cli.command(args[:2]...)
+		switch err := err.(type) {
+		case nil:
+			command("--help")
+			return nil
+		case initErr:
+			return err.error
+		}
+	}
+	if len(args) > 0 {
+		command, err := cli.command(args[0])
+		switch err := err.(type) {
+		case nil:
+			command("--help")
+			return nil
+		case initErr:
+			return err.error
+		}
+		cli.noSuchCommand(args[0])
+	}
+
+	if cli.Usage == nil {
+		flag.Usage()
+	} else {
+		cli.Usage()
+	}
+
+	return nil
+}
+
+// Subcmd is a subcommand of the main "docker" command.
+// A subcommand represents an action that can be performed
+// from the Docker command line client.
+//
+// To see all available subcommands, run "docker --help".
+func Subcmd(name string, synopses []string, description string, exitOnError bool) *flag.FlagSet {
+	var errorHandling flag.ErrorHandling
+	if exitOnError {
+		errorHandling = flag.ExitOnError
+	} else {
+		errorHandling = flag.ContinueOnError
+	}
+	flags := flag.NewFlagSet(name, errorHandling)
+	flags.Usage = func() {
+		flags.ShortUsage()
+		flags.PrintDefaults()
+	}
+
+	flags.ShortUsage = func() {
+		options := ""
+		if flags.FlagCountUndeprecated() > 0 {
+			options = " [OPTIONS]"
+		}
+
+		if len(synopses) == 0 {
+			synopses = []string{""}
+		}
+
+		// Allow for multiple command usage synopses.
+		for i, synopsis := range synopses {
+			lead := "\t"
+			if i == 0 {
+				// First line needs the word 'Usage'.
+				lead = "Usage:\t"
+			}
+
+			if synopsis != "" {
+				synopsis = " " + synopsis
+			}
+
+			fmt.Fprintf(flags.Out(), "\n%shyper %s%s%s", lead, name, options, synopsis)
+		}
+
+		fmt.Fprintf(flags.Out(), "\n\n%s\n", description)
+	}
+
+	return flags
+}
+
+// An StatusError reports an unsuccessful exit by a command.
+type StatusError struct {
+	Status     string
+	StatusCode int
+}
+
+func (e StatusError) Error() string {
+	return fmt.Sprintf("Status: %s, Code: %d", e.Status, e.StatusCode)
+}

vendor/github.com/hyperhq/hypercli/cli/client.go

@@ -0,0 +1,12 @@
+package cli
+
+import flag "github.com/hyperhq/hypercli/pkg/mflag"
+
+// ClientFlags represents flags for the docker client.
+type ClientFlags struct {
+	FlagSet   *flag.FlagSet
+	Common    *CommonFlags
+	PostParse func()
+
+	ConfigDir string
+}

vendor/github.com/hyperhq/hypercli/cli/command/events_utils.go

@@ -0,0 +1,47 @@
+package command
+
+import (
+	"sync"
+
+	eventtypes "github.com/docker/engine-api/types/events"
+)
+
+type eventProcessor func(eventtypes.Message, error) error
+
+// EventHandler is abstract interface for user to customize
+// own handle functions of each type of events
+type EventHandler interface {
+	Handle(action string, h func(eventtypes.Message))
+	Watch(c <-chan eventtypes.Message)
+}
+
+// InitEventHandler initializes and returns an EventHandler
+func InitEventHandler() EventHandler {
+	return &eventHandler{handlers: make(map[string]func(eventtypes.Message))}
+}
+
+type eventHandler struct {
+	handlers map[string]func(eventtypes.Message)
+	mu       sync.Mutex
+}
+
+func (w *eventHandler) Handle(action string, h func(eventtypes.Message)) {
+	w.mu.Lock()
+	w.handlers[action] = h
+	w.mu.Unlock()
+}
+
+// Watch ranges over the passed in event chan and processes the events based on the
+// handlers created for a given action.
+// To stop watching, close the event chan.
+func (w *eventHandler) Watch(c <-chan eventtypes.Message) {
+	for e := range c {
+		w.mu.Lock()
+		h, exists := w.handlers[e.Action]
+		w.mu.Unlock()
+		if !exists {
+			continue
+		}
+		go h(e)
+	}
+}

vendor/github.com/hyperhq/hypercli/cli/command/formatter/custom.go

@@ -0,0 +1,51 @@
+package formatter
+
+import (
+	"strings"
+)
+
+const (
+	imageHeader        = "IMAGE"
+	createdSinceHeader = "CREATED"
+	createdAtHeader    = "CREATED AT"
+	sizeHeader         = "SIZE"
+	labelsHeader       = "LABELS"
+	nameHeader         = "NAME"
+	driverHeader       = "DRIVER"
+	scopeHeader        = "SCOPE"
+)
+
+type subContext interface {
+	FullHeader() string
+	AddHeader(header string)
+}
+
+// HeaderContext provides the subContext interface for managing headers
+type HeaderContext struct {
+	header []string
+}
+
+// FullHeader returns the header as a string
+func (c *HeaderContext) FullHeader() string {
+	if c.header == nil {
+		return ""
+	}
+	return strings.Join(c.header, "\t")
+}
+
+// AddHeader adds another column to the header
+func (c *HeaderContext) AddHeader(header string) {
+	if c.header == nil {
+		c.header = []string{}
+	}
+	c.header = append(c.header, strings.ToUpper(header))
+}
+
+func stripNamePrefix(ss []string) []string {
+	sss := make([]string, len(ss))
+	for i, s := range ss {
+		sss[i] = s[1:]
+	}
+
+	return sss
+}

vendor/github.com/hyperhq/hypercli/cli/command/formatter/formatter.go

@@ -0,0 +1,123 @@
+package formatter
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"strings"
+	"text/tabwriter"
+	"text/template"
+
+	"github.com/hyperhq/hypercli/utils/templates"
+)
+
+// Format keys used to specify certain kinds of output formats
+const (
+	TableFormatKey  = "table"
+	RawFormatKey    = "raw"
+	PrettyFormatKey = "pretty"
+
+	defaultQuietFormat = "{{.ID}}"
+)
+
+// Format is the format string rendered using the Context
+type Format string
+
+// IsTable returns true if the format is a table-type format
+func (f Format) IsTable() bool {
+	return strings.HasPrefix(string(f), TableFormatKey)
+}
+
+// Contains returns true if the format contains the substring
+func (f Format) Contains(sub string) bool {
+	return strings.Contains(string(f), sub)
+}
+
+// Context contains information required by the formatter to print the output as desired.
+type Context struct {
+	// Output is the output stream to which the formatted string is written.
+	Output io.Writer
+	// Format is used to choose raw, table or custom format for the output.
+	Format Format
+	// Trunc when set to true will truncate the output of certain fields such as Container ID.
+	Trunc bool
+
+	// internal element
+	finalFormat string
+	header      string
+	buffer      *bytes.Buffer
+}
+
+func (c *Context) preFormat() {
+	c.finalFormat = string(c.Format)
+
+	// TODO: handle this in the Format type
+	if c.Format.IsTable() {
+		c.finalFormat = c.finalFormat[len(TableFormatKey):]
+	}
+
+	c.finalFormat = strings.Trim(c.finalFormat, " ")
+	r := strings.NewReplacer(`\t`, "\t", `\n`, "\n")
+	c.finalFormat = r.Replace(c.finalFormat)
+}
+
+func (c *Context) parseFormat() (*template.Template, error) {
+	tmpl, err := templates.Parse(c.finalFormat)
+	if err != nil {
+		return tmpl, fmt.Errorf("Template parsing error: %v\n", err)
+	}
+	return tmpl, err
+}
+
+func (c *Context) postFormat(tmpl *template.Template, subContext subContext) {
+	if c.Format.IsTable() {
+		if len(c.header) == 0 {
+			// if we still don't have a header, we didn't have any containers so we need to fake it to get the right headers from the template
+			tmpl.Execute(bytes.NewBufferString(""), subContext)
+			c.header = subContext.FullHeader()
+		}
+
+		t := tabwriter.NewWriter(c.Output, 20, 1, 3, ' ', 0)
+		t.Write([]byte(c.header))
+		t.Write([]byte("\n"))
+		c.buffer.WriteTo(t)
+		t.Flush()
+	} else {
+		c.buffer.WriteTo(c.Output)
+	}
+}
+
+func (c *Context) contextFormat(tmpl *template.Template, subContext subContext) error {
+	if err := tmpl.Execute(c.buffer, subContext); err != nil {
+		return fmt.Errorf("Template parsing error: %v\n", err)
+	}
+	if c.Format.IsTable() && len(c.header) == 0 {
+		c.header = subContext.FullHeader()
+	}
+	c.buffer.WriteString("\n")
+	return nil
+}
+
+// SubFormat is a function type accepted by Write()
+type SubFormat func(func(subContext) error) error
+
+// Write the template to the buffer using this Context
+func (c *Context) Write(sub subContext, f SubFormat) error {
+	c.buffer = bytes.NewBufferString("")
+	c.preFormat()
+
+	tmpl, err := c.parseFormat()
+	if err != nil {
+		return err
+	}
+
+	subFormat := func(subContext subContext) error {
+		return c.contextFormat(tmpl, subContext)
+	}
+	if err := f(subFormat); err != nil {
+		return err
+	}
+
+	c.postFormat(tmpl, sub)
+	return nil
+}

vendor/github.com/hyperhq/hypercli/cli/command/formatter/stats.go

@@ -0,0 +1,177 @@
+package formatter
+
+import (
+	"fmt"
+	"sync"
+
+	units "github.com/docker/go-units"
+)
+
+const (
+	defaultStatsTableFormat = "table {{.Container}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.MemPerc}}\t{{.NetIO}}\t{{.BlockIO}}"
+
+	containerHeader = "CONTAINER"
+	cpuPercHeader   = "CPU %"
+	netIOHeader     = "NET I/O"
+	blockIOHeader   = "BLOCK I/O"
+	memPercHeader   = "MEM %"
+	memUseHeader    = "MEM USAGE / LIMIT"
+)
+
+// StatsEntry represents represents the statistics data collected from a container
+type StatsEntry struct {
+	Container        string
+	Name             string
+	ID               string
+	CPUPercentage    float64
+	Memory           float64
+	MemoryLimit      float64
+	MemoryPercentage float64
+	NetworkRx        float64
+	NetworkTx        float64
+	BlockRead        float64
+	BlockWrite       float64
+	IsInvalid        bool
+}
+
+// ContainerStats represents an entity to store containers statistics synchronously
+type ContainerStats struct {
+	mutex sync.Mutex
+	StatsEntry
+	err error
+}
+
+// GetError returns the container statistics error.
+// This is used to determine whether the statistics are valid or not
+func (cs *ContainerStats) GetError() error {
+	cs.mutex.Lock()
+	defer cs.mutex.Unlock()
+	return cs.err
+}
+
+// SetErrorAndReset zeroes all the container statistics and store the error.
+// It is used when receiving time out error during statistics collecting to reduce lock overhead
+func (cs *ContainerStats) SetErrorAndReset(err error) {
+	cs.mutex.Lock()
+	defer cs.mutex.Unlock()
+	cs.CPUPercentage = 0
+	cs.Memory = 0
+	cs.MemoryPercentage = 0
+	cs.MemoryLimit = 0
+	cs.NetworkRx = 0
+	cs.NetworkTx = 0
+	cs.BlockRead = 0
+	cs.BlockWrite = 0
+	cs.err = err
+	cs.IsInvalid = true
+}
+
+// SetError sets container statistics error
+func (cs *ContainerStats) SetError(err error) {
+	cs.mutex.Lock()
+	defer cs.mutex.Unlock()
+	cs.err = err
+	if err != nil {
+		cs.IsInvalid = true
+	}
+}
+
+// SetStatistics set the container statistics
+func (cs *ContainerStats) SetStatistics(s StatsEntry) {
+	cs.mutex.Lock()
+	defer cs.mutex.Unlock()
+	s.Container = cs.Container
+	cs.StatsEntry = s
+}
+
+// GetStatistics returns container statistics with other meta data such as the container name
+func (cs *ContainerStats) GetStatistics() StatsEntry {
+	cs.mutex.Lock()
+	defer cs.mutex.Unlock()
+	return cs.StatsEntry
+}
+
+// NewStatsFormat returns a format for rendering an CStatsContext
+func NewStatsFormat(source string) Format {
+	if source == TableFormatKey {
+		return Format(defaultStatsTableFormat)
+	}
+	return Format(source)
+}
+
+// NewContainerStats returns a new ContainerStats entity and sets in it the given name
+func NewContainerStats(container string) *ContainerStats {
+	return &ContainerStats{
+		StatsEntry: StatsEntry{Container: container},
+	}
+}
+
+// ContainerStatsWrite renders the context for a list of containers statistics
+func ContainerStatsWrite(ctx Context, containerStats []StatsEntry) error {
+	render := func(format func(subContext subContext) error) error {
+		for _, cstats := range containerStats {
+			containerStatsCtx := &containerStatsContext{
+				s: cstats,
+			}
+			if err := format(containerStatsCtx); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+	return ctx.Write(&containerStatsContext{}, render)
+}
+
+type containerStatsContext struct {
+	HeaderContext
+	s StatsEntry
+}
+
+func (c *containerStatsContext) Container() string {
+	c.AddHeader(containerHeader)
+	return c.s.Container
+}
+
+func (c *containerStatsContext) CPUPerc() string {
+	c.AddHeader(cpuPercHeader)
+	if c.s.IsInvalid {
+		return fmt.Sprintf("--")
+	}
+	return fmt.Sprintf("%.2f%%", c.s.CPUPercentage)
+}
+
+func (c *containerStatsContext) MemUsage() string {
+	header := memUseHeader
+
+	c.AddHeader(header)
+	if c.s.IsInvalid {
+		return fmt.Sprintf("-- / --")
+	}
+
+	return fmt.Sprintf("%s / %s", units.HumanSize(c.s.Memory), units.HumanSize(c.s.MemoryLimit))
+}
+
+func (c *containerStatsContext) MemPerc() string {
+	header := memPercHeader
+	c.AddHeader(header)
+	if c.s.IsInvalid {
+		return fmt.Sprintf("--")
+	}
+	return fmt.Sprintf("%.2f%%", c.s.MemoryPercentage)
+}
+
+func (c *containerStatsContext) NetIO() string {
+	c.AddHeader(netIOHeader)
+	if c.s.IsInvalid {
+		return fmt.Sprintf("--")
+	}
+	return fmt.Sprintf("%s / %s", units.HumanSize(c.s.NetworkRx), units.HumanSize(c.s.NetworkTx))
+}
+
+func (c *containerStatsContext) BlockIO() string {
+	c.AddHeader(blockIOHeader)
+	if c.s.IsInvalid {
+		return fmt.Sprintf("--")
+	}
+	return fmt.Sprintf("%s / %s", units.HumanSize(c.s.BlockRead), units.HumanSize(c.s.BlockWrite))
+}

vendor/github.com/hyperhq/hypercli/cli/common.go

@@ -0,0 +1,88 @@
+package cli
+
+import (
+	"github.com/docker/go-connections/tlsconfig"
+	flag "github.com/hyperhq/hypercli/pkg/mflag"
+)
+
+// CommonFlags represents flags that are common to both the client and the daemon.
+type CommonFlags struct {
+	FlagSet   *flag.FlagSet
+	PostParse func()
+
+	Debug      bool
+	Region     string
+	LogLevel   string
+	TLS        bool
+	TLSVerify  bool
+	TLSOptions *tlsconfig.Options
+	TrustKey   string
+}
+
+// Command is the struct contains command name and description
+type Command struct {
+	Name        string
+	Description string
+}
+
+var dockerCommands = []Command{
+	{"attach", "Attach to a running container"},
+	//{"build", "Build an image from a Dockerfile"},
+	{"commit", "Create a new image from a container's changes"},
+	{"config", "Config access key and secret key to Hyper server"},
+	//{"cp", "Copy files/folders between a container and the local filesystem"},
+	{"create", "Create a new container"},
+	//{"diff", "Inspect changes on a container's filesystem"},
+	//{"events", "Get real time events from the server"},
+	{"exec", "Run a command in a running container"},
+	//{"export", "Export a container's filesystem as a tar archive"},
+	{"history", "Show the history of an image"},
+	{"images", "List images"},
+	//{"import", "Import the contents from a tarball to create a filesystem image"},
+	{"info", "Display system-wide information"},
+	{"inspect", "Return low-level information on a container or image"},
+	{"kill", "Kill a running container"},
+	{"load", "Load a local image or a tar file"},
+	{"login", "Register or log in to a Docker registry"},
+	{"logout", "Log out from a Docker registry"},
+	{"logs", "Fetch the logs of a container"},
+	//{"network", "Manage Hyper.sh networks"},
+	//{"pause", "Pause all processes within a container"},
+	{"port", "List port mappings or a specific mapping for the CONTAINER"},
+	{"ps", "List containers"},
+	{"pull", "Pull an image or a repository from a registry"},
+	{"push", "Push an image or a repository to a registry"},
+	{"rename", "Rename a container"},
+	{"restart", "Restart a container"},
+	{"rm", "Remove one or more containers"},
+	{"rmi", "Remove one or more images"},
+	{"run", "Run a command in a new container"},
+	//{"save", "Save an image(s) to a tar archive"},
+	{"search", "Search the Docker Hub for images"},
+	{"start", "Start one or more stopped containers"},
+	{"stats", "Display a live stream of container(s) resource usage statistics"},
+	{"stop", "Stop a running container"},
+	//{"tag", "Tag an image into a repository"},
+	//{"top", "Display the running processes of a container"},
+	//{"unpause", "Unpause all processes within a container"},
+	{"update", "Update resources of one or more containers"},
+	{"version", "Show the Hyper.sh version information"},
+	{"volume", "Manage Hyper.sh volumes"},
+	{"snapshot", "Manage Hyper.sh snapshots"},
+	{"fip", "Manage Hyper.sh floating IPs"},
+	{"wait", "Block until a container stops, then print its exit code"},
+	{"compose", "Define and run multi-container applications with Hyper.sh"},
+	{"sg", "Manage security group of Hyper.sh"},
+	{"service", "Manage service of Hyper.sh"},
+	{"cron", "Manage cron service of Hyper.sh"},
+	{"func", "Manage func service of Hyper.sh"},
+}
+
+// DockerCommands stores all the docker command
+var DockerCommands = make(map[string]Command)
+
+func init() {
+	for _, cmd := range dockerCommands {
+		DockerCommands[cmd.Name] = cmd
+	}
+}