@@ -30,8 +30,8 @@ import (

 	"github.com/docker/libcontainer/devices"

 	"github.com/docker/libnetwork"

 	"github.com/docker/libnetwork/netlabel"

-	"github.com/docker/libnetwork/netutils"

 	"github.com/docker/libnetwork/options"

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

 )

 const DefaultPathEnv = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

@@ -502,7 +502,7 @@ func (container *Container) buildPortMapInfo(n libnetwork.Network, ep libnetwork

 		return networkSettings, nil

 	}

-	if portMapping, ok := mapData.([]netutils.PortBinding); ok {

+	if portMapping, ok := mapData.([]types.PortBinding); ok {

 		networkSettings.Ports = nat.PortMap{}

 		for _, pp := range portMapping {

 			natPort := nat.NewPort(pp.Proto.String(), strconv.Itoa(int(pp.Port)))

@@ -641,8 +641,8 @@ func (container *Container) buildCreateEndpointOptions() ([]libnetwork.EndpointO

 	var (

 		portSpecs     = make(nat.PortSet)

 		bindings      = make(nat.PortMap)

-		pbList        []netutils.PortBinding

-		exposeList    []netutils.TransportPort

+		pbList        []types.PortBinding

+		exposeList    []types.TransportPort

 		createOptions []libnetwork.EndpointOption

 	)

@@ -682,12 +682,12 @@ func (container *Container) buildCreateEndpointOptions() ([]libnetwork.EndpointO

 	}

 	nat.SortPortMap(ports, bindings)

 	for _, port := range ports {

-		expose := netutils.TransportPort{}

-		expose.Proto = netutils.ParseProtocol(port.Proto())

+		expose := types.TransportPort{}

+		expose.Proto = types.ParseProtocol(port.Proto())

 		expose.Port = uint16(port.Int())

 		exposeList = append(exposeList, expose)

-		pb := netutils.PortBinding{Port: expose.Port, Proto: expose.Proto}

+		pb := types.PortBinding{Port: expose.Port, Proto: expose.Proto}

 		binding := bindings[port]

 		for i := 0; i < len(binding); i++ {

 			pbCopy := pb.GetCopy()

@@ -55,7 +55,7 @@ clone hg code.google.com/p/go.net 84a4013f96e0

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

 #get libnetwork packages

-clone git github.com/docker/libnetwork b39597744b0978fe4aeb9f3a099ba42f7b6c4a1f

+clone git github.com/docker/libnetwork 67438080724b17b641b411322822c00d0d3c3201

 clone git github.com/vishvananda/netns 008d17ae001344769b031375bdb38a86219154c6

 clone git github.com/vishvananda/netlink 8eb64238879fed52fd51c5b30ad20b928fb4c36c

@@ -22,7 +22,7 @@ build: ${build_image}.created

 	${docker} make build-local

 build-local:

-	$(shell which godep) go build ./...

+	$(shell which godep) go build -tags experimental ./...

 check: ${build_image}.created

 	${docker} make check-local

@@ -5,8 +5,10 @@ import (

 	"fmt"

 	"io/ioutil"

 	"net/http"

+	"strings"

 	"github.com/docker/libnetwork"

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

 	"github.com/gorilla/mux"

 )

@@ -14,13 +16,28 @@ 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 (

-	urlNwName = "name"

-	urlNwID   = "id"

+	// 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 + "}"

+

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

+	urlNwName = "network-name"

+	urlNwID   = "network-id"

+	urlNwPID  = "network-partial-id"

 	urlEpName = "endpoint-name"

 	urlEpID   = "endpoint-id"

+	urlEpPID  = "endpoint-partial-id"

 	urlCnID   = "container-id"

 )

@@ -59,42 +76,41 @@ func (h *httpHandler) handleRequest(w http.ResponseWriter, req *http.Request) {

 }

 func (h *httpHandler) initRouter() {

-	m := map[string]map[string]processor{

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

+		url string

+		qrs []string

+		fct processor

+	}{

 		"GET": {

-			"/networks":                                                                   procGetNetworks,

-			"/networks/name/{" + urlNwName + ":.*}":                                       procGetNetwork,

-			"/networks/id/{" + urlNwID + ":.*}":                                           procGetNetwork,

-			"/networks/name/{" + urlNwName + ":.*}/endpoints/":                            procGetEndpoints,

-			"/networks/id/{" + urlNwID + ":.*}/endpoints/":                                procGetEndpoints,

-			"/networks/name/{" + urlNwName + ":.*}/endpoints/name/{" + urlEpName + ":.*}": procGetEndpoint,

-			"/networks/id/{" + urlNwID + ":.*}/endpoints/name/{" + urlEpName + ":.*}":     procGetEndpoint,

-			"/networks/name/{" + urlNwName + ":.*}/endpoints/id/{" + urlEpID + ":.*}":     procGetEndpoint,

-			"/networks/id/{" + urlNwID + ":.*}/endpoints/id/{" + urlEpID + ":.*}":         procGetEndpoint,

+			// 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},

 		},

 		"POST": {

-			"/networks/name/{" + urlNwName + ":.*}":                                                                     procCreateNetwork,

-			"/networks/name/{" + urlNwName + ":.*}/endpoint/name/{" + urlEpName + ":.*}":                                procCreateEndpoint,

-			"/networks/name/{" + urlNwName + ":.*}/endpoint/name/{" + urlEpName + ":.*}/container/{" + urlCnID + ":.*}": procJoinEndpoint,

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

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

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

 		},

 		"DELETE": {

-			"/networks/name/{" + urlNwName + ":.*}":                                                                     procDeleteNetwork,

-			"/networks/id/{" + urlNwID + ":.*}":                                                                         procDeleteNetwork,

-			"/networks/name/{" + urlNwName + ":.*}/endpoints/name/{" + urlEpName + ":.*}":                               procDeleteEndpoint,

-			"/networks/name/{" + urlNwName + ":.*}/endpoints/id/{" + urlEpID + ":.*}":                                   procDeleteEndpoint,

-			"/networks/id/{" + urlNwID + ":.*}/endpoints/name/{" + urlEpName + ":.*}":                                   procDeleteEndpoint,

-			"/networks/id/{" + urlNwID + ":.*}/endpoints/id/{" + urlEpID + ":.*}":                                       procDeleteEndpoint,

-			"/networks/name/{" + urlNwName + ":.*}/endpoint/name/{" + urlEpName + ":.*}/container/{" + urlCnID + ":.*}": procLeaveEndpoint,

-			"/networks/name/{" + urlNwName + ":.*}/endpoint/id/{" + urlEpID + ":.*}/container/{" + urlCnID + ":.*}":     procLeaveEndpoint,

-			"/networks/id/{" + urlNwID + ":.*}/endpoint/name/{" + urlEpName + ":.*}/container/{" + urlCnID + ":.*}":     procLeaveEndpoint,

-			"/networks/id/{" + urlNwID + ":.*}/endpoint/id/{" + urlEpID + ":.*}/container/{" + urlCnID + ":.*}":         procLeaveEndpoint,

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

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

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

 		},

 	}

 	h.r = mux.NewRouter()

 	for method, routes := range m {

-		for route, fct := range routes {

-			f := makeHandler(h.c, fct)

-			h.r.Path(route).Methods(method).HandlerFunc(f)

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

+			}

 		}

 	}

 }

@@ -208,12 +224,7 @@ func procCreateNetwork(c libnetwork.NetworkController, vars map[string]string, b

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

 	}

-	name := vars[urlNwName]

-	if name != create.Name {

-		return "", &mismatchResponse

-	}

-

-	nw, err := c.NewNetwork(create.NetworkType, name, nil)

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

 	if err != nil {

 		return "", convertNetworkError(err)

 	}

@@ -232,10 +243,33 @@ func procGetNetwork(c libnetwork.NetworkController, vars map[string]string, body

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

 	var list []*networkResource

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

-		nwr := buildNetworkResource(nw)

-		list = append(list, nwr)

+

+	// 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

 }

@@ -250,21 +284,12 @@ func procCreateEndpoint(c libnetwork.NetworkController, vars map[string]string,

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

 	}

-	epn := vars[urlEpName]

-	if ec.Name != epn {

-		return "", &mismatchResponse

-	}

-

 	nwT, nwBy := detectNetworkTarget(vars)

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

 	if !errRsp.isOK() {

 		return "", errRsp

 	}

-	if ec.NetworkID != n.ID() {

-		return "", &mismatchResponse

-	}

-

 	var setFctList []libnetwork.EndpointOption

 	if ec.ExposedPorts != nil {

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

@@ -273,7 +298,7 @@ func procCreateEndpoint(c libnetwork.NetworkController, vars map[string]string,

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

 	}

-	ep, err := n.CreateEndpoint(epn, setFctList...)

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

 	if err != nil {

 		return "", convertNetworkError(err)

 	}

@@ -294,17 +319,40 @@ func procGetEndpoint(c libnetwork.NetworkController, vars map[string]string, bod

 }

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

-	target, by := detectNetworkTarget(vars)

+	// Look for query filters and validate

+	name, queryByName := vars[urlEpName]

+	shortID, queryByPid := vars[urlEpPID]

+	if queryByName && queryByPid {

+		return nil, &badQueryresponse

+	}

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

+	nwT, nwBy := detectNetworkTarget(vars)

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

 	if !errRsp.isOK() {

 		return nil, errRsp

 	}

 	var list []*endpointResource

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

-		epr := buildEndpointResource(ep)

-		list = append(list, epr)

+

+	// 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 networks

+		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

@@ -336,11 +384,6 @@ func procJoinEndpoint(c libnetwork.NetworkController, vars map[string]string, bo

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

 	}

-	cid := vars[urlCnID]

-	if ej.ContainerID != cid {

-		return "", &mismatchResponse

-	}

-

 	nwT, nwBy := detectNetworkTarget(vars)

 	epT, epBy := detectEndpointTarget(vars)

@@ -434,7 +477,7 @@ func findNetwork(c libnetwork.NetworkController, s string, by int) (libnetwork.N

 		panic(fmt.Sprintf("unexpected selector for network search: %d", by))

 	}

 	if err != nil {

-		if err == libnetwork.ErrNoSuchNetwork {

+		if _, ok := err.(libnetwork.ErrNoSuchNetwork); ok {

 			return nil, &responseStatus{Status: "Resource not found: Network", StatusCode: http.StatusNotFound}

 		}

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

@@ -460,7 +503,7 @@ func findEndpoint(c libnetwork.NetworkController, ns, es string, nwBy, epBy int)

 		panic(fmt.Sprintf("unexpected selector for endpoint search: %d", epBy))

 	}

 	if err != nil {

-		if err == libnetwork.ErrNoSuchEndpoint {

+		if _, ok := err.(libnetwork.ErrNoSuchEndpoint); ok {

 			return nil, &responseStatus{Status: "Resource not found: Endpoint", StatusCode: http.StatusNotFound}

 		}

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

@@ -469,9 +512,26 @@ func findEndpoint(c libnetwork.NetworkController, ns, es string, nwBy, epBy int)

 }

 func convertNetworkError(err error) *responseStatus {

-	// No real libnetwork error => http error code conversion for now.

-	// Will came in later when new interface for libnetwork error is vailable

-	return &responseStatus{Status: err.Error(), StatusCode: http.StatusBadRequest}

+	var code int

+	switch err.(type) {

+	case types.BadRequestError:

+		code = http.StatusBadRequest

+	case types.ForbiddenError:

+		code = http.StatusForbidden

+	case types.NotFoundError:

+		code = http.StatusNotFound

+	case types.TimeoutError:

+		code = http.StatusRequestTimeout

+	case types.NotImplementedError:

+		code = http.StatusNotImplemented

+	case types.NoServiceError:

+		code = http.StatusServiceUnavailable

+	case types.InternalError:

+		code = http.StatusInternalServerError

+	default:

+		code = http.StatusInternalServerError

+	}

+	return &responseStatus{Status: err.Error(), StatusCode: code}

 }

 func writeJSON(w http.ResponseWriter, code int, v interface{}) error {

@@ -16,6 +16,7 @@ import (

 	"github.com/docker/libnetwork/netlabel"

 	"github.com/docker/libnetwork/netutils"

 	"github.com/docker/libnetwork/options"

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

 )

 const (

@@ -111,7 +112,7 @@ func TestJoinOptionParser(t *testing.T) {

 }

 func TestJson(t *testing.T) {

-	nc := networkCreate{Name: "mynet", NetworkType: bridgeNetType}

+	nc := networkCreate{NetworkType: bridgeNetType}

 	b, err := json.Marshal(nc)

 	if err != nil {

 		t.Fatal(err)

@@ -123,26 +124,10 @@ func TestJson(t *testing.T) {

 		t.Fatal(err)

 	}

-	if nc.Name != ncp.Name || nc.NetworkType != ncp.NetworkType {

+	if nc.NetworkType != ncp.NetworkType {

 		t.Fatalf("Incorrect networkCreate after json encoding/deconding: %v", ncp)

 	}

-	ec := endpointCreate{Name: "mioEp", NetworkID: "0xabcde"}

-	b, err = json.Marshal(ec)

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	var ecp endpointCreate

-	err = json.Unmarshal(b, &ecp)

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	if ec.Name != ecp.Name || ec.NetworkID != ecp.NetworkID {

-		t.Fatalf("Incorrect endpointCreate after json encoding/deconding: %v", ecp)

-	}

-

 	jl := endpointJoin{ContainerID: "abcdef456789"}

 	b, err = json.Marshal(jl)

 	if err != nil {

@@ -156,7 +141,7 @@ func TestJson(t *testing.T) {

 	}

 	if jl.ContainerID != jld.ContainerID {

-		t.Fatalf("Incorrect endpointJoin after json encoding/deconding: %v", ecp)

+		t.Fatalf("Incorrect endpointJoin after json encoding/deconding: %v", jld)

 	}

 }

@@ -177,68 +162,55 @@ func TestCreateDeleteNetwork(t *testing.T) {

 		t.Fatal(err)

 	}

-	goodVars := map[string]string{urlNwName: "myNet"}

-	_, errRsp := procCreateNetwork(c, goodVars, badBody)

+	vars := make(map[string]string)

+	_, errRsp := procCreateNetwork(c, nil, badBody)

 	if errRsp == &createdResponse {

 		t.Fatalf("Expected to fail but succeeded")

 	}

+	if errRsp.StatusCode != http.StatusBadRequest {

+		t.Fatalf("Expected StatusBadRequest status code, got: %v", errRsp)

+	}

-	incompleteBody, err := json.Marshal(networkCreate{Name: "myNet"})

+	incompleteBody, err := json.Marshal(networkCreate{})

 	if err != nil {

 		t.Fatal(err)

 	}

-	_, errRsp = procCreateNetwork(c, goodVars, incompleteBody)

+	_, errRsp = procCreateNetwork(c, vars, incompleteBody)

 	if errRsp == &createdResponse {

 		t.Fatalf("Expected to fail but succeeded")

 	}

 	if errRsp.StatusCode != http.StatusBadRequest {

-		t.Fatalf("Expected StatusBadRequest status code, got: %v", errRsp.StatusCode)

+		t.Fatalf("Expected StatusBadRequest status code, got: %v", errRsp)

 	}

 	ops := make(map[string]interface{})

 	ops[netlabel.GenericData] = options.Generic{}

-	nc := networkCreate{Name: "myNet", NetworkType: bridgeNetType, Options: ops}

+	nc := networkCreate{Name: "network_1", NetworkType: bridgeNetType, Options: ops}

 	goodBody, err := json.Marshal(nc)

 	if err != nil {

 		t.Fatal(err)

 	}

-	badVars := map[string]string{urlNwName: ""}

-	_, errRsp = procCreateNetwork(c, badVars, goodBody)

-	if errRsp == &createdResponse {

-		t.Fatalf("Expected to fail but succeeded")

-	}

-	if errRsp.StatusCode != http.StatusBadRequest {

-		t.Fatalf("Expected StatusBadRequest status code, got: %v", errRsp.StatusCode)

-	}

-

-	badVars[urlNwName] = "badNetworkName"

-	_, errRsp = procCreateNetwork(c, badVars, goodBody)

-	if errRsp == &createdResponse {

-		t.Fatalf("Expected to fail but succeeded")

-	}

-	if errRsp.StatusCode != http.StatusBadRequest {

-		t.Fatalf("Expected StatusBadRequest status code, got: %v", errRsp.StatusCode)

-	}

-

-	_, errRsp = procCreateNetwork(c, goodVars, goodBody)

+	_, errRsp = procCreateNetwork(c, vars, goodBody)

 	if errRsp != &createdResponse {

 		t.Fatalf("Unexepected failure: %v", errRsp)

 	}

-	_, errRsp = procDeleteNetwork(c, badVars, nil)

+	vars[urlNwName] = ""

+	_, errRsp = procDeleteNetwork(c, vars, nil)

 	if errRsp == &successResponse {

 		t.Fatalf("Expected to fail but succeeded")

 	}

-	badVars[urlNwName] = ""

-	_, errRsp = procDeleteNetwork(c, badVars, nil)

+	vars[urlNwName] = "abc"

+	_, errRsp = procDeleteNetwork(c, vars, nil)

 	if errRsp == &successResponse {

 		t.Fatalf("Expected to fail but succeeded")

 	}

-	_, errRsp = procDeleteNetwork(c, goodVars, nil)

+	vars[urlNwName] = "network_1"

+	_, errRsp = procDeleteNetwork(c, vars, nil)

 	if errRsp != &successResponse {

 		t.Fatalf("Unexepected failure: %v", errRsp)

 	}

@@ -262,7 +234,7 @@ func TestGetNetworksAndEndpoints(t *testing.T) {

 		t.Fatal(err)

 	}

-	vars := map[string]string{urlNwName: "sh"}

+	vars := make(map[string]string)

 	inid, errRsp := procCreateNetwork(c, vars, body)

 	if errRsp != &createdResponse {

 		t.Fatalf("Unexepected failure: %v", errRsp)

@@ -273,29 +245,29 @@ func TestGetNetworksAndEndpoints(t *testing.T) {

 	}

 	ec1 := endpointCreate{

-		Name:      "ep1",

-		NetworkID: string(nid),

-		ExposedPorts: []netutils.TransportPort{

-			netutils.TransportPort{Proto: netutils.TCP, Port: uint16(5000)},

-			netutils.TransportPort{Proto: netutils.UDP, Port: uint16(400)},

-			netutils.TransportPort{Proto: netutils.TCP, Port: uint16(600)},

+		Name: "ep1",

+		ExposedPorts: []types.TransportPort{

+			types.TransportPort{Proto: types.TCP, Port: uint16(5000)},

+			types.TransportPort{Proto: types.UDP, Port: uint16(400)},

+			types.TransportPort{Proto: types.TCP, Port: uint16(600)},

 		},

-		PortMapping: []netutils.PortBinding{

-			netutils.PortBinding{Proto: netutils.TCP, Port: uint16(230), HostPort: uint16(23000)},

-			netutils.PortBinding{Proto: netutils.UDP, Port: uint16(200), HostPort: uint16(22000)},

-			netutils.PortBinding{Proto: netutils.TCP, Port: uint16(120), HostPort: uint16(12000)},

+		PortMapping: []types.PortBinding{

+			types.PortBinding{Proto: types.TCP, Port: uint16(230), HostPort: uint16(23000)},

+			types.PortBinding{Proto: types.UDP, Port: uint16(200), HostPort: uint16(22000)},

+			types.PortBinding{Proto: types.TCP, Port: uint16(120), HostPort: uint16(12000)},

 		},

 	}

 	b1, err := json.Marshal(ec1)

 	if err != nil {

 		t.Fatal(err)

 	}

-	ec2 := endpointCreate{Name: "ep2", NetworkID: nid}

+	ec2 := endpointCreate{Name: "ep2"}

 	b2, err := json.Marshal(ec2)

 	if err != nil {

 		t.Fatal(err)

 	}

+	vars[urlNwName] = "sh"

 	vars[urlEpName] = "ep1"

 	ieid1, errRsp := procCreateEndpoint(c, vars, b1)

 	if errRsp != &createdResponse {

@@ -471,6 +443,7 @@ func TestGetNetworksAndEndpoints(t *testing.T) {

 	if errRsp != &successResponse {

 		t.Fatalf("Unexepected failure: %v", errRsp)

 	}

+	delete(vars, urlEpName)

 	iepList, errRsp = procGetEndpoints(c, vars, nil)

 	if errRsp != &successResponse {

 		t.Fatalf("Unexepected failure: %v", errRsp)

@@ -509,6 +482,43 @@ func TestGetNetworksAndEndpoints(t *testing.T) {

 	}

 }

+func TestDetectGetNetworksInvalidQueryComposition(t *testing.T) {

+	c, err := libnetwork.New()

+	if err != nil {

+		t.Fatal(err)

+	}

+

+	vars := map[string]string{urlNwName: "x", urlNwPID: "y"}

+	_, errRsp := procGetNetworks(c, vars, nil)

+	if errRsp.StatusCode != http.StatusBadRequest {

+		t.Fatalf("Expected %d. Got: %v", http.StatusBadRequest, errRsp)

+	}

+}

+

+func TestDetectGetEndpointsInvalidQueryComposition(t *testing.T) {

+	defer netutils.SetupTestNetNS(t)()

+

+	c, err := libnetwork.New()

+	if err != nil {

+		t.Fatal(err)

+	}

+	err = c.ConfigureNetworkDriver(bridgeNetType, nil)

+	if err != nil {

+		t.Fatal(err)

+	}

+

+	_, err = c.NewNetwork(bridgeNetType, "network", nil)

+	if err != nil {

+		t.Fatal(err)

+	}

+

+	vars := map[string]string{urlNwName: "network", urlEpName: "x", urlEpPID: "y"}

+	_, errRsp := procGetEndpoints(c, vars, nil)

+	if errRsp.StatusCode != http.StatusBadRequest {

+		t.Fatalf("Expected %d. Got: %v", http.StatusBadRequest, errRsp)

+	}

+}

+

 func TestFindNetworkUtil(t *testing.T) {

 	defer netutils.SetupTestNetNS(t)()

@@ -603,85 +613,46 @@ func TestCreateDeleteEndpoints(t *testing.T) {

 		t.Fatal(err)

 	}

-	vars := map[string]string{urlNwName: "firstNet"}

+	vars := make(map[string]string)

 	i, errRsp := procCreateNetwork(c, vars, body)

 	if errRsp != &createdResponse {

 		t.Fatalf("Unexepected failure: %v", errRsp)

 	}

 	nid := i2s(i)

-	vbad, err := json.Marshal("bad endppint create data")

+	vbad, err := json.Marshal("bad endppoint create data")

 	if err != nil {

 		t.Fatal(err)

 	}

-	vars[urlEpName] = "ep1"

+	vars[urlNwName] = "firstNet"

 	_, errRsp = procCreateEndpoint(c, vars, vbad)

 	if errRsp == &createdResponse {

 		t.Fatalf("Expected to fail but succeeded")

 	}

-	bad, err := json.Marshal(endpointCreate{Name: "ep1", NetworkID: "123456"})

-	if err != nil {

-		t.Fatal(err)

-	}

-	_, errRsp = procCreateEndpoint(c, vars, bad)

-	if errRsp == &createdResponse {

-		t.Fatalf("Expected to fail but succeeded")

-	}

-

-	soso, err := json.Marshal(endpointCreate{Name: "ep11", NetworkID: nid})

-	if err != nil {

-		t.Fatal(err)

-	}

-	_, errRsp = procCreateEndpoint(c, vars, soso)

-	if errRsp != &mismatchResponse {

-		t.Fatalf("Expected to fail with \"mismatchResponse\", but got: %v", errRsp)

-	}

-

-	bla, err := json.Marshal(endpointCreate{Name: "", NetworkID: nid})

-	if err != nil {

-		t.Fatal(err)

-	}

-	vars[urlNwName] = "firstNet"

-	vars[urlEpName] = ""

-	_, errRsp = procCreateEndpoint(c, vars, bla)

-	if errRsp == &createdResponse {

-		t.Fatalf("Expected to fail but succeeded: %v", errRsp)

-	}

-

-	b, err := json.Marshal(endpointCreate{Name: "firstEp", NetworkID: nid})

+	b, err := json.Marshal(endpointCreate{Name: ""})

 	if err != nil {

 		t.Fatal(err)

 	}

 	vars[urlNwName] = "secondNet"

-	vars[urlEpName] = "firstEp"

 	_, errRsp = procCreateEndpoint(c, vars, b)

 	if errRsp == &createdResponse {

 		t.Fatalf("Expected to fail but succeeded")

 	}

 	vars[urlNwName] = "firstNet"

-	vars[urlEpName] = "ep1"

-	_, errRsp = procCreateEndpoint(c, vars, b)

-	if errRsp != &mismatchResponse {

-		t.Fatalf("Expected to fail with \"mismatchResponse\", but got: %v", errRsp)

-	}

-

-	vars = make(map[string]string)

 	_, errRsp = procCreateEndpoint(c, vars, b)

 	if errRsp == &successResponse {

 		t.Fatalf("Expected failure but succeeded: %v", errRsp)

 	}

-	vars[urlNwName] = "firstNet"

-	_, errRsp = procCreateEndpoint(c, vars, b)

-	if errRsp == &successResponse {

-		t.Fatalf("Expected failure but succeeded: %v", errRsp)

+	b, err = json.Marshal(endpointCreate{Name: "firstEp"})

+	if err != nil {

+		t.Fatal(err)

 	}

-	vars[urlEpName] = "firstEp"

 	i, errRsp = procCreateEndpoint(c, vars, b)

 	if errRsp != &createdResponse {

 		t.Fatalf("Unexepected failure: %v", errRsp)

@@ -713,8 +684,8 @@ func TestCreateDeleteEndpoints(t *testing.T) {

 		t.Fatalf("Unexepected failure: %v", errRsp)

 	}

-	if ep0 != ep1 || ep0 != ep2 || ep0 != ep3 {

-		t.Fatalf("Diffenrent queries returned different endpoints")

+	if ep0.ID() != ep1.ID() || ep0.ID() != ep2.ID() || ep0.ID() != ep3.ID() {

+		t.Fatalf("Diffenrent queries returned different endpoints: \nep0: %v\nep1: %v\nep2: %v\nep3: %v", ep0, ep1, ep2, ep3)

 	}

 	vars = make(map[string]string)

@@ -766,18 +737,17 @@ func TestJoinLeave(t *testing.T) {

 	if err != nil {

 		t.Fatal(err)

 	}

-	vars := map[string]string{urlNwName: "network"}

-	i, errRsp := procCreateNetwork(c, vars, nb)

+	vars := make(map[string]string)

+	_, errRsp := procCreateNetwork(c, vars, nb)

 	if errRsp != &createdResponse {

 		t.Fatalf("Unexepected failure: %v", errRsp)

 	}

-	nid := i2s(i)

-	vars[urlEpName] = "epoint"

-	eb, err := json.Marshal(endpointCreate{Name: "epoint", NetworkID: nid})

+	eb, err := json.Marshal(endpointCreate{Name: "endpoint"})

 	if err != nil {

 		t.Fatal(err)

 	}

+	vars[urlNwName] = "network"

 	_, errRsp = procCreateEndpoint(c, vars, eb)

 	if errRsp != &createdResponse {

 		t.Fatalf("Unexepected failure: %v", errRsp)

@@ -792,6 +762,7 @@ func TestJoinLeave(t *testing.T) {

 		t.Fatalf("Expected failure, got: %v", errRsp)

 	}

+	vars[urlEpName] = "endpoint"

 	bad, err := json.Marshal(endpointJoin{})

 	if err != nil {

 		t.Fatal(err)

@@ -811,44 +782,30 @@ func TestJoinLeave(t *testing.T) {

 	vars = make(map[string]string)

 	vars[urlNwName] = ""

 	vars[urlEpName] = ""

-	vars[urlCnID] = cid

-	_, errRsp = procJoinEndpoint(c, vars, jlb)

-	if errRsp == &successResponse {

-		t.Fatalf("Expected failure, got: %v", errRsp)

-	}

-

-	vars[urlNwName] = "network1"

-	vars[urlEpName] = ""

 	_, errRsp = procJoinEndpoint(c, vars, jlb)

 	if errRsp == &successResponse {

 		t.Fatalf("Expected failure, got: %v", errRsp)

 	}

 	vars[urlNwName] = "network"

-	vars[urlEpName] = "endpoint"

+	vars[urlEpName] = ""

 	_, errRsp = procJoinEndpoint(c, vars, jlb)

 	if errRsp == &successResponse {

 		t.Fatalf("Expected failure, got: %v", errRsp)

 	}

 	vars[urlEpName] = "epoint"

-	delete(vars, urlCnID)

 	_, errRsp = procJoinEndpoint(c, vars, jlb)

 	if errRsp == &successResponse {

 		t.Fatalf("Expected failure, got: %v", errRsp)

 	}

-	vars[urlCnID] = "who?"

-	_, errRsp = procJoinEndpoint(c, vars, jlb)

-	if errRsp == &successResponse {

-		t.Fatalf("Expected failure, got: %v", errRsp)

-	}

-

-	vars[urlCnID] = cid

+	vars[urlEpName] = "endpoint"

 	cdi, errRsp := procJoinEndpoint(c, vars, jlb)

 	if errRsp != &successResponse {

-		t.Fatalf("Unexpected failure, got: %v", errRsp)

+		t.Fatalf("Expected failure, got: %v", errRsp)

 	}

+

 	cd := i2c(cdi)

 	if cd.SandboxKey == "" {

 		t.Fatalf("Empty sandbox key")

@@ -897,6 +854,7 @@ func TestJoinLeave(t *testing.T) {

 	}

 	delete(vars, urlCnID)

+	vars[urlEpName] = "endpoint"

 	_, errRsp = procLeaveEndpoint(c, vars, jlb)

 	if errRsp == &successResponse {

 		t.Fatalf("Expected failure, got: %v", errRsp)

@@ -1178,7 +1136,7 @@ func TestHttpHandlerUninit(t *testing.T) {

 	}

 	rsp := newWriter()

-	req, err := http.NewRequest("GET", "/networks", nil)

+	req, err := http.NewRequest("GET", "/v1.19/networks", nil)

 	if err != nil {

 		t.Fatal(err)

 	}

@@ -1193,15 +1151,24 @@ func TestHttpHandlerUninit(t *testing.T) {

 	handleRequest(rsp, req)

 	if rsp.statusCode != http.StatusOK {

-		t.Fatalf("Unexpectded failure: (%d): %s", rsp.statusCode, rsp.body)

+		t.Fatalf("Expected (%d). Got: (%d): %s", http.StatusOK, rsp.statusCode, rsp.body)

 	}

-	n, err := c.NewNetwork(bridgeNetType, "onenet", nil)

+	var list []*networkResource

+	err = json.Unmarshal(rsp.body, &list)

+	if err != nil {

+		t.Fatal(err)

+	}

+	if len(list) != 0 {

+		t.Fatalf("Expected empty list. Got %v", list)

+	}

+

+	n, err := c.NewNetwork(bridgeNetType, "didietro", nil)

 	if err != nil {

 		t.Fatal(err)

 	}

 	nwr := buildNetworkResource(n)

-	expected, err := json.Marshal([]networkResource{*nwr})

+	expected, err := json.Marshal([]*networkResource{nwr})

 	if err != nil {

 		t.Fatal(err)

 	}

@@ -1229,7 +1196,7 @@ func TestHttpHandlerBadBody(t *testing.T) {

 	}

 	handleRequest := NewHTTPHandler(c)

-	req, err := http.NewRequest("POST", "/networks/name/zero-network", &localReader{beBad: true})

+	req, err := http.NewRequest("POST", "/v1.19/networks", &localReader{beBad: true})

 	if err != nil {

 		t.Fatal(err)

 	}

@@ -1240,7 +1207,7 @@ func TestHttpHandlerBadBody(t *testing.T) {

 	body := []byte{}

 	lr := newLocalReader(body)

-	req, err = http.NewRequest("POST", "/networks/name/zero-network", lr)

+	req, err = http.NewRequest("POST", "/v1.19/networks", lr)

 	if err != nil {

 		t.Fatal(err)

 	}

@@ -1250,7 +1217,7 @@ func TestHttpHandlerBadBody(t *testing.T) {

 	}

 }

-func TestHttpHandlerGood(t *testing.T) {

+func TestEndToEnd(t *testing.T) {

 	defer netutils.SetupTestNetNS(t)()

 	rsp := newWriter()

@@ -1261,14 +1228,14 @@ func TestHttpHandlerGood(t *testing.T) {

 	}

 	handleRequest := NewHTTPHandler(c)

-	nc := networkCreate{Name: "zero-network", NetworkType: bridgeNetType}

+	// Create network

+	nc := networkCreate{Name: "network-fiftyfive", NetworkType: bridgeNetType}

 	body, err := json.Marshal(nc)

 	if err != nil {

 		t.Fatal(err)