func getDefaultCNINetwork(pluginDir, binDir, vendorCNIDirPrefix string) (*cniNetwork, error) {
if pluginDir == "" {
pluginDir = DefaultNetDir
}
files, err := libcni.ConfFiles(pluginDir)
switch {
case err != nil:
return nil, err
case len(files) == 0:
return nil, fmt.Errorf("No networks found in %s", pluginDir)
}
sort.Strings(files)
for _, confFile := range files {
conf, err := libcni.ConfFromFile(confFile)
if err != nil {
glog.Warningf("Error loading CNI config file %s: %v", confFile, err)
continue
}
// Search for vendor-specific plugins as well as default plugins in the CNI codebase.
vendorDir := vendorCNIDir(vendorCNIDirPrefix, conf.Network.Type)
cninet := &libcni.CNIConfig{
Path: []string{binDir, vendorDir},
}
network := &cniNetwork{name: conf.Network.Name, NetworkConfig: conf, CNIConfig: cninet}
return network, nil
}
return nil, fmt.Errorf("No valid networks found in %s", pluginDir)
}
func (c *CNIController) ensureInitialized() error {
if c.cniConfig == nil {
c.cniConfig = &libcni.CNIConfig{Path: []string{c.PluginDir}}
}
if c.networkConfigs == nil {
c.networkConfigs = []*libcni.NetworkConfig{}
err := filepath.Walk(c.ConfigDir, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info.IsDir() {
return nil
}
if !strings.HasSuffix(path, ".conf") {
return nil
}
conf, err := libcni.ConfFromFile(path)
if err != nil {
return fmt.Errorf("unable to load config from %s: %s", path, err)
}
c.networkConfigs = append(c.networkConfigs, conf)
log.Printf("loaded config %+v\n%s\n", conf.Network, string(conf.Bytes))
return nil
})
if err != nil {
return fmt.Errorf("error loading config: %s", err)
}
}
return nil
}
func NewCNIExec(state *DockerPluginState) (*CNIExec, error) {
if state.HostConfig.NetworkMode.IsContainer() ||
state.HostConfig.NetworkMode.IsHost() ||
state.HostConfig.NetworkMode.IsNone() {
return &CNIExec{}, nil
}
c := &CNIExec{
runtimeConf: libcni.RuntimeConf{
ContainerID: state.ContainerID,
NetNS: fmt.Sprintf("/proc/%d/ns/net", state.State.Pid),
IfName: "eth0",
Args: [][2]string{
{"IgnoreUnknown", "1"},
{"DOCKER", "true"},
},
},
cninet: libcni.CNIConfig{
Path: cniPath,
},
}
dir := fmt.Sprintf(cniDir, state.HostConfig.NetworkMode.NetworkName())
files, err := libcni.ConfFiles(dir)
if err != nil {
return nil, err
}
sort.Strings(files)
os.Setenv("PATH", strings.Join(cniPath, ":"))
for _, file := range files {
netConf, err := libcni.ConfFromFile(file)
if err != nil {
return nil, err
}
c.confs = append(c.confs, netConf)
}
return c, nil
}
pluginConfig = []byte(`{ "name": "deep", "some-key": "some-value" }`)
Expect(ioutil.WriteFile(filepath.Join(subdir, "90-deep.conf"), pluginConfig, 0600)).To(Succeed())
})
It("will not find the config", func() {
_, err := libcni.LoadConf(configDir, "deep")
Expect(err).To(MatchError(HavePrefix("no net configuration with name")))
})
})
})
Describe("ConfFromFile", func() {
Context("when the file cannot be opened", func() {
It("returns a useful error", func() {
_, err := libcni.ConfFromFile("/tmp/nope/not-here")
Expect(err).To(MatchError(HavePrefix(`error reading /tmp/nope/not-here: open /tmp/nope/not-here`)))
})
})
})
Describe("InjectConf", func() {
Context("when function parameters are incorrect", func() {
It("returns unmarshal error", func() {
conf := &libcni.NetworkConfig{Network: &types.NetConf{Name: "some-plugin"},
Bytes: []byte(`{ cc cc cc}`)}
_, err := libcni.InjectConf(conf, "", nil)
Expect(err).To(MatchError(HavePrefix(`unmarshal existing network bytes`)))
})