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`))) })