Implement docker network with standalone client lib.

Signed-off-by: David Calavera <david.calavera@gmail.com>

api/client/lib/network.go

@@ -0,0 +1,67 @@
+package lib
+
+import (
+	"encoding/json"
+
+	"github.com/docker/docker/api/types"
+)
+
+// NetworkCreate creates a new network in the docker host.
+func (cli *Client) NetworkCreate(options types.NetworkCreate) (types.NetworkCreateResponse, error) {
+	var response types.NetworkCreateResponse
+	serverResp, err := cli.POST("/networks/create", nil, options, nil)
+	if err != nil {
+		return response, err
+	}
+
+	json.NewDecoder(serverResp.body).Decode(&response)
+	ensureReaderClosed(serverResp)
+	return response, err
+}
+
+// NetworkRemove removes an existent network from the docker host.
+func (cli *Client) NetworkRemove(networkID string) error {
+	resp, err := cli.DELETE("/networks/"+networkID, nil, nil)
+	ensureReaderClosed(resp)
+	return err
+}
+
+// NetworkConnect connects a container to an existent network in the docker host.
+func (cli *Client) NetworkConnect(networkID, containerID string) error {
+	nc := types.NetworkConnect{containerID}
+	resp, err := cli.POST("/networks/"+networkID+"/connect", nil, nc, nil)
+	ensureReaderClosed(resp)
+	return err
+}
+
+// NetworkDisconnect disconnects a container from an existent network in the docker host.
+func (cli *Client) NetworkDisconnect(networkID, containerID string) error {
+	nc := types.NetworkConnect{containerID}
+	resp, err := cli.POST("/networks/"+networkID+"/disconnect", nil, nc, nil)
+	ensureReaderClosed(resp)
+	return err
+}
+
+// NetworkList returns the list of networks configured in the docker host.
+func (cli *Client) NetworkList() ([]types.NetworkResource, error) {
+	var networkResources []types.NetworkResource
+	resp, err := cli.GET("/networks", nil, nil)
+	if err != nil {
+		return networkResources, err
+	}
+	defer ensureReaderClosed(resp)
+	err = json.NewDecoder(resp.body).Decode(&networkResources)
+	return networkResources, err
+}
+
+// NetworkInspect returns the information for a specific network configured in the docker host.
+func (cli *Client) NetworkInspect(networkID string) (types.NetworkResource, error) {
+	var networkResource types.NetworkResource
+	resp, err := cli.GET("/networks/"+networkID, nil, nil)
+	if err != nil {
+		return networkResource, err
+	}
+	defer ensureReaderClosed(resp)
+	err = json.NewDecoder(resp.body).Decode(&networkResource)
+	return networkResource, err
+}

api/client/lib/request.go

@@ -148,7 +148,11 @@ func encodeData(data interface{}) (*bytes.Buffer, error) {
 	return params, nil
 }
 
+<<<<<<< HEAD
 func ensureReaderClosed(response *ServerResponse) {
+=======
+func ensureReaderClosed(response *serverResponse) {
+>>>>>>> 9c13063... Implement docker network with standalone client lib.
 	if response != nil && response.body != nil {
 		response.body.Close()
 	}

api/client/network.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"io"
 	"net"
-	"net/http"
 	"strings"
 	"text/tabwriter"
 	"text/template"
@@ -76,12 +75,8 @@ func (cli *DockerCli) CmdNetworkCreate(args ...string) error {
 		Options:        flOpts.GetAll(),
 		CheckDuplicate: true,
 	}
-	obj, _, err := readBody(cli.call("POST", "/networks/create", nc, nil))
-	if err != nil {
-		return err
-	}
-	var resp types.NetworkCreateResponse
-	err = json.Unmarshal(obj, &resp)
+
+	resp, err := cli.client.NetworkCreate(nc)
 	if err != nil {
 		return err
 	}
@@ -95,15 +90,13 @@ func (cli *DockerCli) CmdNetworkCreate(args ...string) error {
 func (cli *DockerCli) CmdNetworkRm(args ...string) error {
 	cmd := Cli.Subcmd("network rm", []string{"NETWORK [NETWORK...]"}, "Deletes one or more networks", false)
 	cmd.Require(flag.Min, 1)
-	err := cmd.ParseFlags(args, true)
-	if err != nil {
+	if err := cmd.ParseFlags(args, true); err != nil {
 		return err
 	}
 
 	status := 0
 	for _, net := range cmd.Args() {
-		_, _, err = readBody(cli.call("DELETE", "/networks/"+net, nil, nil))
-		if err != nil {
+		if err := cli.client.NetworkRemove(net); err != nil {
 			fmt.Fprintf(cli.err, "%s\n", err)
 			status = 1
 			continue
@@ -121,14 +114,11 @@ func (cli *DockerCli) CmdNetworkRm(args ...string) error {
 func (cli *DockerCli) CmdNetworkConnect(args ...string) error {
 	cmd := Cli.Subcmd("network connect", []string{"NETWORK CONTAINER"}, "Connects a container to a network", false)
 	cmd.Require(flag.Exact, 2)
-	err := cmd.ParseFlags(args, true)
-	if err != nil {
+	if err := cmd.ParseFlags(args, true); err != nil {
 		return err
 	}
 
-	nc := types.NetworkConnect{Container: cmd.Arg(1)}
-	_, _, err = readBody(cli.call("POST", "/networks/"+cmd.Arg(0)+"/connect", nc, nil))
-	return err
+	return cli.client.NetworkConnect(cmd.Arg(0), cmd.Arg(1))
 }
 
 // CmdNetworkDisconnect disconnects a container from a network
@@ -137,14 +127,11 @@ func (cli *DockerCli) CmdNetworkConnect(args ...string) error {
 func (cli *DockerCli) CmdNetworkDisconnect(args ...string) error {
 	cmd := Cli.Subcmd("network disconnect", []string{"NETWORK CONTAINER"}, "Disconnects container from a network", false)
 	cmd.Require(flag.Exact, 2)
-	err := cmd.ParseFlags(args, true)
-	if err != nil {
+	if err := cmd.ParseFlags(args, true); err != nil {
 		return err
 	}
 
-	nc := types.NetworkConnect{Container: cmd.Arg(1)}
-	_, _, err = readBody(cli.call("POST", "/networks/"+cmd.Arg(0)+"/disconnect", nc, nil))
-	return err
+	return cli.client.NetworkDisconnect(cmd.Arg(0), cmd.Arg(1))
 }
 
 // CmdNetworkLs lists all the netorks managed by docker daemon
@@ -156,18 +143,11 @@ func (cli *DockerCli) CmdNetworkLs(args ...string) error {
 	noTrunc := cmd.Bool([]string{"-no-trunc"}, false, "Do not truncate the output")
 
 	cmd.Require(flag.Exact, 0)
-	err := cmd.ParseFlags(args, true)
-
-	if err != nil {
-		return err
-	}
-	obj, _, err := readBody(cli.call("GET", "/networks", nil, nil))
-	if err != nil {
+	if err := cmd.ParseFlags(args, true); err != nil {
 		return err
 	}
 
-	var networkResources []types.NetworkResource
-	err = json.Unmarshal(obj, &networkResources)
+	networkResources, err := cli.client.NetworkList()
 	if err != nil {
 		return err
 	}
@@ -225,31 +205,19 @@ func (cli *DockerCli) CmdNetworkInspect(args ...string) error {
 	var networks []types.NetworkResource
 	buf := new(bytes.Buffer)
 	for _, name := range cmd.Args() {
-		obj, statusCode, err := readBody(cli.call("GET", "/networks/"+name, nil, nil))
+		networkResource, err := cli.client.NetworkInspect(name)
 		if err != nil {
-			if statusCode == http.StatusNotFound {
-				fmt.Fprintf(cli.err, "Error: No such network: %s\n", name)
-			} else {
-				fmt.Fprintf(cli.err, "%s\n", err)
-			}
-			status = 1
-			continue
+			fmt.Fprintf(cli.err, "%s\n", err)
+			return Cli.StatusError{StatusCode: 1}
 		}
-		var networkResource types.NetworkResource
-		if err := json.NewDecoder(bytes.NewReader(obj)).Decode(&networkResource); err != nil {
-			return err
-		}
-
 		if tmpl == nil {
 			networks = append(networks, networkResource)
 			continue
 		}
 
 		if err := tmpl.Execute(buf, &networkResource); err != nil {
-			if err := tmpl.Execute(buf, &networkResource); err != nil {
-				fmt.Fprintf(cli.err, "%s\n", err)
-				return Cli.StatusError{StatusCode: 1}
-			}
+			fmt.Fprintf(cli.err, "%s\n", err)
+			return Cli.StatusError{StatusCode: 1}
 		}
 		buf.WriteString("\n")
 	}