Adding net support to docker create

Adding net support to port layer exec create

Author: Hasan Mahmood

apiservers/engine/backends/container.go

@@ -283,6 +283,7 @@ func (c *Container) dockerContainerCreateParamsToPortlayer(cc types.ContainerCre
 	// network
 	portLayerConfig.CreateConfig.NetworkDisabled = new(bool)
 	*portLayerConfig.CreateConfig.NetworkDisabled = cc.Config.NetworkDisabled
+	portLayerConfig.CreateConfig.NetworkSettings = toModelsNetworkConfig(cc)
 
 	// working dir
 	portLayerConfig.CreateConfig.WorkingDir = new(string)
@@ -291,6 +292,25 @@ func (c *Container) dockerContainerCreateParamsToPortlayer(cc types.ContainerCre
 	return portLayerConfig
 }
 
+func toModelsNetworkConfig(cc types.ContainerCreateConfig) *models.NetworkConfig {
+	if cc.Config.NetworkDisabled {
+		return nil
+	}
+
+	nc := &models.NetworkConfig{
+		NetworkName: cc.HostConfig.NetworkMode.NetworkName(),
+	}
+	if cc.NetworkingConfig != nil {
+		if es, ok := cc.NetworkingConfig.EndpointsConfig[nc.NetworkName]; ok {
+			if es.IPAMConfig != nil {
+				nc.Address = &es.IPAMConfig.IPv4Address
+			}
+		}
+	}
+
+	return nc
+}
+
 func (c *Container) imageExist(imageID string) (storeName string, err error) {
 	// Call the storage port layer to determine if the image currently exist
 	host, err := os.Hostname()

apiservers/engine/backends/network.go

@@ -92,10 +92,12 @@ func (n *Network) CreateNetwork(name, driver string, ipam apinet.IPAM, options m
 	var pools []string
 	if len(ipam.Config) > 0 {
 		if ipam.Config[0].Gateway != "" {
+			gateway = new(string)
 			*gateway = ipam.Config[0].Gateway
 		}
 
 		if ipam.Config[0].Subnet != "" {
+			subnet = new(string)
 			*subnet = ipam.Config[0].Subnet
 		}
 

apiservers/portlayer/restapi/configure_port_layer.go

@@ -15,6 +15,7 @@
 package restapi
 
 import (
+	"net"
 	"net/http"
 
 	log "github.com/Sirupsen/logrus"
@@ -26,15 +27,20 @@ import (
 	"github.com/vmware/vic/apiservers/portlayer/restapi/handlers"
 	"github.com/vmware/vic/apiservers/portlayer/restapi/operations"
 	"github.com/vmware/vic/apiservers/portlayer/restapi/options"
+	"github.com/vmware/vic/portlayer/network"
 )
 
 // This file is safe to edit. Once it exists it will not be overwritten
 
-type portlayerhandlers struct {
-	storageHandlers handlers.StorageHandlersImpl
-	miscHandlers    handlers.MiscHandlersImpl
-	scopesHandlers  handlers.ScopesHandlersImpl
-	execHandlers    handlers.ExecHandlersImpl
+type handler interface {
+	Configure(api *operations.PortLayerAPI, netCtx *network.Context)
+}
+
+var portlayerhandlers = []handler{
+	&handlers.StorageHandlersImpl{},
+	&handlers.MiscHandlersImpl{},
+	&handlers.ScopesHandlersImpl{},
+	&handlers.ExecHandlersImpl{},
 }
 
 func configureFlags(api *operations.PortLayerAPI) {
@@ -63,12 +69,19 @@ func configureAPI(api *operations.PortLayerAPI) http.Handler {
 
 	api.TxtProducer = httpkit.TextProducer()
 
-	allhandlers := portlayerhandlers{}
+	netCtx, err := network.NewContext(
+		net.IPNet{
+			IP:   net.IPv4(172, 16, 0, 0),
+			Mask: net.CIDRMask(12, 32),
+		},
+		net.CIDRMask(16, 32))
+	if err != nil {
+		log.Fatalf("failed to create network context: %s", err)
+	}
 
-	allhandlers.storageHandlers.Configure(api)
-	allhandlers.miscHandlers.Configure(api)
-	allhandlers.scopesHandlers.Configure(api)
-	allhandlers.execHandlers.Configure(api)
+	for _, handler := range portlayerhandlers {
+		handler.Configure(api, netCtx)
+	}
 
 	api.ServerShutdown = func() {}
 	return setupGlobalMiddleware(api.Serve(setupMiddlewares))

apiservers/portlayer/restapi/handlers/exec_handlers.go

@@ -17,6 +17,7 @@ package handlers
 import (
 	"fmt"
 	"math/rand"
+	"net"
 	"strings"
 
 	"github.com/docker/docker/pkg/namesgenerator"
@@ -37,10 +38,13 @@ import (
 	"github.com/vmware/vic/pkg/vsphere/spec"
 	"github.com/vmware/vic/pkg/vsphere/tasks"
 	"github.com/vmware/vic/pkg/vsphere/vm"
+	"github.com/vmware/vic/portlayer/network"
 )
 
 // ExecHandlersImpl is the receiver for all of the exec handler methods
-type ExecHandlersImpl struct{}
+type ExecHandlersImpl struct {
+	netCtx *network.Context
+}
 
 var (
 	execSession = &session.Session{}
@@ -51,7 +55,7 @@ const (
 )
 
 // Configure assigns functions to all the exec api handlers
-func (handler *ExecHandlersImpl) Configure(api *operations.PortLayerAPI) {
+func (handler *ExecHandlersImpl) Configure(api *operations.PortLayerAPI, netCtx *network.Context) {
 	var err error
 
 	api.ExecContainerCreateHandler = exec.ContainerCreateHandlerFunc(handler.ContainerCreateHandler)
@@ -73,12 +77,73 @@ func (handler *ExecHandlersImpl) Configure(api *operations.PortLayerAPI) {
 	if err != nil {
 		log.Fatalf("ERROR: %s", err)
 	}
+
+	handler.netCtx = netCtx
+}
+
+func (handler *ExecHandlersImpl) addContainerToScope(name string, ns *models.NetworkConfig) (*metadata.NetworkEndpoint, *network.Scope, error) {
+	if ns == nil {
+		return nil, nil, nil
+	}
+
+	var err error
+	var s *network.Scope
+	switch ns.NetworkName {
+	// docker's default network, usually maps to the default bridge network
+	case "default":
+		s = handler.netCtx.DefaultScope()
+
+	default:
+		var scopes []*network.Scope
+		scopes, err = handler.netCtx.Scopes(&ns.NetworkName)
+		if err != nil || len(scopes) != 1 {
+			return nil, nil, err
+		}
+
+		// should have only one match at this point
+		s = scopes[0]
+	}
+
+	var ip *net.IP
+	if ns.Address != nil {
+		i := net.ParseIP(*ns.Address)
+		if i == nil {
+			return nil, nil, fmt.Errorf("invalid ip address")
+		}
+
+		ip = &i
+	}
+
+	var e *network.Endpoint
+	e, err = s.AddContainer(name, ip)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	ne := &metadata.NetworkEndpoint{
+		IP: net.IPNet{
+			IP:   e.IP(),
+			Mask: e.Subnet().Mask,
+		},
+		Network: metadata.ContainerNetwork{
+			// FIXME: https://github.com/vmware/vic/issues/444
+			// FIXME: this needs to point to switch or port group name
+			Name: e.Scope().Name(),
+			Gateway: net.IPNet{
+				IP:   e.Gateway(),
+				Mask: e.Subnet().Mask,
+			},
+		},
+	}
+
+	return ne, s, nil
 }
 
 // ContainerCreateHandler creates a new container
 func (handler *ExecHandlersImpl) ContainerCreateHandler(params exec.ContainerCreateParams) middleware.Responder {
 	defer trace.End(trace.Begin("ContainerCreate"))
 
+	var err error
 	var name string
 	session := execSession
 
@@ -122,9 +187,26 @@ func (handler *ExecHandlersImpl) ContainerCreateHandler(params exec.ContainerCre
 				Cmd: cmd,
 			},
 		},
+		Networks: make(map[string]metadata.NetworkEndpoint),
 	}
 	log.Infof("Metadata: %#v", m)
 
+	// network config
+	ns := params.CreateConfig.NetworkSettings
+	ne, s, err := handler.addContainerToScope(name, ns)
+	defer func() {
+		if err != nil {
+			log.Errorf(err.Error())
+			if s != nil {
+				s.RemoveContainer(name)
+			}
+		}
+	}()
+
+	if ne != nil {
+		m.Networks[ne.Network.Name] = *ne
+	}
+
 	specconfig := &spec.VirtualMachineConfigSpecConfig{
 		// FIXME: hardcoded values
 		NumCPUs:  2,

apiservers/portlayer/restapi/handlers/misc_handlers.go

@@ -18,12 +18,13 @@ import (
 	"github.com/go-swagger/go-swagger/httpkit/middleware"
 	"github.com/vmware/vic/apiservers/portlayer/restapi/operations"
 	"github.com/vmware/vic/apiservers/portlayer/restapi/operations/misc"
+	"github.com/vmware/vic/portlayer/network"
 )
 
 type MiscHandlersImpl struct{}
 
 // Configure assigns functions to all the miscellaneous api handlers
-func (handler *MiscHandlersImpl) Configure(api *operations.PortLayerAPI) {
+func (handler *MiscHandlersImpl) Configure(api *operations.PortLayerAPI, netCtx *network.Context) {
 	api.MiscPingHandler = misc.PingHandlerFunc(handler.Ping)
 }
 

apiservers/portlayer/restapi/handlers/scopes_handlers.go

@@ -19,7 +19,6 @@ import (
 	"net"
 	"net/http"
 
-	log "github.com/Sirupsen/logrus"
 	middleware "github.com/go-swagger/go-swagger/httpkit/middleware"
 
 	"github.com/vmware/vic/apiservers/portlayer/models"
@@ -30,26 +29,16 @@ import (
 
 // ScopesHandlersImpl is the receiver for all of the storage handler methods
 type ScopesHandlersImpl struct {
-	ctx *network.Context
+	netCtx *network.Context
 }
 
-// Configure assigns functions to all the storage api handlers
-func (handler *ScopesHandlersImpl) Configure(api *operations.PortLayerAPI) {
+// Configure assigns functions to all the scopes api handlers
+func (handler *ScopesHandlersImpl) Configure(api *operations.PortLayerAPI, netCtx *network.Context) {
 	api.ScopesCreateHandler = scopes.CreateHandlerFunc(handler.ScopesCreate)
 	api.ScopesListAllHandler = scopes.ListAllHandlerFunc(handler.ScopesListAll)
 	api.ScopesListHandler = scopes.ListHandlerFunc(handler.ScopesList)
 
-	var err error
-	handler.ctx, err = network.NewContext(
-		net.IPNet{
-			IP:   net.IPv4(172, 16, 0, 0),
-			Mask: net.CIDRMask(12, 32),
-		},
-		net.CIDRMask(16, 32))
-
-	if err != nil {
-		log.Fatalf("could not create network context: %s", err)
-	}
+	handler.netCtx = netCtx
 }
 
 func parseScopeConfig(cfg *models.ScopeConfig) (subnet *net.IPNet, gateway net.IP, dns []net.IP, err error) {
@@ -104,7 +93,7 @@ func (handler *ScopesHandlersImpl) ScopesCreate(params scopes.CreateParams) midd
 		return scopes.NewCreateDefault(http.StatusServiceUnavailable).WithPayload(&models.Error{Message: err.Error()})
 	}
 
-	s, err := handler.ctx.NewScope(cfg.ScopeType, cfg.Name, subnet, gateway, dns, cfg.IPAM)
+	s, err := handler.netCtx.NewScope(cfg.ScopeType, cfg.Name, subnet, gateway, dns, cfg.IPAM)
 	if _, ok := err.(network.DuplicateResourceError); ok {
 		return scopes.NewCreateConflict()
 	}
@@ -117,7 +106,7 @@ func (handler *ScopesHandlersImpl) ScopesCreate(params scopes.CreateParams) midd
 }
 
 func (handler *ScopesHandlersImpl) ScopesListAll() middleware.Responder {
-	cfgs, err := listScopes(handler.ctx, "")
+	cfgs, err := listScopes(handler.netCtx, "")
 	if err != nil {
 		return scopes.NewListDefault(http.StatusServiceUnavailable).WithPayload(&models.Error{Message: err.Error()})
 	}
@@ -126,7 +115,7 @@ func (handler *ScopesHandlersImpl) ScopesListAll() middleware.Responder {
 }
 
 func (handler *ScopesHandlersImpl) ScopesList(params scopes.ListParams) middleware.Responder {
-	cfgs, err := listScopes(handler.ctx, params.IDName)
+	cfgs, err := listScopes(handler.netCtx, params.IDName)
 	if _, ok := err.(network.ResourceNotFoundError); ok {
 		return scopes.NewListNotFound()
 	}

apiservers/portlayer/restapi/handlers/storage_handlers.go

@@ -29,6 +29,7 @@ import (
 	"github.com/vmware/vic/apiservers/portlayer/restapi/options"
 	"github.com/vmware/vic/pkg/vsphere/session"
 
+	"github.com/vmware/vic/portlayer/network"
 	spl "github.com/vmware/vic/portlayer/storage"
 	"github.com/vmware/vic/portlayer/util"
 	vsphere "github.com/vmware/vic/portlayer/vsphere/storage"
@@ -43,7 +44,7 @@ var (
 )
 
 // Configure assigns functions to all the storage api handlers
-func (handler *StorageHandlersImpl) Configure(api *operations.PortLayerAPI) {
+func (handler *StorageHandlersImpl) Configure(api *operations.PortLayerAPI, netCtx *network.Context) {
 	var err error
 
 	ctx := context.Background()

apiservers/portlayer/swagger.yml

@@ -283,7 +283,7 @@ paths:
       summary: "Starts an existing container"
       operationId: ContainerStart
       tags: ["exec"]
-      consumes: 
+      consumes:
         - application/octet-stream
       parameters:
         - name: id
@@ -408,8 +408,19 @@ definitions:
           type: string
       networkDisabled:
         type: boolean
+      networkSettings:
+        $ref: "#/definitions/NetworkConfig"
   ContainerCreatedInfo:
     type: object
     properties:
       containerID:
         type: string
+  NetworkConfig:
+    type: object
+    required:
+      - networkName
+    properties:
+      networkName:
+        type: string
+      address:
+        type: string

portlayer/network/context.go

@@ -29,8 +29,8 @@ type Context struct {
 	defaultBridgePool *AddressSpace
 	defaultBridgeMask net.IPMask
 
-	scopes             map[string]*Scope
-	defaultBridgeScope *Scope
+	scopes       map[string]*Scope
+	defaultScope *Scope
 }
 
 func NewContext(bridgePool net.IPNet, bridgeMask net.IPMask) (*Context, error) {
@@ -51,7 +51,7 @@ func NewContext(bridgePool net.IPNet, bridgeMask net.IPMask) (*Context, error) {
 		return nil, err
 	}
 
-	ctx.defaultBridgeScope = s
+	ctx.defaultScope = s
 	return ctx, nil
 }
 
@@ -347,3 +347,7 @@ func (c *Context) Scopes(idName *string) ([]*Scope, error) {
 
 	return _scopes, nil
 }
+
+func (c *Context) DefaultScope() *Scope {
+	return c.defaultScope
+}