Factor an API out into a module

This takes some of the machinery from CNI and from the rkt networking
code, and turns it into a library that can be linked into go apps.

Included is an example command-line application that uses the library,
called `cnitool`.

Other headline changes:

 * Plugin exec'ing is factored out

The motivation here is to factor out the protocol for invoking
plugins. To that end, a generalisation of the code from api.go and
pkg/plugin/ipam.go goes into pkg/invoke/exec.go.

 * Move argument-handling and conf-loading into public API

The fact that the arguments get turned into an environment for the
plugin is incidental to the API; so, provide a way of supplying them
as a struct or saying "just use the same arguments as I got" (the
latter is for IPAM plugins).

plugins/ipam/dhcp/daemon.go

@@ -27,8 +27,8 @@ import (
 	"runtime"
 	"sync"
 
-	"github.com/appc/cni/pkg/plugin"
 	"github.com/appc/cni/pkg/skel"
+	"github.com/appc/cni/pkg/types"
 	"github.com/coreos/go-systemd/activation"
 )
 
@@ -50,8 +50,8 @@ func newDHCP() *DHCP {
 
 // Allocate acquires an IP from a DHCP server for a specified container.
 // The acquired lease will be maintained until Release() is called.
-func (d *DHCP) Allocate(args *skel.CmdArgs, result *plugin.Result) error {
-	conf := plugin.NetConf{}
+func (d *DHCP) Allocate(args *skel.CmdArgs, result *types.Result) error {
+	conf := types.NetConf{}
 	if err := json.Unmarshal(args.StdinData, &conf); err != nil {
 		return fmt.Errorf("error parsing netconf: %v", err)
 	}
@@ -70,7 +70,7 @@ func (d *DHCP) Allocate(args *skel.CmdArgs, result *plugin.Result) error {
 
 	d.setLease(args.ContainerID, conf.Name, l)
 
-	result.IP4 = &plugin.IPConfig{
+	result.IP4 = &types.IPConfig{
 		IP:      *ipn,
 		Gateway: l.Gateway(),
 		Routes:  l.Routes(),
@@ -82,7 +82,7 @@ func (d *DHCP) Allocate(args *skel.CmdArgs, result *plugin.Result) error {
 // Release stops maintenance of the lease acquired in Allocate()
 // and sends a release msg to the DHCP server.
 func (d *DHCP) Release(args *skel.CmdArgs, reply *struct{}) error {
-	conf := plugin.NetConf{}
+	conf := types.NetConf{}
 	if err := json.Unmarshal(args.StdinData, &conf); err != nil {
 		return fmt.Errorf("error parsing netconf: %v", err)
 	}

plugins/ipam/dhcp/lease.go

@@ -28,7 +28,7 @@ import (
 	"github.com/vishvananda/netlink"
 
 	"github.com/appc/cni/pkg/ns"
-	"github.com/appc/cni/pkg/plugin"
+	"github.com/appc/cni/pkg/types"
 )
 
 // RFC 2131 suggests using exponential backoff, starting with 4sec
@@ -285,7 +285,7 @@ func (l *DHCPLease) Gateway() net.IP {
 	return parseRouter(l.opts)
 }
 
-func (l *DHCPLease) Routes() []plugin.Route {
+func (l *DHCPLease) Routes() []types.Route {
 	routes := parseRoutes(l.opts)
 	return append(routes, parseCIDRRoutes(l.opts)...)
 }

plugins/ipam/dhcp/main.go

@@ -20,8 +20,8 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/appc/cni/pkg/plugin"
 	"github.com/appc/cni/pkg/skel"
+	"github.com/appc/cni/pkg/types"
 )
 
 const socketPath = "/run/cni/dhcp.sock"
@@ -35,7 +35,7 @@ func main() {
 }
 
 func cmdAdd(args *skel.CmdArgs) error {
-	result := plugin.Result{}
+	result := types.Result{}
 	if err := rpcCall("DHCP.Allocate", args, &result); err != nil {
 		return err
 	}

plugins/ipam/dhcp/options.go

@@ -20,7 +20,7 @@ import (
 	"net"
 	"time"
 
-	"github.com/appc/cni/pkg/plugin"
+	"github.com/appc/cni/pkg/types"
 	"github.com/d2g/dhcp4"
 )
 
@@ -40,17 +40,17 @@ func classfulSubnet(sn net.IP) net.IPNet {
 	}
 }
 
-func parseRoutes(opts dhcp4.Options) []plugin.Route {
+func parseRoutes(opts dhcp4.Options) []types.Route {
 	// StaticRoutes format: pairs of:
 	// Dest = 4 bytes; Classful IP subnet
 	// Router = 4 bytes; IP address of router
 
-	routes := []plugin.Route{}
+	routes := []types.Route{}
 	if opt, ok := opts[dhcp4.OptionStaticRoute]; ok {
 		for len(opt) >= 8 {
 			sn := opt[0:4]
 			r := opt[4:8]
-			rt := plugin.Route{
+			rt := types.Route{
 				Dst: classfulSubnet(sn),
 				GW:  r,
 			}
@@ -62,10 +62,10 @@ func parseRoutes(opts dhcp4.Options) []plugin.Route {
 	return routes
 }
 
-func parseCIDRRoutes(opts dhcp4.Options) []plugin.Route {
+func parseCIDRRoutes(opts dhcp4.Options) []types.Route {
 	// See RFC4332 for format (http://tools.ietf.org/html/rfc3442)
 
-	routes := []plugin.Route{}
+	routes := []types.Route{}
 	if opt, ok := opts[dhcp4.OptionClasslessRouteFormat]; ok {
 		for len(opt) >= 5 {
 			width := int(opt[0])
@@ -89,7 +89,7 @@ func parseCIDRRoutes(opts dhcp4.Options) []plugin.Route {
 
 			gw := net.IP(opt[octets+1 : octets+5])
 
-			rt := plugin.Route{
+			rt := types.Route{
 				Dst: net.IPNet{
 					IP:   net.IP(sn),
 					Mask: net.CIDRMask(width, 32),

plugins/ipam/dhcp/options_test.go

@@ -18,20 +18,20 @@ import (
 	"net"
 	"testing"
 
-	"github.com/appc/cni/pkg/plugin"
+	"github.com/appc/cni/pkg/types"
 	"github.com/d2g/dhcp4"
 )
 
-func validateRoutes(t *testing.T, routes []plugin.Route) {
-	expected := []plugin.Route{
-		plugin.Route{
+func validateRoutes(t *testing.T, routes []types.Route) {
+	expected := []types.Route{
+		types.Route{
 			Dst: net.IPNet{
 				IP:   net.IPv4(10, 0, 0, 0),
 				Mask: net.CIDRMask(8, 32),
 			},
 			GW: net.IPv4(10, 1, 2, 3),
 		},
-		plugin.Route{
+		types.Route{
 			Dst: net.IPNet{
 				IP:   net.IPv4(192, 168, 1, 0),
 				Mask: net.CIDRMask(24, 32),