@@ -3,42 +3,35 @@ package client

 // Command returns a cli command handler if one exists

 func (cli *DockerCli) Command(name string) func(...string) error {

 	return map[string]func(...string) error{

-		"attach":             cli.CmdAttach,

-		"build":              cli.CmdBuild,

-		"commit":             cli.CmdCommit,

-		"cp":                 cli.CmdCp,

-		"events":             cli.CmdEvents,

-		"exec":               cli.CmdExec,

-		"history":            cli.CmdHistory,

-		"images":             cli.CmdImages,

-		"import":             cli.CmdImport,

-		"info":               cli.CmdInfo,

-		"inspect":            cli.CmdInspect,

-		"kill":               cli.CmdKill,

-		"load":               cli.CmdLoad,

-		"login":              cli.CmdLogin,

-		"logout":             cli.CmdLogout,

-		"network":            cli.CmdNetwork,

-		"network create":     cli.CmdNetworkCreate,

-		"network connect":    cli.CmdNetworkConnect,

-		"network disconnect": cli.CmdNetworkDisconnect,

-		"network inspect":    cli.CmdNetworkInspect,

-		"network ls":         cli.CmdNetworkLs,

-		"network rm":         cli.CmdNetworkRm,

-		"pause":              cli.CmdPause,

-		"port":               cli.CmdPort,

-		"ps":                 cli.CmdPs,

-		"pull":               cli.CmdPull,

-		"push":               cli.CmdPush,

-		"rename":             cli.CmdRename,

-		"restart":            cli.CmdRestart,

-		"rm":                 cli.CmdRm,

-		"save":               cli.CmdSave,

-		"stats":              cli.CmdStats,

-		"tag":                cli.CmdTag,

-		"top":                cli.CmdTop,

-		"update":             cli.CmdUpdate,

-		"version":            cli.CmdVersion,

-		"wait":               cli.CmdWait,

+		"attach":  cli.CmdAttach,

+		"build":   cli.CmdBuild,

+		"commit":  cli.CmdCommit,

+		"cp":      cli.CmdCp,

+		"events":  cli.CmdEvents,

+		"exec":    cli.CmdExec,

+		"history": cli.CmdHistory,

+		"images":  cli.CmdImages,

+		"import":  cli.CmdImport,

+		"info":    cli.CmdInfo,

+		"inspect": cli.CmdInspect,

+		"kill":    cli.CmdKill,

+		"load":    cli.CmdLoad,

+		"login":   cli.CmdLogin,

+		"logout":  cli.CmdLogout,

+		"pause":   cli.CmdPause,

+		"port":    cli.CmdPort,

+		"ps":      cli.CmdPs,

+		"pull":    cli.CmdPull,

+		"push":    cli.CmdPush,

+		"rename":  cli.CmdRename,

+		"restart": cli.CmdRestart,

+		"rm":      cli.CmdRm,

+		"save":    cli.CmdSave,

+		"stats":   cli.CmdStats,

+		"tag":     cli.CmdTag,

+		"top":     cli.CmdTop,

+		"update":  cli.CmdUpdate,

+		"version": cli.CmdVersion,

+		"wait":    cli.CmdWait,

 	}[name]

 }

deleted file mode 100644

@@ -1,397 +0,0 @@

-package client

-

-import (

-	"fmt"

-	"net"

-	"sort"

-	"strings"

-	"text/tabwriter"

-

-	"golang.org/x/net/context"

-

-	"github.com/docker/docker/api/client/inspect"

-	Cli "github.com/docker/docker/cli"

-	"github.com/docker/docker/opts"

-	flag "github.com/docker/docker/pkg/mflag"

-	"github.com/docker/docker/pkg/stringid"

-	runconfigopts "github.com/docker/docker/runconfig/opts"

-	"github.com/docker/engine-api/types"

-	"github.com/docker/engine-api/types/filters"

-	"github.com/docker/engine-api/types/network"

-)

-

-// CmdNetwork is the parent subcommand for all network commands

-//

-// Usage: docker network <COMMAND> [OPTIONS]

-func (cli *DockerCli) CmdNetwork(args ...string) error {

-	cmd := Cli.Subcmd("network", []string{"COMMAND [OPTIONS]"}, networkUsage(), false)

-	cmd.Require(flag.Min, 1)

-	err := cmd.ParseFlags(args, true)

-	cmd.Usage()

-	return err

-}

-

-// CmdNetworkCreate creates a new network with a given name

-//

-// Usage: docker network create [OPTIONS] <NETWORK-NAME>

-func (cli *DockerCli) CmdNetworkCreate(args ...string) error {

-	cmd := Cli.Subcmd("network create", []string{"NETWORK-NAME"}, "Creates a new network with a name specified by the user", false)

-	flDriver := cmd.String([]string{"d", "-driver"}, "bridge", "Driver to manage the Network")

-	flOpts := opts.NewMapOpts(nil, nil)

-

-	flIpamDriver := cmd.String([]string{"-ipam-driver"}, "default", "IP Address Management Driver")

-	flIpamSubnet := opts.NewListOpts(nil)

-	flIpamIPRange := opts.NewListOpts(nil)

-	flIpamGateway := opts.NewListOpts(nil)

-	flIpamAux := opts.NewMapOpts(nil, nil)

-	flIpamOpt := opts.NewMapOpts(nil, nil)

-	flLabels := opts.NewListOpts(nil)

-

-	cmd.Var(&flIpamSubnet, []string{"-subnet"}, "subnet in CIDR format that represents a network segment")

-	cmd.Var(&flIpamIPRange, []string{"-ip-range"}, "allocate container ip from a sub-range")

-	cmd.Var(&flIpamGateway, []string{"-gateway"}, "ipv4 or ipv6 Gateway for the master subnet")

-	cmd.Var(flIpamAux, []string{"-aux-address"}, "auxiliary ipv4 or ipv6 addresses used by Network driver")

-	cmd.Var(flOpts, []string{"o", "-opt"}, "set driver specific options")

-	cmd.Var(flIpamOpt, []string{"-ipam-opt"}, "set IPAM driver specific options")

-	cmd.Var(&flLabels, []string{"-label"}, "set metadata on a network")

-

-	flInternal := cmd.Bool([]string{"-internal"}, false, "restricts external access to the network")

-	flIPv6 := cmd.Bool([]string{"-ipv6"}, false, "enable IPv6 networking")

-

-	cmd.Require(flag.Exact, 1)

-	err := cmd.ParseFlags(args, true)

-	if err != nil {

-		return err

-	}

-

-	// Set the default driver to "" if the user didn't set the value.

-	// That way we can know whether it was user input or not.

-	driver := *flDriver

-	if !cmd.IsSet("-driver") && !cmd.IsSet("d") {

-		driver = ""

-	}

-

-	ipamCfg, err := consolidateIpam(flIpamSubnet.GetAll(), flIpamIPRange.GetAll(), flIpamGateway.GetAll(), flIpamAux.GetAll())

-	if err != nil {

-		return err

-	}

-

-	// Construct network create request body

-	nc := types.NetworkCreate{

-		Driver:         driver,

-		IPAM:           network.IPAM{Driver: *flIpamDriver, Config: ipamCfg, Options: flIpamOpt.GetAll()},

-		Options:        flOpts.GetAll(),

-		CheckDuplicate: true,

-		Internal:       *flInternal,

-		EnableIPv6:     *flIPv6,

-		Labels:         runconfigopts.ConvertKVStringsToMap(flLabels.GetAll()),

-	}

-

-	resp, err := cli.client.NetworkCreate(context.Background(), cmd.Arg(0), nc)

-	if err != nil {

-		return err

-	}

-	fmt.Fprintf(cli.out, "%s\n", resp.ID)

-	return nil

-}

-

-// CmdNetworkRm deletes one or more networks

-//

-// Usage: docker network rm NETWORK-NAME|NETWORK-ID [NETWORK-NAME|NETWORK-ID...]

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

-	if err := cmd.ParseFlags(args, true); err != nil {

-		return err

-	}

-

-	ctx := context.Background()

-

-	status := 0

-	for _, net := range cmd.Args() {

-		if err := cli.client.NetworkRemove(ctx, net); err != nil {

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

-			status = 1

-			continue

-		}

-		fmt.Fprintf(cli.out, "%s\n", net)

-	}

-	if status != 0 {

-		return Cli.StatusError{StatusCode: status}

-	}

-	return nil

-}

-

-// CmdNetworkConnect connects a container to a network

-//

-// Usage: docker network connect [OPTIONS] <NETWORK> <CONTAINER>

-func (cli *DockerCli) CmdNetworkConnect(args ...string) error {

-	cmd := Cli.Subcmd("network connect", []string{"NETWORK CONTAINER"}, "Connects a container to a network", false)

-	flIPAddress := cmd.String([]string{"-ip"}, "", "IP Address")

-	flIPv6Address := cmd.String([]string{"-ip6"}, "", "IPv6 Address")

-	flLinks := opts.NewListOpts(runconfigopts.ValidateLink)

-	cmd.Var(&flLinks, []string{"-link"}, "Add link to another container")

-	flAliases := opts.NewListOpts(nil)

-	cmd.Var(&flAliases, []string{"-alias"}, "Add network-scoped alias for the container")

-	cmd.Require(flag.Min, 2)

-	if err := cmd.ParseFlags(args, true); err != nil {

-		return err

-	}

-	epConfig := &network.EndpointSettings{

-		IPAMConfig: &network.EndpointIPAMConfig{

-			IPv4Address: *flIPAddress,

-			IPv6Address: *flIPv6Address,

-		},

-		Links:   flLinks.GetAll(),

-		Aliases: flAliases.GetAll(),

-	}

-	return cli.client.NetworkConnect(context.Background(), cmd.Arg(0), cmd.Arg(1), epConfig)

-}

-

-// CmdNetworkDisconnect disconnects a container from a network

-//

-// Usage: docker network disconnect <NETWORK> <CONTAINER>

-func (cli *DockerCli) CmdNetworkDisconnect(args ...string) error {

-	cmd := Cli.Subcmd("network disconnect", []string{"NETWORK CONTAINER"}, "Disconnects container from a network", false)

-	force := cmd.Bool([]string{"f", "-force"}, false, "Force the container to disconnect from a network")

-	cmd.Require(flag.Exact, 2)

-	if err := cmd.ParseFlags(args, true); err != nil {

-		return err

-	}

-

-	return cli.client.NetworkDisconnect(context.Background(), cmd.Arg(0), cmd.Arg(1), *force)

-}

-

-// CmdNetworkLs lists all the networks managed by docker daemon

-//

-// Usage: docker network ls [OPTIONS]

-func (cli *DockerCli) CmdNetworkLs(args ...string) error {

-	cmd := Cli.Subcmd("network ls", nil, "Lists networks", true)

-	quiet := cmd.Bool([]string{"q", "-quiet"}, false, "Only display numeric IDs")

-	noTrunc := cmd.Bool([]string{"-no-trunc"}, false, "Do not truncate the output")

-

-	flFilter := opts.NewListOpts(nil)

-	cmd.Var(&flFilter, []string{"f", "-filter"}, "Filter output based on conditions provided")

-

-	cmd.Require(flag.Exact, 0)

-	err := cmd.ParseFlags(args, true)

-	if err != nil {

-		return err

-	}

-

-	// Consolidate all filter flags, and sanity check them early.

-	// They'll get process after get response from server.

-	netFilterArgs := filters.NewArgs()

-	for _, f := range flFilter.GetAll() {

-		if netFilterArgs, err = filters.ParseFlag(f, netFilterArgs); err != nil {

-			return err

-		}

-	}

-

-	options := types.NetworkListOptions{

-		Filters: netFilterArgs,

-	}

-

-	networkResources, err := cli.client.NetworkList(context.Background(), options)

-	if err != nil {

-		return err

-	}

-

-	wr := tabwriter.NewWriter(cli.out, 20, 1, 3, ' ', 0)

-

-	// unless quiet (-q) is specified, print field titles

-	if !*quiet {

-		fmt.Fprintln(wr, "NETWORK ID\tNAME\tDRIVER")

-	}

-	sort.Sort(byNetworkName(networkResources))

-	for _, networkResource := range networkResources {

-		ID := networkResource.ID

-		netName := networkResource.Name

-		if !*noTrunc {

-			ID = stringid.TruncateID(ID)

-		}

-		if *quiet {

-			fmt.Fprintln(wr, ID)

-			continue

-		}

-		driver := networkResource.Driver

-		fmt.Fprintf(wr, "%s\t%s\t%s\t",

-			ID,

-			netName,

-			driver)

-		fmt.Fprint(wr, "\n")

-	}

-	wr.Flush()

-	return nil

-}

-

-type byNetworkName []types.NetworkResource

-

-func (r byNetworkName) Len() int           { return len(r) }

-func (r byNetworkName) Swap(i, j int)      { r[i], r[j] = r[j], r[i] }

-func (r byNetworkName) Less(i, j int) bool { return r[i].Name < r[j].Name }

-

-// CmdNetworkInspect inspects the network object for more details

-//

-// Usage: docker network inspect [OPTIONS] <NETWORK> [NETWORK...]

-func (cli *DockerCli) CmdNetworkInspect(args ...string) error {

-	cmd := Cli.Subcmd("network inspect", []string{"NETWORK [NETWORK...]"}, "Displays detailed information on one or more networks", false)

-	tmplStr := cmd.String([]string{"f", "-format"}, "", "Format the output using the given go template")

-	cmd.Require(flag.Min, 1)

-

-	if err := cmd.ParseFlags(args, true); err != nil {

-		return err

-	}

-

-	ctx := context.Background()

-

-	inspectSearcher := func(name string) (interface{}, []byte, error) {

-		i, err := cli.client.NetworkInspect(ctx, name)

-		return i, nil, err

-	}

-

-	return inspect.Inspect(cli.out, cmd.Args(), *tmplStr, inspectSearcher)

-}

-

-// Consolidates the ipam configuration as a group from different related configurations

-// user can configure network with multiple non-overlapping subnets and hence it is

-// possible to correlate the various related parameters and consolidate them.

-// consoidateIpam consolidates subnets, ip-ranges, gateways and auxiliary addresses into

-// structured ipam data.

-func consolidateIpam(subnets, ranges, gateways []string, auxaddrs map[string]string) ([]network.IPAMConfig, error) {

-	if len(subnets) < len(ranges) || len(subnets) < len(gateways) {

-		return nil, fmt.Errorf("every ip-range or gateway must have a corresponding subnet")

-	}

-	iData := map[string]*network.IPAMConfig{}

-

-	// Populate non-overlapping subnets into consolidation map

-	for _, s := range subnets {

-		for k := range iData {

-			ok1, err := subnetMatches(s, k)

-			if err != nil {

-				return nil, err

-			}

-			ok2, err := subnetMatches(k, s)

-			if err != nil {

-				return nil, err

-			}

-			if ok1 || ok2 {

-				return nil, fmt.Errorf("multiple overlapping subnet configuration is not supported")

-			}

-		}

-		iData[s] = &network.IPAMConfig{Subnet: s, AuxAddress: map[string]string{}}

-	}

-

-	// Validate and add valid ip ranges

-	for _, r := range ranges {

-		match := false

-		for _, s := range subnets {

-			ok, err := subnetMatches(s, r)

-			if err != nil {

-				return nil, err

-			}

-			if !ok {

-				continue

-			}

-			if iData[s].IPRange != "" {

-				return nil, fmt.Errorf("cannot configure multiple ranges (%s, %s) on the same subnet (%s)", r, iData[s].IPRange, s)

-			}

-			d := iData[s]

-			d.IPRange = r

-			match = true

-		}

-		if !match {

-			return nil, fmt.Errorf("no matching subnet for range %s", r)

-		}

-	}

-

-	// Validate and add valid gateways

-	for _, g := range gateways {

-		match := false

-		for _, s := range subnets {

-			ok, err := subnetMatches(s, g)

-			if err != nil {

-				return nil, err

-			}

-			if !ok {

-				continue

-			}

-			if iData[s].Gateway != "" {

-				return nil, fmt.Errorf("cannot configure multiple gateways (%s, %s) for the same subnet (%s)", g, iData[s].Gateway, s)

-			}

-			d := iData[s]

-			d.Gateway = g

-			match = true

-		}

-		if !match {

-			return nil, fmt.Errorf("no matching subnet for gateway %s", g)

-		}

-	}

-

-	// Validate and add aux-addresses

-	for key, aa := range auxaddrs {

-		match := false

-		for _, s := range subnets {

-			ok, err := subnetMatches(s, aa)

-			if err != nil {

-				return nil, err

-			}

-			if !ok {

-				continue

-			}

-			iData[s].AuxAddress[key] = aa

-			match = true

-		}

-		if !match {

-			return nil, fmt.Errorf("no matching subnet for aux-address %s", aa)

-		}

-	}

-

-	idl := []network.IPAMConfig{}

-	for _, v := range iData {

-		idl = append(idl, *v)

-	}

-	return idl, nil

-}

-

-func subnetMatches(subnet, data string) (bool, error) {

-	var (

-		ip net.IP

-	)

-

-	_, s, err := net.ParseCIDR(subnet)

-	if err != nil {

-		return false, fmt.Errorf("Invalid subnet %s : %v", s, err)

-	}

-

-	if strings.Contains(data, "/") {

-		ip, _, err = net.ParseCIDR(data)

-		if err != nil {

-			return false, fmt.Errorf("Invalid cidr %s : %v", data, err)

-		}

-	} else {

-		ip = net.ParseIP(data)

-	}

-

-	return s.Contains(ip), nil

-}

-

-func networkUsage() string {

-	networkCommands := [][]string{

-		{"create", "Create a network"},

-		{"connect", "Connect container to a network"},

-		{"disconnect", "Disconnect container from a network"},

-		{"inspect", "Display detailed network information"},

-		{"ls", "List all networks"},

-		{"rm", "Remove a network"},

-	}

-

-	help := "Commands:\n"

-

-	for _, cmd := range networkCommands {

-		help += fmt.Sprintf("  %-25.25s%s\n", cmd[0], cmd[1])

-	}

-

-	help += fmt.Sprintf("\nRun 'docker network COMMAND --help' for more information on a command.")

-	return help

-}

new file mode 100644

@@ -0,0 +1,31 @@

+package network

+

+import (

+	"fmt"

+

+	"github.com/spf13/cobra"

+

+	"github.com/docker/docker/api/client"

+	"github.com/docker/docker/cli"

+)

+

+// NewNetworkCommand returns a cobra command for `network` subcommands

+func NewNetworkCommand(dockerCli *client.DockerCli) *cobra.Command {

+	cmd := &cobra.Command{

+		Use:   "network",

+		Short: "Manage Docker networks",

+		Args:  cli.NoArgs,

+		Run: func(cmd *cobra.Command, args []string) {

+			fmt.Fprintf(dockerCli.Err(), "\n"+cmd.UsageString())

+		},

+	}

+	cmd.AddCommand(

+		newConnectCommand(dockerCli),

+		newCreateCommand(dockerCli),

+		newDisconnectCommand(dockerCli),

+		newInspectCommand(dockerCli),

+		newListCommand(dockerCli),

+		newRemoveCommand(dockerCli),

+	)

+	return cmd

+}

new file mode 100644

@@ -0,0 +1,61 @@

+package network

+

+import (

+	"golang.org/x/net/context"

+

+	"github.com/docker/docker/api/client"

+	"github.com/docker/docker/cli"

+	"github.com/docker/docker/opts"

+	runconfigopts "github.com/docker/docker/runconfig/opts"

+	"github.com/docker/engine-api/types/network"

+	"github.com/spf13/cobra"

+)

+

+type connectOptions struct {

+	network     string

+	container   string

+	ipaddress   string

+	ipv6address string

+	links       opts.ListOpts

+	aliases     []string

+}

+

+func newConnectCommand(dockerCli *client.DockerCli) *cobra.Command {

+	opts := connectOptions{

+		links: opts.NewListOpts(runconfigopts.ValidateLink),

+	}

+

+	cmd := &cobra.Command{

+		Use:   "connect [OPTIONS] NETWORK CONTAINER",

+		Short: "Connects a container to a network",

+		Args:  cli.ExactArgs(2),

+		RunE: func(cmd *cobra.Command, args []string) error {

+			opts.network = args[0]

+			opts.container = args[1]

+			return runConnect(dockerCli, opts)

+		},

+	}

+

+	flags := cmd.Flags()

+	flags.StringVar(&opts.ipaddress, "ip", "", "IP Address")

+	flags.StringVar(&opts.ipv6address, "ip6", "", "IPv6 Address")

+	flags.Var(&opts.links, "link", "Add link to another container")

+	flags.StringSliceVar(&opts.aliases, "alias", []string{}, "Add network-scoped alias for the container")

+

+	return cmd

+}

+

+func runConnect(dockerCli *client.DockerCli, opts connectOptions) error {

+	client := dockerCli.Client()

+

+	epConfig := &network.EndpointSettings{

+		IPAMConfig: &network.EndpointIPAMConfig{

+			IPv4Address: opts.ipaddress,

+			IPv6Address: opts.ipv6address,

+		},

+		Links:   opts.links.GetAll(),

+		Aliases: opts.aliases,

+	}

+

+	return client.NetworkConnect(context.Background(), opts.network, opts.container, epConfig)

+}

new file mode 100644

@@ -0,0 +1,222 @@

+package network

+

+import (

+	"fmt"

+	"net"

+	"strings"

+

+	"golang.org/x/net/context"

+

+	"github.com/docker/docker/api/client"

+	"github.com/docker/docker/cli"

+	"github.com/docker/docker/opts"

+	runconfigopts "github.com/docker/docker/runconfig/opts"

+	"github.com/docker/engine-api/types"

+	"github.com/docker/engine-api/types/network"

+	"github.com/spf13/cobra"

+)

+

+type createOptions struct {

+	name       string

+	driver     string

+	driverOpts opts.MapOpts

+	labels     []string

+	internal   bool

+	ipv6       bool

+

+	ipamDriver  string

+	ipamSubnet  []string

+	ipamIPRange []string

+	ipamGateway []string

+	ipamAux     opts.MapOpts

+	ipamOpt     opts.MapOpts

+}

+

+func newCreateCommand(dockerCli *client.DockerCli) *cobra.Command {

+	opts := createOptions{

+		driverOpts: *opts.NewMapOpts(nil, nil),

+		ipamAux:    *opts.NewMapOpts(nil, nil),

+		ipamOpt:    *opts.NewMapOpts(nil, nil),

+	}

+

+	cmd := &cobra.Command{

+		Use:   "create",

+		Short: "Create a network",

+		Args:  cli.ExactArgs(1),

+		RunE: func(cmd *cobra.Command, args []string) error {

+			opts.name = args[0]

+			return runCreate(dockerCli, opts)

+		},

+	}

+

+	flags := cmd.Flags()

+	flags.StringVarP(&opts.driver, "driver", "d", "bridge", "Driver to manage the Network")

+	flags.VarP(&opts.driverOpts, "opt", "o", "Set driver specific options")

+	flags.StringSliceVar(&opts.labels, "label", []string{}, "Set metadata on a network")

+	flags.BoolVar(&opts.internal, "internal", false, "restricts external access to the network")

+	flags.BoolVar(&opts.ipv6, "ipv6", false, "enable IPv6 networking")

+

+	flags.StringVar(&opts.ipamDriver, "ipam-driver", "default", "IP Address Management Driver")

+	flags.StringSliceVar(&opts.ipamSubnet, "subnet", []string{}, "subnet in CIDR format that represents a network segment")

+	flags.StringSliceVar(&opts.ipamIPRange, "ip-range", []string{}, "allocate container ip from a sub-range")

+	flags.StringSliceVar(&opts.ipamGateway, "gateway", []string{}, "ipv4 or ipv6 Gateway for the master subnet")

+

+	flags.Var(&opts.ipamAux, "aux-address", "auxiliary ipv4 or ipv6 addresses used by Network driver")

+	flags.Var(&opts.ipamOpt, "ipam-opt", "set IPAM driver specific options")

+

+	return cmd

+}

+

+func runCreate(dockerCli *client.DockerCli, opts createOptions) error {

+	client := dockerCli.Client()

+

+	ipamCfg, err := consolidateIpam(opts.ipamSubnet, opts.ipamIPRange, opts.ipamGateway, opts.ipamAux.GetAll())

+	if err != nil {

+		return err

+	}

+

+	// Construct network create request body

+	nc := types.NetworkCreate{

+		Driver:  opts.driver,

+		Options: opts.driverOpts.GetAll(),

+		IPAM: network.IPAM{

+			Driver:  opts.ipamDriver,

+			Config:  ipamCfg,

+			Options: opts.ipamOpt.GetAll(),

+		},

+		CheckDuplicate: true,

+		Internal:       opts.internal,

+		EnableIPv6:     opts.ipv6,

+		Labels:         runconfigopts.ConvertKVStringsToMap(opts.labels),

+	}

+

+	resp, err := client.NetworkCreate(context.Background(), opts.name, nc)

+	if err != nil {

+		return err

+	}

+	fmt.Fprintf(dockerCli.Out(), "%s\n", resp.ID)

+	return nil

+}

+

+// Consolidates the ipam configuration as a group from different related configurations

+// user can configure network with multiple non-overlapping subnets and hence it is

+// possible to correlate the various related parameters and consolidate them.

+// consoidateIpam consolidates subnets, ip-ranges, gateways and auxiliary addresses into

+// structured ipam data.

+func consolidateIpam(subnets, ranges, gateways []string, auxaddrs map[string]string) ([]network.IPAMConfig, error) {

+	if len(subnets) < len(ranges) || len(subnets) < len(gateways) {

+		return nil, fmt.Errorf("every ip-range or gateway must have a corresponding subnet")

+	}

+	iData := map[string]*network.IPAMConfig{}

+

+	// Populate non-overlapping subnets into consolidation map

+	for _, s := range subnets {

+		for k := range iData {

+			ok1, err := subnetMatches(s, k)

+			if err != nil {

+				return nil, err

+			}

+			ok2, err := subnetMatches(k, s)

+			if err != nil {

+				return nil, err

+			}

+			if ok1 || ok2 {

+				return nil, fmt.Errorf("multiple overlapping subnet configuration is not supported")

+			}

+		}

+		iData[s] = &network.IPAMConfig{Subnet: s, AuxAddress: map[string]string{}}

+	}

+

+	// Validate and add valid ip ranges

+	for _, r := range ranges {

+		match := false

+		for _, s := range subnets {

+			ok, err := subnetMatches(s, r)

+			if err != nil {

+				return nil, err

+			}

+			if !ok {

+				continue

+			}

+			if iData[s].IPRange != "" {

+				return nil, fmt.Errorf("cannot configure multiple ranges (%s, %s) on the same subnet (%s)", r, iData[s].IPRange, s)

+			}

+			d := iData[s]

+			d.IPRange = r

+			match = true

+		}

+		if !match {

+			return nil, fmt.Errorf("no matching subnet for range %s", r)

+		}

+	}

+

+	// Validate and add valid gateways

+	for _, g := range gateways {

+		match := false

+		for _, s := range subnets {

+			ok, err := subnetMatches(s, g)

+			if err != nil {

+				return nil, err

+			}

+			if !ok {

+				continue

+			}

+			if iData[s].Gateway != "" {

+				return nil, fmt.Errorf("cannot configure multiple gateways (%s, %s) for the same subnet (%s)", g, iData[s].Gateway, s)

+			}

+			d := iData[s]

+			d.Gateway = g

+			match = true

+		}

+		if !match {

+			return nil, fmt.Errorf("no matching subnet for gateway %s", g)

+		}

+	}

+

+	// Validate and add aux-addresses

+	for key, aa := range auxaddrs {

+		match := false

+		for _, s := range subnets {

+			ok, err := subnetMatches(s, aa)

+			if err != nil {

+				return nil, err

+			}

+			if !ok {

+				continue

+			}

+			iData[s].AuxAddress[key] = aa

+			match = true

+		}

+		if !match {

+			return nil, fmt.Errorf("no matching subnet for aux-address %s", aa)

+		}

+	}

+

+	idl := []network.IPAMConfig{}

+	for _, v := range iData {

+		idl = append(idl, *v)

+	}

+	return idl, nil

+}

+

+func subnetMatches(subnet, data string) (bool, error) {

+	var (

+		ip net.IP

+	)

+

+	_, s, err := net.ParseCIDR(subnet)

+	if err != nil {

+		return false, fmt.Errorf("Invalid subnet %s : %v", s, err)

+	}

+

+	if strings.Contains(data, "/") {

+		ip, _, err = net.ParseCIDR(data)

+		if err != nil {

+			return false, fmt.Errorf("Invalid cidr %s : %v", data, err)

+		}

+	} else {

+		ip = net.ParseIP(data)

+	}

+

+	return s.Contains(ip), nil

+}

new file mode 100644

@@ -0,0 +1,41 @@

+package network

+

+import (

+	"golang.org/x/net/context"

+

+	"github.com/docker/docker/api/client"

+	"github.com/docker/docker/cli"

+	"github.com/spf13/cobra"

+)

+

+type disconnectOptions struct {

+	network   string

+	container string

+	force     bool

+}

+

+func newDisconnectCommand(dockerCli *client.DockerCli) *cobra.Command {

+	opts := disconnectOptions{}

+

+	cmd := &cobra.Command{

+		Use:   "disconnect [OPTIONS] NETWORK CONTAINER",

+		Short: "Disconnects container from a network",

+		Args:  cli.ExactArgs(2),

+		RunE: func(cmd *cobra.Command, args []string) error {

+			opts.network = args[0]

+			opts.container = args[1]

+			return runDisconnect(dockerCli, opts)

+		},

+	}

+

+	flags := cmd.Flags()

+	flags.BoolVarP(&opts.force, "force", "f", false, "Force the container to disconnect from a network")

+

+	return cmd

+}

+

+func runDisconnect(dockerCli *client.DockerCli, opts disconnectOptions) error {

+	client := dockerCli.Client()

+

+	return client.NetworkDisconnect(context.Background(), opts.network, opts.container, opts.force)

+}

new file mode 100644

@@ -0,0 +1,44 @@

+package network

+

+import (

+	"golang.org/x/net/context"

+

+	"github.com/docker/docker/api/client"

+	"github.com/docker/docker/api/client/inspect"

+	"github.com/docker/docker/cli"

+	"github.com/spf13/cobra"

+)

+

+type inspectOptions struct {

+	format string

+	names  []string

+}

+

+func newInspectCommand(dockerCli *client.DockerCli) *cobra.Command {

+	var opts inspectOptions

+

+	cmd := &cobra.Command{

+		Use:   "inspect [OPTIONS] NETWORK [NETWORK...]",

+		Short: "Displays detailed information on one or more networks",

+		Args:  cli.RequiresMinArgs(1),

+		RunE: func(cmd *cobra.Command, args []string) error {

+			opts.names = args

+			return runInspect(dockerCli, opts)

+		},

+	}

+

+	cmd.Flags().StringVarP(&opts.format, "format", "f", "", "Format the output using the given go template")

+

+	return cmd

+}