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