mcculloughsean · August 29, 2015 14:04 · shykes · Jul 31, 2014 · shykes · Jul 31, 2014
diff --git a/docker_remote_api_proposal.md b/docker_remote_api_proposal.md
diff --git a/proposal.go b/proposal.go
 package api

 import (
 	"crypto/tls"
 	"io"
 )

 // So i don't go crazy with stupid gofmt warnings
 type Container struct {
 }

 var registry interface {
 	ConfigFile
 }

 // Create an Api Client that holds onto state about how to connect to the remote api
 type ApiClient struct {
 	// ...
 }

 func NewApiClient(proto, addr string, tlsConfig *tls.Config) *ApiClient {
 	// ...
 	return &ApiClient{}
 }

 // move call over to the ApiClient as a private method
 func (client *ApiClient) call(method, path string, data interface{}, passAuthInfo bool) (io.ReadCloser, int, error)

 // in a api/client package with each endpoint in separate file
 type PsFlags struct {
 	Quiet   bool
 	Size    bool
 	All     bool
 	NoTrunc bool
 	NLatest bool
 	Since   string
 	Before  string
 	Last    int
 }

 // Separate out encoding to a method
 func (flags PsFlags) UrlEncode() string {

 	v := url.Values{}
 	if flags.Last == -1 && flags.NLatest {
 		flags.Last = 1
 	}
 	if flags.All {
 		v.Set("all", "1")
 	}
 	if flags.Last != -1 {
 		v.Set("limit", strconv.Itoa(flgags.Last))
 	}
 	if flags.Since != "" {
 		v.Set("since", flags.Since)
 	}
 	if flags.Before != "" {
 		v.Set("before", flags.Before)
 	}
 	if flags.Size {
 		v.Set("size", "1")
 	}
 	return v.Encode()

 }

 // Handle logic around managing connection to remote API
 func (client *ApiClient) CallPs(flags PsFlags) (containers []*Container, e error) {
 	body, _, err := readBody(cli.call("GET", "/containers/json?"+v.Encode(), nil, false))
 	if err != nil {
 		return nil, err
 	}
 	if err := json.Unmarshal(body, containers); err != nil {
 		return nil, err
 	}
 	return containers, nil
 }

 // in the main client package, remove raw proto state and include a reference to the client
 type DockerCli struct {
 	configFile *registry.ConfigFile
 	in         io.ReadCloser
 	out        io.Writer
 	err        io.Writer
 	isTerminal bool
 	terminalFd uintptr
 	tlsConfig  *tls.Config
 	scheme     string
 	Client     *ApiClient
 }

 // Refactored version of the CLI command
 func (cli *DockerCli) CmdPs(args ...string) error {
 	// parse out the cli options
 	cmd := cli.Subcmd("ps", "[OPTIONS]", "List containers")
 	quiet := cmd.Bool([]string{"q", "-quiet"}, false, "Only display numeric IDs")
 	size := cmd.Bool([]string{"s", "-size"}, false, "Display sizes")
 	all := cmd.Bool([]string{"a", "-all"}, false, "Show all containers. Only running containers are shown by default.")
 	noTrunc := cmd.Bool([]string{"#notrunc", "-no-trunc"}, false, "Don't truncate output")
 	nLatest := cmd.Bool([]string{"l", "-latest"}, false, "Show only the latest created container, include non-running ones.")
 	since := cmd.String([]string{"#sinceId", "#-since-id", "-since"}, "", "Show only containers created since Id or Name, include non-running ones.")
 	before := cmd.String([]string{"#beforeId", "#-before-id", "-before"}, "", "Show only container created before Id or Name, include non-running ones.")
 	last := cmd.Int([]string{"n"}, -1, "Show n last created containers, include non-running ones.")

 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}

 	// hand those options into a standard interface to the API client
 	flags = PsFlags{
 		Quiet:   *quiet,
 		Size:    *size,
 		All:     *all,
 		NoTrunc: *noTrunc,
 		NLatest: *nLatest,
 		Since:   *since,
 		Before:  *before,
 		Last:    *last,
 	}

 	// call the api client endpoint, get a list of containers back
 	containers, err := cli.Client.CallPs(flags)
 	if err != nil {
 		return err
 	}

 	// delegate to something else to format the output
 	printContainerTable(containers)
 	// or just define a useful String() on Containers struct
 	fmt.Println(containers)

 	return nil
 }
	package api

	import (
	"crypto/tls"
	"io"
	)

	// So i don't go crazy with stupid gofmt warnings
	type Container struct {
	}

	var registry interface {
	ConfigFile
	}

	// Create an Api Client that holds onto state about how to connect to the remote api
	type ApiClient struct {
	// ...
	}

	func NewApiClient(proto, addr string, tlsConfig tls.Config) ApiClient {
	// ...
	return &ApiClient{}
	}

	// move call over to the ApiClient as a private method
	func (client *ApiClient) call(method, path string, data interface{}, passAuthInfo bool) (io.ReadCloser, int, error)

	// in a api/client package with each endpoint in separate file
	type PsFlags struct {
	Quiet bool
	Size bool
	All bool
	NoTrunc bool
	NLatest bool
	Since string
	Before string
	Last int
	}

	// Separate out encoding to a method
	func (flags PsFlags) UrlEncode() string {

	v := url.Values{}
	if flags.Last == -1 && flags.NLatest {
	flags.Last = 1
	}
	if flags.All {
	v.Set("all", "1")
	}
	if flags.Last != -1 {
	v.Set("limit", strconv.Itoa(flgags.Last))
	}
	if flags.Since != "" {
	v.Set("since", flags.Since)
	}
	if flags.Before != "" {
	v.Set("before", flags.Before)
	}
	if flags.Size {
	v.Set("size", "1")
	}
	return v.Encode()

	}

	// Handle logic around managing connection to remote API
	func (client ApiClient) CallPs(flags PsFlags) (containers []Container, e error) {
	body, _, err := readBody(cli.call("GET", "/containers/json?"+v.Encode(), nil, false))
	if err != nil {
	return nil, err
	}
	if err := json.Unmarshal(body, containers); err != nil {
	return nil, err
	}
	return containers, nil
	}

	// in the main client package, remove raw proto state and include a reference to the client
	type DockerCli struct {
	configFile *registry.ConfigFile
	in io.ReadCloser
	out io.Writer
	err io.Writer
	isTerminal bool
	terminalFd uintptr
	tlsConfig *tls.Config
	scheme string
	Client *ApiClient
	}

	// Refactored version of the CLI command
	func (cli *DockerCli) CmdPs(args ...string) error {
	// parse out the cli options
	cmd := cli.Subcmd("ps", "[OPTIONS]", "List containers")
	quiet := cmd.Bool([]string{"q", "-quiet"}, false, "Only display numeric IDs")
	size := cmd.Bool([]string{"s", "-size"}, false, "Display sizes")
	all := cmd.Bool([]string{"a", "-all"}, false, "Show all containers. Only running containers are shown by default.")
	noTrunc := cmd.Bool([]string{"#notrunc", "-no-trunc"}, false, "Don't truncate output")
	nLatest := cmd.Bool([]string{"l", "-latest"}, false, "Show only the latest created container, include non-running ones.")
	since := cmd.String([]string{"#sinceId", "#-since-id", "-since"}, "", "Show only containers created since Id or Name, include non-running ones.")
	before := cmd.String([]string{"#beforeId", "#-before-id", "-before"}, "", "Show only container created before Id or Name, include non-running ones.")
	last := cmd.Int([]string{"n"}, -1, "Show n last created containers, include non-running ones.")

	if err := cmd.Parse(args); err != nil {
	return nil
	}

	// hand those options into a standard interface to the API client
	flags = PsFlags{
	Quiet: *quiet,
	Size: *size,
	All: *all,
	NoTrunc: *noTrunc,
	NLatest: *nLatest,
	Since: *since,
	Before: *before,
	Last: *last,
	}

	// call the api client endpoint, get a list of containers back
	containers, err := cli.Client.CallPs(flags)
	if err != nil {
	return err
	}

	// delegate to something else to format the output
	printContainerTable(containers)
	// or just define a useful String() on Containers struct
	fmt.Println(containers)

	return nil
	}