func inspectAll(ctx context.Context, dockerCli *client.DockerCli, getSize bool) inspect.GetRefFunc {
client := dockerCli.Client()
return func(ref string) (interface{}, []byte, error) {
c, rawContainer, err := client.ContainerInspectWithRaw(ctx, ref, getSize)
if err == nil || !apiclient.IsErrNotFound(err) {
return c, rawContainer, err
}
// Search for image with that id if a container doesn't exist.
i, rawImage, err := client.ImageInspectWithRaw(ctx, ref)
if err == nil || !apiclient.IsErrNotFound(err) {
return i, rawImage, err
}
// Search for task with that id if an image doesn't exist.
t, rawTask, err := client.TaskInspectWithRaw(ctx, ref)
if err == nil || !(apiclient.IsErrNotFound(err) || isErrorNoSwarmMode(err)) {
if getSize {
fmt.Fprintln(dockerCli.Err(), "WARNING: --size ignored for tasks")
}
return t, rawTask, err
}
return nil, nil, fmt.Errorf("Error: No such container, image or task: %s", ref)
}
}
func (l *LocalCluster) createNetwork() {
l.panicOnStop()
net, err := l.client.NetworkInspect(context.Background(), 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(context.Background(), containerID, "9"))
}
maybePanic(l.client.NetworkRemove(context.Background(), networkName))
} else if !client.IsErrNotFound(err) {
panic(err)
}
resp, err := l.client.NetworkCreate(context.Background(), 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("creating network: %s", resp.Warning)
}
l.networkID = resp.ID
}
func inspectAll(ctx context.Context, dockerCli *client.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", true, 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)},
}
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 !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)
}
}