## What is CNI?
CNI, the _Container Network Interface_, is a proposed standard for configuring network interfaces for Linux application containers.
-The standard consists of a simple specification for how executable plugins can be used to configure network namespaces.
+The standard consists of a simple specification for how executable plugins can be used to configure network namespaces; this repository also contains a go library implementing that specification.
+
The specification itself is contained in [SPEC.md](SPEC.md)
## Why develop CNI?
EOF
```
+The directory `/etc/cni/net.d` is the default location in which the scripts will look for net configurations.
+
Next, build the plugins:
```
RX bytes:0 (0.0 B) TX bytes:0 (0.0 B)
```
+The environment variable `CNI_PATH` tells the scripts and library where to look for plugin executables.
+
## Running a Docker container with network namespace set up by CNI plugins
Use instructions in the previous section to define a netconf and build the plugins.
export GOBIN=${PWD}/bin
export GOPATH=${PWD}/gopath:$(pwd)/Godeps/_workspace
+echo "Building API"
+go build ${REPO_PATH}/libcni
+
+echo "Building reference CLI"
+go install ${REPO_PATH}/cnitool
+
echo "Building plugins"
PLUGINS="plugins/meta/* plugins/main/* plugins/ipam/*"
--- /dev/null
+// Copyright 2015 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+ "fmt"
+ "os"
+ "path/filepath"
+ "strings"
+
+ "github.com/appc/cni/libcni"
+)
+
+const (
+ EnvCNIPath = "CNI_PATH"
+ EnvNetDir = "NETCONFPATH"
+
+ DefaultNetDir = "/etc/cni/net.d"
+
+ CmdAdd = "add"
+ CmdDel = "del"
+)
+
+func main() {
+ if len(os.Args) < 3 {
+ usage()
+ return
+ }
+
+ netdir := os.Getenv(EnvNetDir)
+ if netdir == "" {
+ netdir = DefaultNetDir
+ }
+ netconf, err := libcni.LoadConf(netdir, os.Args[2])
+ if err != nil {
+ exit(err)
+ }
+
+ netns := os.Args[3]
+
+ cninet := &libcni.CNIConfig{
+ Path: strings.Split(os.Getenv(EnvCNIPath), ":"),
+ }
+
+ rt := &libcni.RuntimeConf{
+ ContainerID: "cni",
+ NetNS: netns,
+ IfName: "eth0",
+ }
+
+ switch os.Args[1] {
+ case CmdAdd:
+ _, err := cninet.AddNetwork(netconf, rt)
+ exit(err)
+ case CmdDel:
+ exit(cninet.DelNetwork(netconf, rt))
+ }
+}
+
+func usage() {
+ exe := filepath.Base(os.Args[0])
+
+ fmt.Fprintf(os.Stderr, "%s: Add or remove network interfaces from a network namespace\n", exe)
+ fmt.Fprintf(os.Stderr, " %s %s <net> <netns>\n", exe, CmdAdd)
+ fmt.Fprintf(os.Stderr, " %s %s <net> <netns>\n", exe, CmdDel)
+ os.Exit(1)
+}
+
+func exit(err error) {
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "%s\n", err)
+ os.Exit(1)
+ }
+ os.Exit(0)
+}
--- /dev/null
+// Copyright 2015 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package libcni
+
+import (
+ "strings"
+
+ "github.com/appc/cni/pkg/invoke"
+ "github.com/appc/cni/pkg/types"
+)
+
+type RuntimeConf struct {
+ ContainerID string
+ NetNS string
+ IfName string
+ Args [][2]string
+}
+
+type NetworkConfig struct {
+ Network *types.NetConf
+ Bytes []byte
+}
+
+type CNI interface {
+ AddNetwork(net *NetworkConfig, rt *RuntimeConf) (*types.Result, error)
+ DelNetwork(net *NetworkConfig, rt *RuntimeConf) error
+}
+
+type CNIConfig struct {
+ Path []string
+}
+
+func (c *CNIConfig) AddNetwork(net *NetworkConfig, rt *RuntimeConf) (*types.Result, error) {
+ return c.execPlugin("ADD", net, rt)
+}
+
+func (c *CNIConfig) DelNetwork(net *NetworkConfig, rt *RuntimeConf) error {
+ _, err := c.execPlugin("DEL", net, rt)
+ return err
+}
+
+// =====
+
+func (c *CNIConfig) execPlugin(action string, conf *NetworkConfig, rt *RuntimeConf) (*types.Result, error) {
+ pluginPath := invoke.FindInPath(conf.Network.Type, c.Path)
+
+ args := &invoke.Args{
+ Command: action,
+ ContainerID: rt.ContainerID,
+ NetNS: rt.NetNS,
+ PluginArgs: rt.Args,
+ IfName: rt.IfName,
+ Path: strings.Join(c.Path, ":"),
+ }
+ return invoke.ExecPlugin(pluginPath, conf.Bytes, args)
+}
--- /dev/null
+// Copyright 2015 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package libcni
+
+import (
+ "encoding/json"
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "sort"
+)
+
+func ConfFromBytes(bytes []byte) (*NetworkConfig, error) {
+ conf := &NetworkConfig{Bytes: bytes}
+ if err := json.Unmarshal(bytes, &conf.Network); err != nil {
+ return nil, fmt.Errorf("error parsing configuration: %s", err)
+ }
+ return conf, nil
+}
+
+func ConfFromFile(filename string) (*NetworkConfig, error) {
+ bytes, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return nil, fmt.Errorf("error reading %s: %s", filename, err)
+ }
+ return ConfFromBytes(bytes)
+}
+
+func ConfFiles(dir string) ([]string, error) {
+ // In part, adapted from rkt/networking/podenv.go#listFiles
+ files, err := ioutil.ReadDir(dir)
+ switch {
+ case err == nil: // break
+ case os.IsNotExist(err):
+ return nil, nil
+ default:
+ return nil, err
+ }
+
+ confFiles := []string{}
+ for _, f := range files {
+ if f.IsDir() {
+ continue
+ }
+ if filepath.Ext(f.Name()) == ".conf" {
+ confFiles = append(confFiles, filepath.Join(dir, f.Name()))
+ }
+ }
+ return confFiles, nil
+}
+
+func LoadConf(dir, name string) (*NetworkConfig, error) {
+ files, err := ConfFiles(dir)
+ switch {
+ case err != nil:
+ return nil, err
+ case len(files) == 0:
+ return nil, fmt.Errorf("no net configurations found")
+ }
+ sort.Strings(files)
+
+ for _, confFile := range files {
+ conf, err := ConfFromFile(confFile)
+ if err != nil {
+ return nil, err
+ }
+ if conf.Network.Name == name {
+ return conf, nil
+ }
+ }
+ return nil, fmt.Errorf(`no net configuration with name "%s" in %s`, name, dir)
+}
--- /dev/null
+// Copyright 2015 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package invoke
+
+import (
+ "os"
+ "strings"
+)
+
+type CNIArgs interface {
+ // For use with os/exec; i.e., return nil to inherit the
+ // environment from this process
+ AsEnv() []string
+}
+
+type inherited struct{}
+
+var inheritArgsFromEnv inherited
+
+func (_ *inherited) AsEnv() []string {
+ return nil
+}
+
+func ArgsFromEnv() CNIArgs {
+ return &inheritArgsFromEnv
+}
+
+type Args struct {
+ Command string
+ ContainerID string
+ NetNS string
+ PluginArgs [][2]string
+ PluginArgsStr string
+ IfName string
+ Path string
+}
+
+func (args *Args) AsEnv() []string {
+ env := os.Environ()
+ pluginArgsStr := args.PluginArgsStr
+ if pluginArgsStr == "" {
+ pluginArgsStr = stringify(args.PluginArgs)
+ }
+
+ env = append(env,
+ "CNI_COMMAND="+args.Command,
+ "CNI_CONTAINERID="+args.ContainerID,
+ "CNI_NETNS="+args.NetNS,
+ "CNI_ARGS="+pluginArgsStr,
+ "CNI_IFNAME="+args.IfName,
+ "CNI_PATH="+args.Path)
+ return env
+}
+
+// taken from rkt/networking/net_plugin.go
+func stringify(pluginArgs [][2]string) string {
+ entries := make([]string, len(pluginArgs))
+
+ for i, kv := range pluginArgs {
+ entries[i] = strings.Join(kv[:], "=")
+ }
+
+ return strings.Join(entries, ";")
+}
--- /dev/null
+// Copyright 2015 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package invoke
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "os"
+ "os/exec"
+ "path/filepath"
+
+ "github.com/appc/cni/pkg/types"
+)
+
+func pluginErr(err error, output []byte) error {
+ if _, ok := err.(*exec.ExitError); ok {
+ emsg := types.Error{}
+ if perr := json.Unmarshal(output, &emsg); perr != nil {
+ return fmt.Errorf("netplugin failed but error parsing its diagnostic message %q: %v", string(output), perr)
+ }
+ details := ""
+ if emsg.Details != "" {
+ details = fmt.Sprintf("; %v", emsg.Details)
+ }
+ return fmt.Errorf("%v%v", emsg.Msg, details)
+ }
+
+ return err
+}
+
+func ExecPlugin(pluginPath string, netconf []byte, args CNIArgs) (*types.Result, error) {
+ if pluginPath == "" {
+ return nil, fmt.Errorf("could not find %q plugin", filepath.Base(pluginPath))
+ }
+
+ stdout := &bytes.Buffer{}
+
+ c := exec.Cmd{
+ Env: args.AsEnv(),
+ Path: pluginPath,
+ Args: []string{pluginPath},
+ Stdin: bytes.NewBuffer(netconf),
+ Stdout: stdout,
+ Stderr: os.Stderr,
+ }
+ if err := c.Run(); err != nil {
+ return nil, pluginErr(err, stdout.Bytes())
+ }
+
+ res := &types.Result{}
+ err := json.Unmarshal(stdout.Bytes(), res)
+ return res, err
+}
--- /dev/null
+// Copyright 2015 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package invoke
+
+import (
+ "os"
+ "path/filepath"
+ "strings"
+)
+
+func FindInPath(plugin string, path []string) string {
+ for _, p := range path {
+ fullname := filepath.Join(p, plugin)
+ if fi, err := os.Stat(fullname); err == nil && fi.Mode().IsRegular() {
+ return fullname
+ }
+ }
+ return ""
+}
+
+// Find returns the full path of the plugin by searching in CNI_PATH
+func Find(plugin string) string {
+ paths := strings.Split(os.Getenv("CNI_PATH"), ":")
+ return FindInPath(plugin, paths)
+}
package ip
import (
- "encoding/json"
"math/big"
"net"
)
-// ParseCIDR takes a string like "10.2.3.1/24" and
-// return IPNet with "10.2.3.1" and /24 mask
-func ParseCIDR(s string) (*net.IPNet, error) {
- ip, ipn, err := net.ParseCIDR(s)
- if err != nil {
- return nil, err
- }
-
- ipn.IP = ip
- return ipn, nil
-}
-
// NextIP returns IP incremented by 1
func NextIP(ip net.IP) net.IP {
i := ipToInt(ip)
Mask: ipn.Mask,
}
}
-
-// like net.IPNet but adds JSON marshalling and unmarshalling
-type IPNet net.IPNet
-
-func (n IPNet) MarshalJSON() ([]byte, error) {
- return json.Marshal((*net.IPNet)(&n).String())
-}
-
-func (n *IPNet) UnmarshalJSON(data []byte) error {
- var s string
- if err := json.Unmarshal(data, &s); err != nil {
- return err
- }
-
- tmp, err := ParseCIDR(s)
- if err != nil {
- return err
- }
-
- *n = IPNet(*tmp)
- return nil
-}
--- /dev/null
+// Copyright 2015 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ipam
+
+import (
+ "fmt"
+ "os"
+
+ "github.com/appc/cni/pkg/invoke"
+ "github.com/appc/cni/pkg/ip"
+ "github.com/appc/cni/pkg/types"
+
+ "github.com/vishvananda/netlink"
+)
+
+func ExecAdd(plugin string, netconf []byte) (*types.Result, error) {
+ if os.Getenv("CNI_COMMAND") != "ADD" {
+ return nil, fmt.Errorf("CNI_COMMAND is not ADD")
+ }
+ return invoke.ExecPlugin(invoke.Find(plugin), netconf, invoke.ArgsFromEnv())
+}
+
+func ExecDel(plugin string, netconf []byte) error {
+ if os.Getenv("CNI_COMMAND") != "DEL" {
+ return fmt.Errorf("CNI_COMMAND is not DEL")
+ }
+ _, err := invoke.ExecPlugin(invoke.Find(plugin), netconf, invoke.ArgsFromEnv())
+ return err
+}
+
+// ConfigureIface takes the result of IPAM plugin and
+// applies to the ifName interface
+func ConfigureIface(ifName string, res *types.Result) error {
+ link, err := netlink.LinkByName(ifName)
+ if err != nil {
+ return fmt.Errorf("failed to lookup %q: %v", ifName, err)
+ }
+
+ if err := netlink.LinkSetUp(link); err != nil {
+ return fmt.Errorf("failed to set %q UP: %v", ifName, err)
+ }
+
+ // TODO(eyakubovich): IPv6
+ addr := &netlink.Addr{IPNet: &res.IP4.IP, Label: ""}
+ if err = netlink.AddrAdd(link, addr); err != nil {
+ return fmt.Errorf("failed to add IP addr to %q: %v", ifName, err)
+ }
+
+ for _, r := range res.IP4.Routes {
+ gw := r.GW
+ if gw == nil {
+ gw = res.IP4.Gateway
+ }
+ if err = ip.AddRoute(&r.Dst, gw, link); err != nil {
+ // we skip over duplicate routes as we assume the first one wins
+ if !os.IsExist(err) {
+ return fmt.Errorf("failed to add route '%v via %v dev %v': %v", r.Dst, gw, ifName, err)
+ }
+ }
+ }
+
+ return nil
+}
+++ /dev/null
-// Copyright 2015 CoreOS, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package plugin
-
-import (
- "bytes"
- "encoding/json"
- "fmt"
- "os"
- "os/exec"
- "path/filepath"
- "strings"
-
- "github.com/appc/cni/pkg/ip"
- "github.com/vishvananda/netlink"
-)
-
-// Find returns the full path of the plugin by searching in CNI_PATH
-func Find(plugin string) string {
- paths := strings.Split(os.Getenv("CNI_PATH"), ":")
-
- for _, p := range paths {
- fullname := filepath.Join(p, plugin)
- if fi, err := os.Stat(fullname); err == nil && fi.Mode().IsRegular() {
- return fullname
- }
- }
-
- return ""
-}
-
-func pluginErr(err error, output []byte) error {
- if _, ok := err.(*exec.ExitError); ok {
- emsg := Error{}
- if perr := json.Unmarshal(output, &emsg); perr != nil {
- return fmt.Errorf("netplugin failed but error parsing its diagnostic message %q: %v", string(output), perr)
- }
- details := ""
- if emsg.Details != "" {
- details = fmt.Sprintf("; %v", emsg.Details)
- }
- return fmt.Errorf("%v%v", emsg.Msg, details)
- }
-
- return err
-}
-
-// ExecAdd executes IPAM plugin, assuming CNI_COMMAND == ADD.
-// Parses and returns resulting IPConfig
-func ExecAdd(plugin string, netconf []byte) (*Result, error) {
- if os.Getenv("CNI_COMMAND") != "ADD" {
- return nil, fmt.Errorf("CNI_COMMAND is not ADD")
- }
- if plugin == "" {
- return nil, fmt.Errorf(`name of IPAM plugin is missing. Please specify a "type" field in the "ipam" section`)
- }
-
- pluginPath := Find(plugin)
- if pluginPath == "" {
- return nil, fmt.Errorf("could not find %q IPAM plugin", plugin)
- }
-
- stdout := &bytes.Buffer{}
-
- c := exec.Cmd{
- Path: pluginPath,
- Args: []string{pluginPath},
- Stdin: bytes.NewBuffer(netconf),
- Stdout: stdout,
- Stderr: os.Stderr,
- }
- if err := c.Run(); err != nil {
- return nil, pluginErr(err, stdout.Bytes())
- }
-
- res := &Result{}
- err := json.Unmarshal(stdout.Bytes(), res)
- return res, err
-}
-
-// ExecDel executes IPAM plugin, assuming CNI_COMMAND == DEL.
-func ExecDel(plugin string, netconf []byte) error {
- if os.Getenv("CNI_COMMAND") != "DEL" {
- return fmt.Errorf("CNI_COMMAND is not DEL")
- }
-
- pluginPath := Find(plugin)
- if pluginPath == "" {
- return fmt.Errorf("could not find %q plugin", plugin)
- }
-
- stdout := &bytes.Buffer{}
-
- c := exec.Cmd{
- Path: pluginPath,
- Args: []string{pluginPath},
- Stdin: bytes.NewBuffer(netconf),
- Stdout: stdout,
- Stderr: os.Stderr,
- }
- if err := c.Run(); err != nil {
- return pluginErr(err, stdout.Bytes())
- }
- return nil
-}
-
-// ConfigureIface takes the result of IPAM plugin and
-// applies to the ifName interface
-func ConfigureIface(ifName string, res *Result) error {
- link, err := netlink.LinkByName(ifName)
- if err != nil {
- return fmt.Errorf("failed to lookup %q: %v", ifName, err)
- }
-
- if err := netlink.LinkSetUp(link); err != nil {
- return fmt.Errorf("failed to set %q UP: %v", ifName, err)
- }
-
- // TODO(eyakubovich): IPv6
- addr := &netlink.Addr{IPNet: &res.IP4.IP, Label: ""}
- if err = netlink.AddrAdd(link, addr); err != nil {
- return fmt.Errorf("failed to add IP addr to %q: %v", ifName, err)
- }
-
- for _, r := range res.IP4.Routes {
- gw := r.GW
- if gw == nil {
- gw = res.IP4.Gateway
- }
- if err = ip.AddRoute(&r.Dst, gw, link); err != nil {
- // we skip over duplicate routes as we assume the first one wins
- if !os.IsExist(err) {
- return fmt.Errorf("failed to add route '%v via %v dev %v': %v", r.Dst, gw, ifName, err)
- }
- }
- }
-
- return nil
-}
"log"
"os"
- "github.com/appc/cni/pkg/plugin"
+ "github.com/appc/cni/pkg/types"
)
// CmdArgs captures all the arguments passed in to the plugin
}
if err != nil {
- if e, ok := err.(*plugin.Error); ok {
+ if e, ok := err.(*types.Error); ok {
// don't wrap Error in Error
dieErr(e)
}
}
func dieMsg(f string, args ...interface{}) {
- e := &plugin.Error{
+ e := &types.Error{
Code: 100,
Msg: fmt.Sprintf(f, args...),
}
dieErr(e)
}
-func dieErr(e *plugin.Error) {
+func dieErr(e *types.Error) {
if err := e.Print(); err != nil {
log.Print("Error writing error JSON to stdout: ", err)
}
-package plugin
+// Copyright 2015 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
import (
"encoding"
// See the License for the specific language governing permissions and
// limitations under the License.
-package plugin
+package types
import (
"encoding/json"
"net"
"os"
-
- "github.com/appc/cni/pkg/ip"
)
+// like net.IPNet but adds JSON marshalling and unmarshalling
+type IPNet net.IPNet
+
+// ParseCIDR takes a string like "10.2.3.1/24" and
+// return IPNet with "10.2.3.1" and /24 mask
+func ParseCIDR(s string) (*net.IPNet, error) {
+ ip, ipn, err := net.ParseCIDR(s)
+ if err != nil {
+ return nil, err
+ }
+
+ ipn.IP = ip
+ return ipn, nil
+}
+
+func (n IPNet) MarshalJSON() ([]byte, error) {
+ return json.Marshal((*net.IPNet)(&n).String())
+}
+
+func (n *IPNet) UnmarshalJSON(data []byte) error {
+ var s string
+ if err := json.Unmarshal(data, &s); err != nil {
+ return err
+ }
+
+ tmp, err := ParseCIDR(s)
+ if err != nil {
+ return err
+ }
+
+ *n = IPNet(*tmp)
+ return nil
+}
+
// NetConf describes a network.
type NetConf struct {
Name string `json:"name,omitempty"`
}
// net.IPNet is not JSON (un)marshallable so this duality is needed
-// for our custom ip.IPNet type
+// for our custom IPNet type
// JSON (un)marshallable types
type ipConfig struct {
- IP ip.IPNet `json:"ip"`
- Gateway net.IP `json:"gateway,omitempty"`
- Routes []Route `json:"routes,omitempty"`
+ IP IPNet `json:"ip"`
+ Gateway net.IP `json:"gateway,omitempty"`
+ Routes []Route `json:"routes,omitempty"`
}
type route struct {
- Dst ip.IPNet `json:"dst"`
- GW net.IP `json:"gw,omitempty"`
+ Dst IPNet `json:"dst"`
+ GW net.IP `json:"gw,omitempty"`
}
func (c *IPConfig) MarshalJSON() ([]byte, error) {
ipc := ipConfig{
- IP: ip.IPNet(c.IP),
+ IP: IPNet(c.IP),
Gateway: c.Gateway,
Routes: c.Routes,
}
func (r *Route) MarshalJSON() ([]byte, error) {
rt := route{
- Dst: ip.IPNet(r.Dst),
+ Dst: IPNet(r.Dst),
GW: r.GW,
}
"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"
)
// 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)
}
d.setLease(args.ContainerID, conf.Name, l)
- result.IP4 = &plugin.IPConfig{
+ result.IP4 = &types.IPConfig{
IP: *ipn,
Gateway: l.Gateway(),
Routes: l.Routes(),
// 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)
}
"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
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)...)
}
"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"
}
func cmdAdd(args *skel.CmdArgs) error {
- result := plugin.Result{}
+ result := types.Result{}
if err := rpcCall("DHCP.Allocate", args, &result); err != nil {
return err
}
"net"
"time"
- "github.com/appc/cni/pkg/plugin"
+ "github.com/appc/cni/pkg/types"
"github.com/d2g/dhcp4"
)
}
}
-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,
}
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])
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),
"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),
"net"
"github.com/appc/cni/pkg/ip"
- "github.com/appc/cni/pkg/plugin"
+ "github.com/appc/cni/pkg/types"
"github.com/appc/cni/plugins/ipam/host-local/backend"
)
}
// Returns newly allocated IP along with its config
-func (a *IPAllocator) Get(id string) (*plugin.IPConfig, error) {
+func (a *IPAllocator) Get(id string) (*types.IPConfig, error) {
a.store.Lock()
defer a.store.Unlock()
}
if reserved {
- return &plugin.IPConfig{
+ return &types.IPConfig{
IP: net.IPNet{requestedIP, a.conf.Subnet.Mask},
Gateway: gw,
Routes: a.conf.Routes,
return nil, err
}
if reserved {
- return &plugin.IPConfig{
+ return &types.IPConfig{
IP: net.IPNet{cur, a.conf.Subnet.Mask},
Gateway: gw,
Routes: a.conf.Routes,
// Allocates both an IP and the Gateway IP, i.e. a /31
// This is used for Point-to-Point links
-func (a *IPAllocator) GetPtP(id string) (*plugin.IPConfig, error) {
+func (a *IPAllocator) GetPtP(id string) (*types.IPConfig, error) {
a.store.Lock()
defer a.store.Unlock()
_, bits := a.conf.Subnet.Mask.Size()
mask := net.CIDRMask(bits-1, bits)
- return &plugin.IPConfig{
+ return &types.IPConfig{
IP: net.IPNet{cur, mask},
Gateway: gw,
Routes: a.conf.Routes,
"fmt"
"net"
- "github.com/appc/cni/pkg/ip"
- "github.com/appc/cni/pkg/plugin"
+ "github.com/appc/cni/pkg/types"
)
// IPAMConfig represents the IP related network configuration.
type IPAMConfig struct {
Name string
- Type string `json:"type"`
- RangeStart net.IP `json:"rangeStart"`
- RangeEnd net.IP `json:"rangeEnd"`
- Subnet ip.IPNet `json:"subnet"`
- Gateway net.IP `json:"gateway"`
- Routes []plugin.Route `json:"routes"`
- Args *IPAMArgs `json:"-"`
+ Type string `json:"type"`
+ RangeStart net.IP `json:"rangeStart"`
+ RangeEnd net.IP `json:"rangeEnd"`
+ Subnet types.IPNet `json:"subnet"`
+ Gateway net.IP `json:"gateway"`
+ Routes []types.Route `json:"routes"`
+ Args *IPAMArgs `json:"-"`
}
type IPAMArgs struct {
if args != "" {
ipamArgs := IPAMArgs{}
- err := plugin.LoadArgs(args, &ipamArgs)
+ err := types.LoadArgs(args, &ipamArgs)
if err != nil {
return nil, err
}
"github.com/appc/cni/plugins/ipam/host-local/backend/disk"
- "github.com/appc/cni/pkg/plugin"
"github.com/appc/cni/pkg/skel"
+ "github.com/appc/cni/pkg/types"
)
func main() {
defer store.Close()
ipamArgs := IPAMArgs{}
- err = plugin.LoadArgs(args.Args, &ipamArgs)
+ err = types.LoadArgs(args.Args, &ipamArgs)
if err != nil {
return err
}
return err
}
- var ipConf *plugin.IPConfig
+ var ipConf *types.IPConfig
switch ipamConf.Type {
case "host-local":
return err
}
- r := &plugin.Result{
+ r := &types.Result{
IP4: ipConf,
}
return r.Print()
"syscall"
"github.com/appc/cni/pkg/ip"
+ "github.com/appc/cni/pkg/ipam"
"github.com/appc/cni/pkg/ns"
- "github.com/appc/cni/pkg/plugin"
"github.com/appc/cni/pkg/skel"
+ "github.com/appc/cni/pkg/types"
"github.com/vishvananda/netlink"
)
const defaultBrName = "cni0"
type NetConf struct {
- plugin.NetConf
+ types.NetConf
BrName string `json:"bridge"`
IsGW bool `json:"isGateway"`
IPMasq bool `json:"ipMasq"`
}
// run the IPAM plugin and get back the config to apply
- result, err := plugin.ExecAdd(n.IPAM.Type, args.StdinData)
+ result, err := ipam.ExecAdd(n.IPAM.Type, args.StdinData)
if err != nil {
return err
}
}
err = ns.WithNetNSPath(args.Netns, false, func(hostNS *os.File) error {
- return plugin.ConfigureIface(args.IfName, result)
+ return ipam.ConfigureIface(args.IfName, result)
})
if err != nil {
return err
return err
}
- err = plugin.ExecDel(n.IPAM.Type, args.StdinData)
+ err = ipam.ExecDel(n.IPAM.Type, args.StdinData)
if err != nil {
return err
}
"runtime"
"github.com/appc/cni/pkg/ip"
+ "github.com/appc/cni/pkg/ipam"
"github.com/appc/cni/pkg/ns"
- "github.com/appc/cni/pkg/plugin"
"github.com/appc/cni/pkg/skel"
+ "github.com/appc/cni/pkg/types"
"github.com/vishvananda/netlink"
)
type NetConf struct {
- plugin.NetConf
+ types.NetConf
Master string `json:"master"`
Mode string `json:"mode"`
MTU int `json:"mtu"`
}
// run the IPAM plugin and get back the config to apply
- result, err := plugin.ExecAdd(n.IPAM.Type, args.StdinData)
+ result, err := ipam.ExecAdd(n.IPAM.Type, args.StdinData)
if err != nil {
return err
}
}
err = ns.WithNetNS(netns, false, func(_ *os.File) error {
- return plugin.ConfigureIface(args.IfName, result)
+ return ipam.ConfigureIface(args.IfName, result)
})
if err != nil {
return err
return err
}
- err = plugin.ExecDel(n.IPAM.Type, args.StdinData)
+ err = ipam.ExecDel(n.IPAM.Type, args.StdinData)
if err != nil {
return err
}
"runtime"
"github.com/appc/cni/pkg/ip"
+ "github.com/appc/cni/pkg/ipam"
"github.com/appc/cni/pkg/ns"
- "github.com/appc/cni/pkg/plugin"
"github.com/appc/cni/pkg/skel"
+ "github.com/appc/cni/pkg/types"
"github.com/vishvananda/netlink"
)
type NetConf struct {
- plugin.NetConf
+ types.NetConf
Master string `json:"master"`
Mode string `json:"mode"`
MTU int `json:"mtu"`
}
// run the IPAM plugin and get back the config to apply
- result, err := plugin.ExecAdd(n.IPAM.Type, args.StdinData)
+ result, err := ipam.ExecAdd(n.IPAM.Type, args.StdinData)
if err != nil {
return err
}
}
err = ns.WithNetNS(netns, false, func(_ *os.File) error {
- return plugin.ConfigureIface(args.IfName, result)
+ return ipam.ConfigureIface(args.IfName, result)
})
if err != nil {
return err
return err
}
- err = plugin.ExecDel(n.IPAM.Type, args.StdinData)
+ err = ipam.ExecDel(n.IPAM.Type, args.StdinData)
if err != nil {
return err
}
"github.com/vishvananda/netlink"
"github.com/appc/cni/pkg/ip"
+ "github.com/appc/cni/pkg/ipam"
"github.com/appc/cni/pkg/ns"
- "github.com/appc/cni/pkg/plugin"
"github.com/appc/cni/pkg/skel"
+ "github.com/appc/cni/pkg/types"
)
func init() {
}
type NetConf struct {
- plugin.NetConf
+ types.NetConf
IPMasq bool `json:"ipMasq"`
MTU int `json:"mtu"`
}
-func setupContainerVeth(netns, ifName string, mtu int, pr *plugin.Result) (string, error) {
+func setupContainerVeth(netns, ifName string, mtu int, pr *types.Result) (string, error) {
var hostVethName string
err := ns.WithNetNSPath(netns, false, func(hostNS *os.File) error {
hostVeth, _, err := ip.SetupVeth(ifName, mtu, hostNS)
return err
}
- err = plugin.ConfigureIface(ifName, pr)
+ err = ipam.ConfigureIface(ifName, pr)
if err != nil {
return err
}
return hostVethName, err
}
-func setupHostVeth(vethName string, ipConf *plugin.IPConfig) error {
+func setupHostVeth(vethName string, ipConf *types.IPConfig) error {
// hostVeth moved namespaces and may have a new ifindex
veth, err := netlink.LinkByName(vethName)
if err != nil {
}
// run the IPAM plugin and get back the config to apply
- result, err := plugin.ExecAdd(conf.IPAM.Type, args.StdinData)
+ result, err := ipam.ExecAdd(conf.IPAM.Type, args.StdinData)
if err != nil {
return err
}
}
}
- return plugin.ExecDel(conf.IPAM.Type, args.StdinData)
+ return ipam.ExecDel(conf.IPAM.Type, args.StdinData)
}
func main() {
"strconv"
"strings"
- "github.com/appc/cni/pkg/plugin"
+ "github.com/appc/cni/pkg/ipam"
"github.com/appc/cni/pkg/skel"
+ "github.com/appc/cni/pkg/types"
)
const (
)
type NetConf struct {
- plugin.NetConf
+ types.NetConf
SubnetFile string `json:"subnetFile"`
Delegate map[string]interface{} `json:"delegate"`
}
return err
}
- result, err := plugin.ExecAdd(netconf["type"].(string), netconfBytes)
+ result, err := ipam.ExecAdd(netconf["type"].(string), netconfBytes)
if err != nil {
return err
}
n.Delegate["ipam"] = map[string]interface{}{
"type": "host-local",
"subnet": fenv.sn.String(),
- "routes": []plugin.Route{
- plugin.Route{
+ "routes": []types.Route{
+ types.Route{
Dst: *fenv.nw,
},
},
return err
}
- n := &plugin.NetConf{}
+ n := &types.NetConf{}
if err = json.Unmarshal(netconfBytes, n); err != nil {
return fmt.Errorf("failed to parse netconf: %v", err)
}
- return plugin.ExecDel(n.Type, netconfBytes)
+ return ipam.ExecDel(n.Type, netconfBytes)
}
func main() {
source ./build
TESTABLE="plugins/ipam/dhcp"
-FORMATTABLE="$TESTABLE pkg/ip pkg/ns pkg/plugin pkg/skel plugins/ipam/host-local plugins/main/bridge plugins/meta/flannel"
+FORMATTABLE="$TESTABLE libcni pkg/ip pkg/ns pkg/invoke pkg/types pkg/ipam pkg/skel plugins/ipam/host-local plugins/main/bridge plugins/meta/flannel"
# user has not provided PKG override
if [ -z "$PKG" ]; then
git://git.halfball.org / cni.git / commitdiff