IPAM config through cni network config

Signed-off-by: Abhinandan Prativadi <abhi@docker.com>

Author: abhi

Makefile

@@ -36,7 +36,7 @@ build-local:
 	@mkdir -p "bin"
 	go build -tags experimental -o "bin/dnet" ./cmd/dnet
 	go build -o "bin/docker-proxy" ./cmd/proxy
-	go build -o "bin/cniserver" ./pkg/server
+	go build -o "bin/cniserver" ./cmd/cni_
 	go build -o "bin/cnictl" ./cni/
 clean:
 	@echo "🐳 $@"

cmd/cni_/cni_.go

@@ -0,0 +1,36 @@
+package main
+
+import (
+	"io"
+	"os"
+
+	"github.com/codegangsta/cli"
+	"github.com/docker/docker/pkg/reexec"
+	"github.com/docker/docker/pkg/term"
+	"github.com/sirupsen/logrus"
+)
+
+func main() {
+	if reexec.Init() {
+		return
+	}
+	_, stdout, stderr := term.StdStreams()
+	logrus.SetOutput(stderr)
+	err := cniApp(stdout, stderr)
+	if err != nil {
+		os.Exit(1)
+	}
+}
+
+func cniApp(stdout, stderr io.Writer) error {
+	app := cli.NewApp()
+
+	app.Name = "cniserver"
+	app.Usage = "A cni side car for libnetwork daemon."
+	app.Flags = cniserverFlags
+	app.Before = processFlags
+	//app.Commands = cniCommands
+
+	app.Run(os.Args)
+	return nil
+}

cmd/cni_/flags_.go

@@ -0,0 +1,54 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/codegangsta/cli"
+	cniserver "github.com/docker/libnetwork/pkg/server/cniserver"
+	"github.com/sirupsen/logrus"
+)
+
+var (
+	cniserverFlags = []cli.Flag{
+		cli.StringFlag{
+			Name:  "sock",
+			Value: "/var/run/cniserver.sock",
+			Usage: "path to the socket file on which cniserver listens. Default (/var/run/cni-libnetwork.sock)",
+		},
+		cli.StringFlag{
+			Name:  "dnet-port",
+			Value: "2389",
+			Usage: "Daemon socket to connect to. Default(2389)",
+		},
+		cli.StringFlag{
+			Name:  "dnet-address",
+			Value: "127.0.0.1",
+			Usage: "Daemon IP address to connect to",
+		},
+		cli.BoolFlag{
+			Name:  "D, -debug",
+			Usage: "Enable debug mode",
+		},
+	}
+)
+
+func processFlags(c *cli.Context) error {
+	var err error
+
+	if c.Bool("D") {
+		logrus.SetLevel(logrus.DebugLevel)
+	}
+
+	cniService, err := cniserver.NewCniService(c.String("sock"), c.String("dnet-address"), c.String("dnet-port"))
+	if err != nil {
+		return fmt.Errorf("faile to create cni service: %v", err)
+	}
+	serverCloseChan := make(chan struct{})
+	if err := cniService.InitCniService(serverCloseChan); err != nil {
+		fmt.Printf("Failed to initialize CNI server: \n", err)
+		os.Exit(1)
+	}
+	<-serverCloseChan
+	return nil
+}

cmd/dnet/cmd.go

@@ -3,14 +3,12 @@ package main
 import (
 	"encoding/json"
 	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
 	"os"
 
 	"github.com/codegangsta/cli"
 	"github.com/docker/docker/pkg/term"
 	"github.com/docker/libnetwork/client"
+	"github.com/docker/libnetwork/netutils"
 )
 
 var (
@@ -49,7 +47,7 @@ func runContainerCreate(c *cli.Context) {
 	}
 
 	sc := client.SandboxCreate{ContainerID: c.Args()[0]}
-	obj, _, err := readBody(epConn.httpCall("POST", "/sandboxes", sc, nil))
+	obj, _, err := netutils.ReadBody(epConn.conn.HttpCall("POST", "/sandboxes", sc, nil))
 	if err != nil {
 		fmt.Printf("POST failed during create container: %v\n", err)
 		os.Exit(1)
@@ -74,7 +72,7 @@ func runContainerRm(c *cli.Context) {
 		os.Exit(1)
 	}
 
-	obj, _, err := readBody(epConn.httpCall("GET", "/sandboxes?partial-container-id="+c.Args()[0], nil, nil))
+	obj, _, err := netutils.ReadBody(epConn.conn.HttpCall("GET", "/sandboxes?partial-container-id="+c.Args()[0], nil, nil))
 	if err != nil {
 		fmt.Printf("GET failed during container id lookup: %v\n", err)
 		os.Exit(1)
@@ -91,7 +89,7 @@ func runContainerRm(c *cli.Context) {
 		os.Exit(1)
 	}
 
-	_, _, err = readBody(epConn.httpCall("DELETE", "/sandboxes/"+sbList[0].ID, nil, nil))
+	_, _, err = netutils.ReadBody(epConn.conn.HttpCall("DELETE", "/sandboxes/"+sbList[0].ID, nil, nil))
 	if err != nil {
 		fmt.Printf("DELETE of sandbox id %s failed: %v", sbList[0].ID, err)
 		os.Exit(1)
@@ -100,7 +98,7 @@ func runContainerRm(c *cli.Context) {
 
 func runDockerCommand(c *cli.Context, cmd string) {
 	_, stdout, stderr := term.StdStreams()
-	oldcli := client.NewNetworkCli(stdout, stderr, epConn.httpCall)
+	oldcli := client.NewNetworkCli(stdout, stderr, epConn.conn.HttpCall)
 	var args []string
 	args = append(args, cmd)
 	if c.Bool("h") {
@@ -130,17 +128,3 @@ func createDockerCommand(cmd string) cli.Command {
 		},
 	}
 }
-
-func readBody(stream io.ReadCloser, hdr http.Header, statusCode int, err error) ([]byte, int, error) {
-	if stream != nil {
-		defer stream.Close()
-	}
-	if err != nil {
-		return nil, statusCode, err
-	}
-	body, err := ioutil.ReadAll(stream)
-	if err != nil {
-		return nil, -1, err
-	}
-	return body, statusCode, nil
-}

cmd/dnet/dnet.go

@@ -1,8 +1,6 @@
 package main
 
 import (
-	"bytes"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
@@ -96,10 +94,10 @@ func (d *dnetConnection) parseConfig(cfgFile string) (*config.Config, error) {
 	return config.ParseConfig(cfgFile)
 }
 
-func processConfig(cfg *config.Config) []config.Option {
+func processConfig(cfg *config.Config) ([]config.Option, error) {
 	options := []config.Option{}
 	if cfg == nil {
-		return options
+		return options, nil
 	}
 
 	dn := "bridge"
@@ -131,14 +129,19 @@ func processConfig(cfg *config.Config) []config.Option {
 		options = append(options, config.OptionDataDir(cfg.Daemon.DataDir))
 	}
 
-	dOptions, err := startDiscovery(&cfg.Cluster)
-	if err != nil {
-		logrus.Infof("Skipping discovery : %s", err.Error())
-	} else {
-		options = append(options, dOptions...)
+	// Retry discovery for 2 minutes before exiting
+	for {
+		select {
+		case <-time.After(2 * time.Minute):
+			return nil, fmt.Errorf("failed to initialize discovery")
+		default:
+			dOptions, err := startDiscovery(&cfg.Cluster)
+			if err == nil {
+				options = append(options, dOptions...)
+				return options, nil
+			}
+		}
 	}
-
-	return options
 }
 
 func startDiscovery(cfg *config.ClusterCfg) ([]config.Option, error) {
@@ -238,10 +241,7 @@ func createDefaultNetwork(c libnetwork.NetworkController) {
 }
 
 type dnetConnection struct {
-	// proto holds the client protocol i.e. unix.
-	proto string
-	// addr holds the client address.
-	addr          string
+	conn          *netutils.HttpConnection
 	Orchestration *NetworkOrchestration
 	configEvent   chan cluster.ConfigEventType
 }
@@ -262,9 +262,12 @@ func (d *dnetConnection) dnetDaemon(cfgFile string) error {
 	cfg, err := d.parseConfig(cfgFile)
 	var cOptions []config.Option
 	if err == nil {
-		cOptions = processConfig(cfg)
+		cOptions, err = processConfig(cfg)
+		if err != nil {
+			fmt.Errorf("failed to process config: %v", err)
+		}
 	} else {
-		logrus.Errorf("Error parsing config %v", err)
+		logrus.Errorf("failed to parse config: %v", err)
 	}
 
 	bridgeConfig := options.Generic{
@@ -306,7 +309,7 @@ func (d *dnetConnection) dnetDaemon(cfgFile string) error {
 	handleSignals(controller)
 	setupDumpStackTrap()
 
-	return http.ListenAndServe(d.addr, r)
+	return http.ListenAndServe(d.conn.Addr, r)
 }
 
 func (d *dnetConnection) IsManager() bool {
@@ -436,76 +439,14 @@ func newDnetConnection(val string) (*dnetConnection, error) {
 		return nil, errors.New("dnet currently only supports tcp transport")
 	}
 
-	return &dnetConnection{protoAddrParts[0], protoAddrParts[1], &NetworkOrchestration{}, make(chan cluster.ConfigEventType, 10)}, nil
-}
-
-func (d *dnetConnection) httpCall(method, path string, data interface{}, headers map[string][]string) (io.ReadCloser, http.Header, int, error) {
-	var in io.Reader
-	in, err := encodeData(data)
-	if err != nil {
-		return nil, nil, -1, err
-	}
-
-	req, err := http.NewRequest(method, fmt.Sprintf("%s", path), in)
-	if err != nil {
-		return nil, nil, -1, err
-	}
-
-	setupRequestHeaders(method, data, req, headers)
-
-	req.URL.Host = d.addr
-	req.URL.Scheme = "http"
-	fmt.Printf("Requesting http: %+v", req)
-	httpClient := &http.Client{}
-	resp, err := httpClient.Do(req)
-	statusCode := -1
-	if resp != nil {
-		statusCode = resp.StatusCode
-	}
-	if err != nil {
-		return nil, nil, statusCode, fmt.Errorf("error when trying to connect: %v", err)
-	}
-
-	if statusCode < 200 || statusCode >= 400 {
-		body, err := ioutil.ReadAll(resp.Body)
-		if err != nil {
-			return nil, nil, statusCode, err
-		}
-		return nil, nil, statusCode, fmt.Errorf("error : %s", bytes.TrimSpace(body))
-	}
-
-	return resp.Body, resp.Header, statusCode, nil
-}
-
-func setupRequestHeaders(method string, data interface{}, req *http.Request, headers map[string][]string) {
-	if data != nil {
-		if headers == nil {
-			headers = make(map[string][]string)
-		}
-		headers["Content-Type"] = []string{"application/json"}
-	}
-
-	expectedPayload := (method == "POST" || method == "PUT")
-
-	if expectedPayload && req.Header.Get("Content-Type") == "" {
-		req.Header.Set("Content-Type", "text/plain")
-	}
-
-	if headers != nil {
-		for k, v := range headers {
-			req.Header[k] = v
-		}
-	}
-}
-
-func encodeData(data interface{}) (*bytes.Buffer, error) {
-	params := bytes.NewBuffer(nil)
-	if data != nil {
-		if err := json.NewEncoder(params).Encode(data); err != nil {
-			return nil, err
-		}
-	}
-	return params, nil
+	return &dnetConnection{
+		&netutils.HttpConnection{
+			Proto: protoAddrParts[0],
+			Addr:  protoAddrParts[1],
+		},
+		&NetworkOrchestration{},
+		make(chan cluster.ConfigEventType, 10),
+	}, nil
 }
 
 func ipamOption(bridgeName string) libnetwork.NetworkOption {

cni/main.go

@@ -11,23 +11,23 @@ import (
 )
 
 func cmdAdd(args *skel.CmdArgs) error {
-	libClient := cniapi.NewLibNetCniClient()
-	result, err := libClient.SetupPod(args)
+	c := cniapi.NewDnetCniClient()
+	result, err := c.SetupPod(args)
 	if err != nil {
-		return fmt.Errorf("Failed to setup Pod , %v", err)
+		return fmt.Errorf("failed to setup Pod: %v", err)
 	}
 	return types.PrintResult(result, version.Current())
 }
 
 func cmdDel(args *skel.CmdArgs) error {
-	libClient := cniapi.NewLibNetCniClient()
-	if err := libClient.TearDownPod(args); err != nil {
-		return fmt.Errorf("Failed to tear down pod, %v", err)
+	c := cniapi.NewDnetCniClient()
+	if err := c.TearDownPod(args); err != nil {
+		return fmt.Errorf("failed to tear down pod: %v", err)
 	}
 	return nil
 }
 
 func main() {
-	log.Infof("Starting Libnetwork CNI plugin")
+	log.Infof("Dnet CNI plugin")
 	skel.PluginMain(cmdAdd, cmdDel, version.PluginSupports("", "0.1.0", "0.2.0", version.Current()))
 }