func (l *LocalCluster) createNetwork(ctx context.Context) { l.panicOnStop() l.networkName = fmt.Sprintf("%s-%s", networkPrefix, l.clusterID) log.Infof(ctx, "creating docker network with name: %s", l.networkName) net, err := l.client.NetworkInspect(ctx, l.networkName) if err == nil { // We need to destroy the network and any running containers inside of it. for containerID := range net.Containers { // This call could fail if the container terminated on its own after we call // NetworkInspect, but the likelihood of this seems low. If this line creates // a lot of panics we should do more careful error checking. maybePanic(l.client.ContainerKill(ctx, containerID, "9")) } maybePanic(l.client.NetworkRemove(ctx, l.networkName)) } else if !client.IsErrNotFound(err) { panic(err) } resp, err := l.client.NetworkCreate(ctx, l.networkName, types.NetworkCreate{ Driver: "bridge", // Docker gets very confused if two networks have the same name. CheckDuplicate: true, }) maybePanic(err) if resp.Warning != "" { log.Warningf(ctx, "creating network: %s", resp.Warning) } l.networkID = resp.ID }
func inspectAll(ctx context.Context, dockerCli *command.DockerCli, getSize bool, typeConstraint string) inspect.GetRefFunc { var inspectAutodetect = []struct { ObjectType string IsSizeSupported bool ObjectInspector func(string) (interface{}, []byte, error) }{ {"container", true, inspectContainers(ctx, dockerCli, getSize)}, {"image", false, inspectImages(ctx, dockerCli)}, {"network", false, inspectNetwork(ctx, dockerCli)}, {"volume", false, inspectVolume(ctx, dockerCli)}, {"service", false, inspectService(ctx, dockerCli)}, {"task", false, inspectTasks(ctx, dockerCli)}, {"node", false, inspectNode(ctx, dockerCli)}, {"plugin", false, inspectPlugin(ctx, dockerCli)}, } isErrNotSwarmManager := func(err error) bool { return strings.Contains(err.Error(), "This node is not a swarm manager") } return func(ref string) (interface{}, []byte, error) { for _, inspectData := range inspectAutodetect { if typeConstraint != "" && inspectData.ObjectType != typeConstraint { continue } v, raw, err := inspectData.ObjectInspector(ref) if err != nil { if typeConstraint == "" && (apiclient.IsErrNotFound(err) || isErrNotSwarmManager(err)) { continue } return v, raw, err } if getSize && !inspectData.IsSizeSupported { fmt.Fprintf(dockerCli.Err(), "WARNING: --size ignored for %s\n", inspectData.ObjectType) } return v, raw, err } return nil, nil, fmt.Errorf("Error: No such object: %s", ref) } }
func inspectAll(ctx context.Context, dockerCli *command.DockerCli, getSize bool, typeConstraint string) inspect.GetRefFunc { var inspectAutodetect = []struct { objectType string isSizeSupported bool isSwarmObject bool objectInspector func(string) (interface{}, []byte, error) }{ { objectType: "container", isSizeSupported: true, objectInspector: inspectContainers(ctx, dockerCli, getSize), }, { objectType: "image", objectInspector: inspectImages(ctx, dockerCli), }, { objectType: "network", objectInspector: inspectNetwork(ctx, dockerCli), }, { objectType: "volume", objectInspector: inspectVolume(ctx, dockerCli), }, { objectType: "service", isSwarmObject: true, objectInspector: inspectService(ctx, dockerCli), }, { objectType: "task", isSwarmObject: true, objectInspector: inspectTasks(ctx, dockerCli), }, { objectType: "node", isSwarmObject: true, objectInspector: inspectNode(ctx, dockerCli), }, { objectType: "plugin", objectInspector: inspectPlugin(ctx, dockerCli), }, } // isSwarmManager does an Info API call to verify that the daemon is // a swarm manager. isSwarmManager := func() bool { info, err := dockerCli.Client().Info(ctx) if err != nil { fmt.Fprintln(dockerCli.Err(), err) return false } return info.Swarm.ControlAvailable } isErrNotSupported := func(err error) bool { return strings.Contains(err.Error(), "not supported") } return func(ref string) (interface{}, []byte, error) { const ( swarmSupportUnknown = iota swarmSupported swarmUnsupported ) isSwarmSupported := swarmSupportUnknown for _, inspectData := range inspectAutodetect { if typeConstraint != "" && inspectData.objectType != typeConstraint { continue } if typeConstraint == "" && inspectData.isSwarmObject { if isSwarmSupported == swarmSupportUnknown { if isSwarmManager() { isSwarmSupported = swarmSupported } else { isSwarmSupported = swarmUnsupported } } if isSwarmSupported == swarmUnsupported { continue } } v, raw, err := inspectData.objectInspector(ref) if err != nil { if typeConstraint == "" && (apiclient.IsErrNotFound(err) || isErrNotSupported(err)) { continue } return v, raw, err } if getSize && !inspectData.isSizeSupported { fmt.Fprintf(dockerCli.Err(), "WARNING: --size ignored for %s\n", inspectData.objectType) } return v, raw, err } return nil, nil, fmt.Errorf("Error: No such object: %s", ref) } }