new file mode 100644

@@ -0,0 +1,15 @@

+// +build experimental

+

+package client

+

+import (

+	"os"

+

+	nwclient "github.com/docker/libnetwork/client"

+)

+

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

+	nCli := nwclient.NewNetworkCli(cli.out, cli.err, nwclient.CallFunc(cli.call))

+	args = append([]string{"network"}, args...)

+	return nCli.Cmd(os.Args[0], args...)

+}

new file mode 100644

@@ -0,0 +1,12 @@

+// +build experimental

+

+package server

+

+func (s *Server) registerSubRouter() {

+	httpHandler := s.daemon.NetworkApiRouter()

+

+	subrouter := s.router.PathPrefix("/v{version:[0-9.]+}/networks").Subrouter()

+	subrouter.Methods("GET", "POST", "PUT", "DELETE").HandlerFunc(httpHandler)

+	subrouter = s.router.PathPrefix("/networks").Subrouter()

+	subrouter.Methods("GET", "POST", "PUT", "DELETE").HandlerFunc(httpHandler)

+}

@@ -70,6 +70,7 @@ func (s *Server) newServer(proto, addr string) ([]serverCloser, error) {

 func (s *Server) AcceptConnections(d *daemon.Daemon) {

 	// Tell the init daemon we are accepting requests

 	s.daemon = d

+	s.registerSubRouter()

 	go systemd.SdNotify("READY=1")

 	// close the lock so the listeners start accepting connections

 	select {

new file mode 100644

@@ -0,0 +1,6 @@

+// +build !experimental

+

+package server

+

+func (s *Server) registerSubRouter() {

+}

@@ -45,6 +45,7 @@ func (s *Server) newServer(proto, addr string) ([]serverCloser, error) {

 func (s *Server) AcceptConnections(d *daemon.Daemon) {

 	s.daemon = d

+	s.registerSubRouter()

 	// close the lock so the listeners start accepting connections

 	select {

 	case <-s.start:

@@ -32,6 +32,7 @@ type CommonConfig struct {

 	Pidfile        string

 	Root           string

 	TrustKeyPath   string

+	DefaultNetwork string

 }

 // InstallCommonFlags adds command-line options to the top-level flag parser for

@@ -50,6 +51,7 @@ func (config *Config) InstallCommonFlags() {

 	flag.IntVar(&config.Mtu, []string{"#mtu", "-mtu"}, 0, "Set the containers network MTU")

 	flag.BoolVar(&config.EnableCors, []string{"#api-enable-cors", "#-api-enable-cors"}, false, "Enable CORS headers in the remote API, this is deprecated by --api-cors-header")

 	flag.StringVar(&config.CorsHeaders, []string{"-api-cors-header"}, "", "Set CORS headers in the remote API")

+	flag.StringVar(&config.DefaultNetwork, []string{"-default-network"}, "", "Set default network")

 	// FIXME: why the inconsistency between "hosts" and "sockets"?

 	opts.IPListVar(&config.Dns, []string{"#dns", "-dns"}, "DNS server to use")

 	opts.DnsSearchListVar(&config.DnsSearch, []string{"-dns-search"}, "DNS search domains to use")

@@ -737,17 +737,47 @@ func (container *Container) buildCreateEndpointOptions() ([]libnetwork.EndpointO

 	return createOptions, nil

 }

+func createDefaultNetwork(controller libnetwork.NetworkController) (libnetwork.Network, error) {

+	createOptions := []libnetwork.NetworkOption{}

+	genericOption := options.Generic{}

+	dnet := controller.Config().Daemon.DefaultNetwork

+	driver := controller.Config().Daemon.DefaultDriver

+

+	// Bridge driver is special due to legacy reasons

+	if runconfig.NetworkMode(driver).IsBridge() {

+		genericOption[netlabel.GenericData] = map[string]interface{}{

+			"BridgeName":            dnet,

+			"AllowNonDefaultBridge": "true",

+		}

+		networkOption := libnetwork.NetworkOptionGeneric(genericOption)

+		createOptions = append(createOptions, networkOption)

+	}

+

+	return controller.NewNetwork(driver, dnet, createOptions...)

+}

+

 func (container *Container) AllocateNetwork() error {

 	mode := container.hostConfig.NetworkMode

+	controller := container.daemon.netController

 	if container.Config.NetworkDisabled || mode.IsContainer() {

 		return nil

 	}

+	networkName := mode.NetworkName()

+	if mode.IsDefault() {

+		networkName = controller.Config().Daemon.DefaultNetwork

+	}

+

 	var err error

-	n, err := container.daemon.netController.NetworkByName(string(mode))

+	n, err := controller.NetworkByName(networkName)

 	if err != nil {

-		return fmt.Errorf("error locating network with name %s: %v", string(mode), err)

+		if !mode.IsDefault() {

+			return fmt.Errorf("error locating network with name %s: %v", networkName, err)

+		}

+		if n, err = createDefaultNetwork(controller); err != nil {

+			return err

+		}

 	}

 	createOptions, err := container.buildCreateEndpointOptions()

@@ -790,9 +820,8 @@ func (container *Container) initializeNetworking() error {

 	// Make sure NetworkMode has an acceptable value before

 	// initializing networking.

 	if container.hostConfig.NetworkMode == runconfig.NetworkMode("") {

-		container.hostConfig.NetworkMode = runconfig.NetworkMode("bridge")

+		container.hostConfig.NetworkMode = runconfig.NetworkMode("default")

 	}

-

 	if container.hostConfig.NetworkMode.IsContainer() {

 		// we need to get the hosts files from the container to join

 		nc, err := container.getNetworkedContainer()

@@ -5,6 +5,7 @@ package daemon

 import (

 	"fmt"

 	"net"

+	"net/http"

 	"os"

 	"path/filepath"

 	"runtime"

@@ -24,6 +25,8 @@ import (

 	"github.com/docker/docker/volume/local"

 	"github.com/docker/libcontainer/label"

 	"github.com/docker/libnetwork"

+	nwapi "github.com/docker/libnetwork/api"

+	nwconfig "github.com/docker/libnetwork/config"

 	"github.com/docker/libnetwork/netlabel"

 	"github.com/docker/libnetwork/options"

 )

@@ -264,8 +267,35 @@ func isNetworkDisabled(config *Config) bool {

 	return config.Bridge.Iface == disableNetworkBridge

 }

+func networkOptions(dconfig *Config) ([]nwconfig.Option, error) {

+	options := []nwconfig.Option{}

+	if dconfig == nil {

+		return options, nil

+	}

+	if strings.TrimSpace(dconfig.DefaultNetwork) != "" {

+		dn := strings.Split(dconfig.DefaultNetwork, ":")

+		if len(dn) < 2 {

+			return nil, fmt.Errorf("default network daemon config must be of the form NETWORKDRIVER:NETWORKNAME")

+		}

+		options = append(options, nwconfig.OptionDefaultDriver(dn[0]))

+		options = append(options, nwconfig.OptionDefaultNetwork(strings.Join(dn[1:], ":")))

+	} else {

+		dd := runconfig.DefaultDaemonNetworkMode()

+		dn := runconfig.DefaultDaemonNetworkMode().NetworkName()

+		options = append(options, nwconfig.OptionDefaultDriver(string(dd)))

+		options = append(options, nwconfig.OptionDefaultNetwork(dn))

+	}

+	options = append(options, nwconfig.OptionLabels(dconfig.Labels))

+	return options, nil

+}

+

 func initNetworkController(config *Config) (libnetwork.NetworkController, error) {

-	controller, err := libnetwork.New()

+	netOptions, err := networkOptions(config)

+	if err != nil {

+		return nil, err

+	}

+

+	controller, err := libnetwork.New(netOptions...)

 	if err != nil {

 		return nil, fmt.Errorf("error obtaining controller instance: %v", err)

 	}

@@ -419,3 +449,7 @@ func setupInitLayer(initLayer string) error {

 	// Layer is ready to use, if it wasn't before.

 	return nil

 }

+

+func (daemon *Daemon) NetworkApiRouter() func(w http.ResponseWriter, req *http.Request) {

+	return nwapi.NewHTTPHandler(daemon.netController)

+}

@@ -18,7 +18,7 @@ clone git golang.org/x/net 3cffabab72adf04f8e3b01c5baf775361837b5fe https://gith

 clone hg code.google.com/p/gosqlite 74691fb6f837

 #get libnetwork packages

-clone git github.com/docker/libnetwork 3be488927db8d719568917203deddd630a194564

+clone git github.com/docker/libnetwork fc7abaa93fd33a77cc37845adbbc4adf03676dd5

 clone git github.com/docker/libkv e8cde779d58273d240c1eff065352a6cd67027dd

 clone git github.com/vishvananda/netns 5478c060110032f972e86a1f844fdb9a2f008f2c

 clone git github.com/vishvananda/netlink 8eb64238879fed52fd51c5b30ad20b928fb4c36c

@@ -869,7 +869,7 @@ func (s *DockerSuite) TestContainerApiCreate(c *check.C) {

 	out, err := exec.Command(dockerBinary, "start", "-a", container.Id).CombinedOutput()

 	if err != nil {

-		c.Fatal(out, err)

+		c.Fatal(string(out), err)

 	}

 	if strings.TrimSpace(string(out)) != "/test" {

 		c.Fatalf("expected output `/test`, got %q", out)

new file mode 100644

@@ -0,0 +1,72 @@

+// +build experimental

+

+package main

+

+import (

+	"encoding/json"

+	"fmt"

+	"net/http"

+

+	"github.com/go-check/check"

+)

+

+func isNetworkAvailable(c *check.C, name string) bool {

+	status, body, err := sockRequest("GET", "/networks", nil)

+	c.Assert(status, check.Equals, http.StatusOK)

+	c.Assert(err, check.IsNil)

+

+	var inspectJSON []struct {

+		Name string

+		ID   string

+		Type string

+	}

+	if err = json.Unmarshal(body, &inspectJSON); err != nil {

+		c.Fatalf("unable to unmarshal response body: %v", err)

+	}

+	for _, n := range inspectJSON {

+		if n.Name == name {

+			return true

+		}

+	}

+	return false

+

+}

+

+func (s *DockerSuite) TestNetworkApiGetAll(c *check.C) {

+	defaults := []string{"bridge", "host", "none"}

+	for _, nn := range defaults {

+		if !isNetworkAvailable(c, nn) {

+			c.Fatalf("Missing Default network : %s", nn)

+		}

+	}

+}

+

+func (s *DockerSuite) TestNetworkApiCreateDelete(c *check.C) {

+	name := "testnetwork"

+	config := map[string]interface{}{

+		"name":         name,

+		"network_type": "bridge",

+	}

+

+	status, resp, err := sockRequest("POST", "/networks", config)

+	c.Assert(status, check.Equals, http.StatusCreated)

+	c.Assert(err, check.IsNil)

+

+	if !isNetworkAvailable(c, name) {

+		c.Fatalf("Network %s not found", name)

+	}

+

+	var id string

+	err = json.Unmarshal(resp, &id)

+	if err != nil {

+		c.Fatal(err)

+	}

+

+	status, _, err = sockRequest("DELETE", fmt.Sprintf("/networks/%s", id), nil)

+	c.Assert(status, check.Equals, http.StatusOK)

+	c.Assert(err, check.IsNil)

+

+	if isNetworkAvailable(c, name) {

+		c.Fatalf("Network %s not deleted", name)

+	}

+}

new file mode 100644

@@ -0,0 +1,54 @@

+// +build experimental

+

+package main

+

+import (

+	"os/exec"

+	"strings"

+

+	"github.com/go-check/check"

+)

+

+func isNetworkPresent(c *check.C, name string) bool {

+	runCmd := exec.Command(dockerBinary, "network", "ls")

+	out, _, _, err := runCommandWithStdoutStderr(runCmd)

+	if err != nil {

+		c.Fatal(out, err)

+	}

+	lines := strings.Split(out, "\n")

+	for i := 1; i < len(lines)-1; i++ {

+		if strings.Contains(lines[i], name) {

+			return true

+		}

+	}

+	return false

+}

+

+func (s *DockerSuite) TestDockerNetworkLsDefault(c *check.C) {

+	defaults := []string{"bridge", "host", "none"}

+	for _, nn := range defaults {

+		if !isNetworkPresent(c, nn) {

+			c.Fatalf("Missing Default network : %s", nn)

+		}

+	}

+}

+

+func (s *DockerSuite) TestDockerNetworkCreateDelete(c *check.C) {

+	runCmd := exec.Command(dockerBinary, "network", "create", "test")

+	out, _, _, err := runCommandWithStdoutStderr(runCmd)

+	if err != nil {

+		c.Fatal(out, err)

+	}

+	if !isNetworkPresent(c, "test") {

+		c.Fatalf("Network test not found")

+	}

+

+	runCmd = exec.Command(dockerBinary, "network", "rm", "test")

+	out, _, _, err = runCommandWithStdoutStderr(runCmd)

+	if err != nil {

+		c.Fatal(out, err)

+	}

+	if isNetworkPresent(c, "test") {

+		c.Fatalf("Network test is not removed")

+	}

+}

@@ -21,6 +21,29 @@ func (n NetworkMode) IsPrivate() bool {

 	return !(n.IsHost() || n.IsContainer())

 }

+func (n NetworkMode) IsDefault() bool {

+	return n == "default"

+}

+

+func DefaultDaemonNetworkMode() NetworkMode {

+	return NetworkMode("bridge")

+}

+

+func (n NetworkMode) NetworkName() string {

+	if n.IsBridge() {

+		return "bridge"

+	} else if n.IsHost() {

+		return "host"

+	} else if n.IsContainer() {

+		return "container"

+	} else if n.IsNone() {

+		return "none"

+	} else if n.IsDefault() {

+		return "default"

+	}

+	return ""

+}

+

 func (n NetworkMode) IsBridge() bool {

 	return n == "bridge"

 }

@@ -72,7 +72,7 @@ func Parse(cmd *flag.FlagSet, args []string) (*Config, *HostConfig, *flag.FlagSe

 		flCpusetMems      = cmd.String([]string{"-cpuset-mems"}, "", "MEMs in which to allow execution (0-3, 0,1)")

 		flCpuQuota        = cmd.Int64([]string{"-cpu-quota"}, 0, "Limit the CPU CFS quota")

 		flBlkioWeight     = cmd.Int64([]string{"-blkio-weight"}, 0, "Block IO (relative weight), between 10 and 1000")

-		flNetMode         = cmd.String([]string{"-net"}, "bridge", "Set the Network mode for the container")

+		flNetMode         = cmd.String([]string{"-net"}, "default", "Set the Network mode for the container")

 		flMacAddress      = cmd.String([]string{"-mac-address"}, "", "Container MAC address (e.g. 92:d0:c6:0a:29:33)")

 		flIpcMode         = cmd.String([]string{"-ipc"}, "", "IPC namespace to use")

 		flRestartPolicy   = cmd.String([]string{"-restart"}, "no", "Restart policy to apply when a container exits")

@@ -485,7 +485,7 @@ func parseKeyValueOpts(opts opts.ListOpts) ([]KeyValuePair, error) {

 func parseNetMode(netMode string) (NetworkMode, error) {

 	parts := strings.Split(netMode, ":")

 	switch mode := parts[0]; mode {

-	case "bridge", "none", "host":

+	case "default", "bridge", "none", "host":

 	case "container":

 		if len(parts) < 2 || parts[1] == "" {

 			return "", fmt.Errorf("invalid container format container:<name|id>")

new file mode 100644

@@ -0,0 +1,807 @@

+package api

+

+import (

+	"encoding/json"

+	"fmt"

+	"io/ioutil"

+	"net/http"

+	"strings"

+

+	"github.com/docker/libnetwork"

+	"github.com/docker/libnetwork/netlabel"

+	"github.com/docker/libnetwork/types"

+	"github.com/gorilla/mux"

+)

+

+var (

+	successResponse  = responseStatus{Status: "Success", StatusCode: http.StatusOK}

+	createdResponse  = responseStatus{Status: "Created", StatusCode: http.StatusCreated}

+	mismatchResponse = responseStatus{Status: "Body/URI parameter mismatch", StatusCode: http.StatusBadRequest}

+	badQueryResponse = responseStatus{Status: "Unsupported query", StatusCode: http.StatusBadRequest}

+)

+

+const (

+	// Resource name regex

+	regex = "[a-zA-Z_0-9-]+"

+	// Router URL variable definition

+	nwName = "{" + urlNwName + ":" + regex + "}"

+	nwID   = "{" + urlNwID + ":" + regex + "}"

+	nwPID  = "{" + urlNwPID + ":" + regex + "}"

+	epName = "{" + urlEpName + ":" + regex + "}"

+	epID   = "{" + urlEpID + ":" + regex + "}"

+	epPID  = "{" + urlEpPID + ":" + regex + "}"

+	cnID   = "{" + urlCnID + ":" + regex + "}"

+

+	// Though this name can be anything, in order to support default network,

+	// we will keep it as name

+	urlNwName = "name"

+	// Internal URL variable name, they can be anything

+	urlNwID   = "network-id"

+	urlNwPID  = "network-partial-id"

+	urlEpName = "endpoint-name"

+	urlEpID   = "endpoint-id"

+	urlEpPID  = "endpoint-partial-id"

+	urlCnID   = "container-id"

+

+	// BridgeNetworkDriver is the built-in default for Network Driver

+	BridgeNetworkDriver = "bridge"

+)

+

+// NewHTTPHandler creates and initialize the HTTP handler to serve the requests for libnetwork

+func NewHTTPHandler(c libnetwork.NetworkController) func(w http.ResponseWriter, req *http.Request) {

+	h := &httpHandler{c: c}

+	h.initRouter()

+	return h.handleRequest

+}

+

+type responseStatus struct {

+	Status     string

+	StatusCode int

+}

+

+func (r *responseStatus) isOK() bool {

+	return r.StatusCode == http.StatusOK || r.StatusCode == http.StatusCreated

+}

+

+type processor func(c libnetwork.NetworkController, vars map[string]string, body []byte) (interface{}, *responseStatus)

+

+type httpHandler struct {

+	c libnetwork.NetworkController

+	r *mux.Router

+}

+

+func (h *httpHandler) handleRequest(w http.ResponseWriter, req *http.Request) {

+	// Make sure the service is there

+	if h.c == nil {

+		http.Error(w, "NetworkController is not available", http.StatusServiceUnavailable)

+		return

+	}

+

+	// Get handler from router and execute it

+	h.r.ServeHTTP(w, req)

+}

+

+func (h *httpHandler) initRouter() {

+	m := map[string][]struct {

+		url string

+		qrs []string

+		fct processor

+	}{

+		"GET": {

+			// Order matters

+			{"/networks", []string{"name", nwName}, procGetNetworks},

+			{"/networks", []string{"partial-id", nwPID}, procGetNetworks},

+			{"/networks", nil, procGetNetworks},

+			{"/networks/" + nwID, nil, procGetNetwork},

+			{"/networks/" + nwID + "/endpoints", []string{"name", epName}, procGetEndpoints},

+			{"/networks/" + nwID + "/endpoints", []string{"partial-id", epPID}, procGetEndpoints},

+			{"/networks/" + nwID + "/endpoints", nil, procGetEndpoints},

+			{"/networks/" + nwID + "/endpoints/" + epID, nil, procGetEndpoint},

+			{"/services", []string{"network", nwName}, procGetServices},

+			{"/services", []string{"name", epName}, procGetServices},

+			{"/services", []string{"partial-id", epPID}, procGetServices},

+			{"/services", nil, procGetServices},

+			{"/services/" + epID, nil, procGetService},

+			{"/services/" + epID + "/backend", nil, procGetContainers},

+		},

+		"POST": {

+			{"/networks", nil, procCreateNetwork},

+			{"/networks/" + nwID + "/endpoints", nil, procCreateEndpoint},

+			{"/networks/" + nwID + "/endpoints/" + epID + "/containers", nil, procJoinEndpoint},

+			{"/services", nil, procPublishService},

+			{"/services/" + epID + "/backend", nil, procAttachBackend},

+		},

+		"DELETE": {

+			{"/networks/" + nwID, nil, procDeleteNetwork},

+			{"/networks/" + nwID + "/endpoints/" + epID, nil, procDeleteEndpoint},

+			{"/networks/" + nwID + "/endpoints/" + epID + "/containers/" + cnID, nil, procLeaveEndpoint},

+			{"/services/" + epID, nil, procUnpublishService},

+			{"/services/" + epID + "/backend/" + cnID, nil, procDetachBackend},

+		},

+	}

+

+	h.r = mux.NewRouter()

+	for method, routes := range m {

+		for _, route := range routes {

+			r := h.r.Path("/{.*}" + route.url).Methods(method).HandlerFunc(makeHandler(h.c, route.fct))

+			if route.qrs != nil {

+				r.Queries(route.qrs...)

+			}

+

+			r = h.r.Path(route.url).Methods(method).HandlerFunc(makeHandler(h.c, route.fct))

+			if route.qrs != nil {

+				r.Queries(route.qrs...)

+			}

+		}

+	}

+}

+

+func makeHandler(ctrl libnetwork.NetworkController, fct processor) http.HandlerFunc {

+	return func(w http.ResponseWriter, req *http.Request) {

+		var (

+			body []byte

+			err  error

+		)

+		if req.Body != nil {

+			body, err = ioutil.ReadAll(req.Body)

+			if err != nil {

+				http.Error(w, "Invalid body: "+err.Error(), http.StatusBadRequest)

+				return

+			}

+		}

+

+		mvars := mux.Vars(req)

+		rvars := req.URL.Query()

+		// workaround a mux issue which filters out valid queries with empty value

+		for k := range rvars {

+			if _, ok := mvars[k]; !ok {

+				if rvars.Get(k) == "" {

+					mvars[k] = ""

+				}

+			}

+		}

+

+		res, rsp := fct(ctrl, mvars, body)

+		if !rsp.isOK() {

+			http.Error(w, rsp.Status, rsp.StatusCode)

+			return

+		}

+		if res != nil {

+			writeJSON(w, rsp.StatusCode, res)

+		}

+	}

+}

+

+/*****************

+ Resource Builders

+******************/

+

+func buildNetworkResource(nw libnetwork.Network) *networkResource {

+	r := &networkResource{}

+	if nw != nil {

+		r.Name = nw.Name()

+		r.ID = nw.ID()

+		r.Type = nw.Type()

+		epl := nw.Endpoints()

+		r.Endpoints = make([]*endpointResource, 0, len(epl))

+		for _, e := range epl {

+			epr := buildEndpointResource(e)

+			r.Endpoints = append(r.Endpoints, epr)

+		}

+	}

+	return r

+}

+

+func buildEndpointResource(ep libnetwork.Endpoint) *endpointResource {

+	r := &endpointResource{}

+	if ep != nil {

+		r.Name = ep.Name()

+		r.ID = ep.ID()

+		r.Network = ep.Network()

+	}

+	return r

+}

+

+func buildContainerResource(ci libnetwork.ContainerInfo) *containerResource {

+	r := &containerResource{}

+	if ci != nil {

+		r.ID = ci.ID()

+	}

+	return r

+}

+

+/****************

+ Options Parsers

+*****************/

+

+func (nc *networkCreate) parseOptions() []libnetwork.NetworkOption {

+	var setFctList []libnetwork.NetworkOption

+

+	if nc.Options != nil {

+		setFctList = append(setFctList, libnetwork.NetworkOptionGeneric(nc.Options))

+	}

+

+	return setFctList

+}

+

+func (ej *endpointJoin) parseOptions() []libnetwork.EndpointOption {

+	var setFctList []libnetwork.EndpointOption

+	if ej.HostName != "" {

+		setFctList = append(setFctList, libnetwork.JoinOptionHostname(ej.HostName))

+	}

+	if ej.DomainName != "" {

+		setFctList = append(setFctList, libnetwork.JoinOptionDomainname(ej.DomainName))

+	}

+	if ej.HostsPath != "" {

+		setFctList = append(setFctList, libnetwork.JoinOptionHostsPath(ej.HostsPath))

+	}

+	if ej.ResolvConfPath != "" {

+		setFctList = append(setFctList, libnetwork.JoinOptionResolvConfPath(ej.ResolvConfPath))

+	}

+	if ej.UseDefaultSandbox {

+		setFctList = append(setFctList, libnetwork.JoinOptionUseDefaultSandbox())

+	}

+	if ej.DNS != nil {

+		for _, d := range ej.DNS {

+			setFctList = append(setFctList, libnetwork.JoinOptionDNS(d))

+		}

+	}

+	if ej.ExtraHosts != nil {

+		for _, e := range ej.ExtraHosts {

+			setFctList = append(setFctList, libnetwork.JoinOptionExtraHost(e.Name, e.Address))

+		}

+	}

+	if ej.ParentUpdates != nil {

+		for _, p := range ej.ParentUpdates {

+			setFctList = append(setFctList, libnetwork.JoinOptionParentUpdate(p.EndpointID, p.Name, p.Address))

+		}

+	}

+	return setFctList

+}

+

+/******************

+ Process functions

+*******************/

+

+func processCreateDefaults(c libnetwork.NetworkController, nc *networkCreate) {

+	if nc.NetworkType == "" {

+		nc.NetworkType = c.Config().Daemon.DefaultDriver

+	}

+	if nc.NetworkType == BridgeNetworkDriver {

+		if nc.Options == nil {

+			nc.Options = make(map[string]interface{})

+		}

+		genericData, ok := nc.Options[netlabel.GenericData]

+		if !ok {

+			genericData = make(map[string]interface{})

+		}

+		gData := genericData.(map[string]interface{})

+

+		if _, ok := gData["BridgeName"]; !ok {

+			gData["BridgeName"] = nc.Name

+		}

+		if _, ok := gData["AllowNonDefaultBridge"]; !ok {

+			gData["AllowNonDefaultBridge"] = "true"

+		}

+		nc.Options[netlabel.GenericData] = genericData

+	}

+}

+

+/***************************

+ NetworkController interface

+****************************/

+func procCreateNetwork(c libnetwork.NetworkController, vars map[string]string, body []byte) (interface{}, *responseStatus) {

+	var create networkCreate

+

+	err := json.Unmarshal(body, &create)

+	if err != nil {

+		return "", &responseStatus{Status: "Invalid body: " + err.Error(), StatusCode: http.StatusBadRequest}

+	}

+	processCreateDefaults(c, &create)

+

+	nw, err := c.NewNetwork(create.NetworkType, create.Name, create.parseOptions()...)

+	if err != nil {

+		return "", convertNetworkError(err)

+	}

+

+	return nw.ID(), &createdResponse

+}

+

+func procGetNetwork(c libnetwork.NetworkController, vars map[string]string, body []byte) (interface{}, *responseStatus) {

+	t, by := detectNetworkTarget(vars)

+	nw, errRsp := findNetwork(c, t, by)

+	if !errRsp.isOK() {

+		return nil, errRsp

+	}

+	return buildNetworkResource(nw), &successResponse

+}

+

+func procGetNetworks(c libnetwork.NetworkController, vars map[string]string, body []byte) (interface{}, *responseStatus) {

+	var list []*networkResource

+

+	// Look for query filters and validate

+	name, queryByName := vars[urlNwName]

+	shortID, queryByPid := vars[urlNwPID]

+	if queryByName && queryByPid {

+		return nil, &badQueryResponse

+	}

+

+	if queryByName {

+		if nw, errRsp := findNetwork(c, name, byName); errRsp.isOK() {

+			list = append(list, buildNetworkResource(nw))

+		}

+	} else if queryByPid {

+		// Return all the prefix-matching networks

+		l := func(nw libnetwork.Network) bool {

+			if strings.HasPrefix(nw.ID(), shortID) {

+				list = append(list, buildNetworkResource(nw))

+			}

+			return false

+		}

+		c.WalkNetworks(l)

+	} else {

+		for _, nw := range c.Networks() {

+			list = append(list, buildNetworkResource(nw))

+		}

+	}

+

+	return list, &successResponse

+}

+

+/******************

+ Network interface

+*******************/

+func procCreateEndpoint(c libnetwork.NetworkController, vars map[string]string, body []byte) (interface{}, *responseStatus) {

+	var ec endpointCreate

+

+	err := json.Unmarshal(body, &ec)

+	if err != nil {

+		return "", &responseStatus{Status: "Invalid body: " + err.Error(), StatusCode: http.StatusBadRequest}

+	}

+

+	nwT, nwBy := detectNetworkTarget(vars)

+	n, errRsp := findNetwork(c, nwT, nwBy)

+	if !errRsp.isOK() {

+		return "", errRsp

+	}

+

+	var setFctList []libnetwork.EndpointOption

+	if ec.ExposedPorts != nil {

+		setFctList = append(setFctList, libnetwork.CreateOptionExposedPorts(ec.ExposedPorts))

+	}

+	if ec.PortMapping != nil {

+		setFctList = append(setFctList, libnetwork.CreateOptionPortMapping(ec.PortMapping))

+	}

+

+	ep, err := n.CreateEndpoint(ec.Name, setFctList...)

+	if err != nil {

+		return "", convertNetworkError(err)

+	}

+

+	return ep.ID(), &createdResponse

+}

+

+func procGetEndpoint(c libnetwork.NetworkController, vars map[string]string, body []byte) (interface{}, *responseStatus) {

+	nwT, nwBy := detectNetworkTarget(vars)

+	epT, epBy := detectEndpointTarget(vars)

+

+	ep, errRsp := findEndpoint(c, nwT, epT, nwBy, epBy)

+	if !errRsp.isOK() {

+		return nil, errRsp

+	}

+

+	return buildEndpointResource(ep), &successResponse

+}

+

+func procGetEndpoints(c libnetwork.NetworkController, vars map[string]string, body []byte) (interface{}, *responseStatus) {

+	// Look for query filters and validate

+	name, queryByName := vars[urlEpName]

+	shortID, queryByPid := vars[urlEpPID]

+	if queryByName && queryByPid {

+		return nil, &badQueryResponse

+	}

+

+	nwT, nwBy := detectNetworkTarget(vars)

+	nw, errRsp := findNetwork(c, nwT, nwBy)

+	if !errRsp.isOK() {

+		return nil, errRsp

+	}

+

+	var list []*endpointResource

+

+	// If query parameter is specified, return a filtered collection

+	if queryByName {

+		if ep, errRsp := findEndpoint(c, nwT, name, nwBy, byName); errRsp.isOK() {

+			list = append(list, buildEndpointResource(ep))

+		}

+	} else if queryByPid {

+		// Return all the prefix-matching endpoints

+		l := func(ep libnetwork.Endpoint) bool {

+			if strings.HasPrefix(ep.ID(), shortID) {

+				list = append(list, buildEndpointResource(ep))

+			}

+			return false

+		}

+		nw.WalkEndpoints(l)

+	} else {

+		for _, ep := range nw.Endpoints() {

+			epr := buildEndpointResource(ep)

+			list = append(list, epr)

+		}

+	}

+

+	return list, &successResponse

+}

+

+func procDeleteNetwork(c libnetwork.NetworkController, vars map[string]string, body []byte) (interface{}, *responseStatus) {

+	target, by := detectNetworkTarget(vars)

+

+	nw, errRsp := findNetwork(c, target, by)

+	if !errRsp.isOK() {

+		return nil, errRsp

+	}

+

+	err := nw.Delete()

+	if err != nil {

+		return nil, convertNetworkError(err)

+	}

+

+	return nil, &successResponse

+}

+

+/******************

+ Endpoint interface

+*******************/

+func procJoinEndpoint(c libnetwork.NetworkController, vars map[string]string, body []byte) (interface{}, *responseStatus) {

+	var ej endpointJoin

+	err := json.Unmarshal(body, &ej)

+	if err != nil {

+		return nil, &responseStatus{Status: "Invalid body: " + err.Error(), StatusCode: http.StatusBadRequest}

+	}

+

+	nwT, nwBy := detectNetworkTarget(vars)

+	epT, epBy := detectEndpointTarget(vars)

+

+	ep, errRsp := findEndpoint(c, nwT, epT, nwBy, epBy)

+	if !errRsp.isOK() {

+		return nil, errRsp

+	}