new file mode 100644

@@ -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

+}

@@ -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()

 	}

@@ -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

-		}

-		var networkResource types.NetworkResource

-		if err := json.NewDecoder(bytes.NewReader(obj)).Decode(&networkResource); err != nil {

-			return err

+			fmt.Fprintf(cli.err, "%s\n", err)

+			return Cli.StatusError{StatusCode: 1}

 		}

-

 		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")

 	}