Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

fix(ec2): detach Floci before deleting VPC networks (#5869)

Aniket Shukla5a4413d63a65
diff --git a/docs/services/ec2.md b/docs/services/ec2.md
index 5689890c3c..d78c76abb7 100644
--- a/docs/services/ec2.md
+++ b/docs/services/ec2.md
@@ -962,6 +962,11 @@ For overlapping VPC CIDRs, the first VPC whose addresses are needed keeps the de
later VPCs use the fallback pool. Within one emulator run, allocated addresses remain on the
same effective range.
+When Floci runs in Docker, deleting a VPC disconnects Floci's own container before removing
+the VPC network. Other endpoints are not forcibly disconnected: removal retries while they
+drain, up to five attempts two seconds apart. After successful removal, a new VPC can reuse
+the CIDR without colliding with a network left behind by that deletion.
+
When EC2 is enabled, Floci initializes its service, restores persisted state, and seeds the
configured region's default resources during startup. Other account and region scopes seed on
first access. Docker reconciliation can lengthen startup, and Docker-backed instance launches
diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/net/VpcNetworkManager.java b/src/main/java/io/github/hectorvent/floci/services/ec2/net/VpcNetworkManager.java
index 4d623be409..0292c5b8e2 100644
--- a/src/main/java/io/github/hectorvent/floci/services/ec2/net/VpcNetworkManager.java
+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/net/VpcNetworkManager.java
@@ -613,15 +613,19 @@ public class VpcNetworkManager {
if (vpc == null || !vpc.created) {
return;
}
+ disconnect(vpc.networkName, containerId);
+ }
+
+ private void disconnect(String networkId, String containerId) {
try {
dockerClient.disconnectFromNetworkCmd()
- .withNetworkId(vpc.networkName)
+ .withNetworkId(networkId)
.withContainerId(containerId)
.withForce(true)
.exec();
} catch (Exception e) {
LOG.debugv("Could not disconnect {0} from VPC network {1}: {2}",
- containerId, vpc.networkName, e.getMessage());
+ containerId, networkId, e.getMessage());
}
}
@@ -811,10 +815,17 @@ public class VpcNetworkManager {
if (!vpc.created) {
return;
}
- removeNetworkWithRetry(vpc.networkName, 1);
+ String flociContainerId = vpc.flociContainerId;
+ if (flociContainerId == null && currentContainerNetworkResolver != null) {
+ flociContainerId = currentContainerNetworkResolver.resolveContainerId().orElse(null);
+ }
+ removeNetworkWithRetry(vpc.networkName, flociContainerId, 1);
}
- private void removeNetworkWithRetry(String networkName, int attempt) {
+ private void removeNetworkWithRetry(String networkName, String flociContainerId, int attempt) {
+ if (flociContainerId != null) {
+ disconnect(networkName, flociContainerId);
+ }
try {
dockerClient.removeNetworkCmd(networkName).exec();
LOG.infov("Removed Docker network {0}", networkName);
@@ -823,7 +834,8 @@ public class VpcNetworkManager {
} catch (Exception e) {
// Containers terminated moments earlier still hold endpoints for a beat.
if (attempt < 5 && !retries.isShutdown()) {
- retries.schedule(() -> removeNetworkWithRetry(networkName, attempt + 1), 2, TimeUnit.SECONDS);
+ retries.schedule(() -> removeNetworkWithRetry(networkName, flociContainerId, attempt + 1),
+ 2, TimeUnit.SECONDS);
return;
}
LOG.warnv("Could not remove Docker network {0} after {1} attempts: {2}. It will be reconciled "
@@ -910,15 +922,7 @@ public class VpcNetworkManager {
return;
}
for (String containerId : containers.keySet()) {
- try {
- dockerClient.disconnectFromNetworkCmd()
- .withNetworkId(listed.getId())
- .withContainerId(containerId)
- .withForce(true)
- .exec();
- } catch (Exception e) {
- LOG.debugv("Could not disconnect {0} from {1}: {2}", containerId, listed.getName(), e.getMessage());
- }
+ disconnect(listed.getId(), containerId);
}
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/net/VpcNetworkManagerTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/net/VpcNetworkManagerTest.java
index b14d9d0395..0a9a1548c4 100644
--- a/src/test/java/io/github/hectorvent/floci/services/ec2/net/VpcNetworkManagerTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/net/VpcNetworkManagerTest.java
@@ -8,12 +8,15 @@ import com.github.dockerjava.api.command.DisconnectFromNetworkCmd;
import com.github.dockerjava.api.command.InspectNetworkCmd;
import com.github.dockerjava.api.command.ListNetworksCmd;
import com.github.dockerjava.api.command.RemoveNetworkCmd;
+import com.github.dockerjava.api.exception.ConflictException;
import com.github.dockerjava.api.exception.NotFoundException;
import com.github.dockerjava.api.model.Network;
import io.github.hectorvent.floci.config.EmulatorConfig;
import io.github.hectorvent.floci.core.common.docker.CurrentContainerNetworkResolver;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.ArgumentCaptor;
import java.util.ArrayList;
@@ -22,11 +25,13 @@ import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -37,6 +42,7 @@ import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.RETURNS_SELF;
+import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
@@ -477,6 +483,200 @@ class VpcNetworkManagerTest {
verify(connect).withContainerId("instance-1");
}
+ @Test
+ void deletingVpcDisconnectsFlociAndLetsTheNextVpcReuseItsDeclaredCidr() {
+ VpcNetworkManager dockerHostedManager = dockerHostedManager("floci-container");
+ NetworkLifecycle network = new NetworkLifecycle(dockerHostedManager, "floci-container");
+ try {
+ dockerHostedManager.declareVpc(REGION, "vpc-1", "10.0.0.0/16");
+ dockerHostedManager.declareSubnet(REGION, "vpc-1", "subnet-a", "10.0.1.0/24");
+ String address = dockerHostedManager.allocatePrivateIp(REGION, "subnet-a").orElseThrow();
+ assertTrue(dockerHostedManager.attach(REGION, "vpc-1", "subnet-a", "instance-1", address).isPresent());
+ dockerHostedManager.detach(REGION, "vpc-1", "instance-1");
+ dockerHostedManager.forgetSubnet(REGION, "subnet-a");
+
+ dockerHostedManager.deleteVpcNetwork(REGION, "vpc-1");
+ dockerHostedManager.declareVpc(REGION, "vpc-2", "10.0.0.0/16");
+ dockerHostedManager.declareSubnet(REGION, "vpc-2", "subnet-b", "10.0.1.0/24");
+
+ assertEquals(address, dockerHostedManager.allocatePrivateIp(REGION, "subnet-b").orElseThrow(),
+ "deleting the first VPC must release its Docker IPAM reservation");
+ assertTrue(existingNetworks.isEmpty());
+ assertTrue(network.endpoints.isEmpty());
+ } finally {
+ dockerHostedManager.shutdown();
+ }
+ }
+
+ @ParameterizedTest
+ @ValueSource(booleans = {false, true})
+ void deletingAdoptedVpcDisconnectsItsExistingFlociEndpoint(boolean shortContainerId) {
+ String fullContainerId = "0123456789abcdef".repeat(4);
+ String resolvedContainerId = shortContainerId ? fullContainerId.substring(0, 12) : fullContainerId;
+ VpcNetworkManager dockerHostedManager = dockerHostedManager(resolvedContainerId);
+ NetworkLifecycle network = new NetworkLifecycle(dockerHostedManager, fullContainerId);
+ network.endpoints.put(fullContainerId, mock(Network.ContainerNetworkConfig.class));
+ existingNetwork(network.name, "10.0.0.0/16", ourLabels("vpc-1", "4650"), network.endpoints);
+ try {
+ dockerHostedManager.declareVpc(REGION, "vpc-1", "10.0.0.0/16");
+ dockerHostedManager.declareSubnet(REGION, "vpc-1", "subnet-a", "10.0.1.0/24");
+ String address = dockerHostedManager.allocatePrivateIp(REGION, "subnet-a").orElseThrow();
+ assertTrue(dockerHostedManager.attach(REGION, "vpc-1", "subnet-a", "instance-1", address).isPresent());
+ dockerHostedManager.detach(REGION, "vpc-1", "instance-1");
+
+ dockerHostedManager.deleteVpcNetwork(REGION, "vpc-1");
+
+ assertTrue(existingNetworks.isEmpty(), "an adopted self endpoint must not keep the network alive");
+ assertTrue(network.endpoints.isEmpty());
+ } finally {
+ dockerHostedManager.shutdown();
+ }
+ }
+
+ @Test
+ void deletingVpcDisconnectsTheRecordedFlociEndpointAndLeavesOthersAttached() {
+ CurrentContainerNetworkResolver resolver = mock(CurrentContainerNetworkResolver.class);
+ when(resolver.resolveContainerId()).thenReturn(Optional.of("floci-container"));
+ VpcNetworkManager dockerHostedManager = new VpcNetworkManager(config, docker, resolver);
+ NetworkLifecycle network = new NetworkLifecycle(dockerHostedManager, "floci-container");
+ try {
+ dockerHostedManager.declareVpc(REGION, "vpc-1", "10.0.0.0/16");
+ dockerHostedManager.declareSubnet(REGION, "vpc-1", "subnet-a", "10.0.1.0/24");
+ String address = dockerHostedManager.allocatePrivateIp(REGION, "subnet-a").orElseThrow();
+ assertTrue(dockerHostedManager.attach(REGION, "vpc-1", "subnet-a", "instance-1", address).isPresent());
+ network.endpoints.put("foreign-container", mock(Network.ContainerNetworkConfig.class));
+ when(resolver.resolveContainerId()).thenReturn(Optional.of("foreign-container"));
+
+ dockerHostedManager.deleteVpcNetwork(REGION, "vpc-1");
+
+ assertEquals(Set.of("instance-1", "foreign-container"), network.endpoints.keySet(),
+ "normal teardown detaches only Floci, leaving other endpoints to drain");
+ assertEquals(1, existingNetworks.size(), "Docker must retain a network with live guest endpoints");
+ } finally {
+ dockerHostedManager.shutdown();
+ }
+ }
+
+ @ParameterizedTest
+ @ValueSource(booleans = {false, true})
+ void deletingVpcWithoutASelfEndpointNeedsNoDisconnect(boolean resolverAvailable) {
+ VpcNetworkManager hostManager = resolverAvailable
+ ? dockerHostedManager(null) : new VpcNetworkManager(config, docker);
+ NetworkLifecycle network = new NetworkLifecycle(hostManager, "floci-container");
+ try {
+ hostManager.declareVpc(REGION, "vpc-1", "10.0.0.0/16");
+ hostManager.declareSubnet(REGION, "vpc-1", "subnet-a", "10.0.1.0/24");
+ String address = hostManager.allocatePrivateIp(REGION, "subnet-a").orElseThrow();
+ assertTrue(hostManager.attach(REGION, "vpc-1", "subnet-a", "instance-1", address).isPresent());
+ network.endpoints.remove("instance-1");
+
+ hostManager.deleteVpcNetwork(REGION, "vpc-1");
+
+ assertTrue(existingNetworks.isEmpty());
+ verify(docker, never()).disconnectFromNetworkCmd();
+ } finally {
+ hostManager.shutdown();
+ }
+ }
+
+ @Test
+ void deletingVpcRetriesATransientFlociDisconnectFailure() throws Exception {
+ VpcNetworkManager dockerHostedManager = dockerHostedManager("floci-container");
+ NetworkLifecycle network = new NetworkLifecycle(dockerHostedManager, "floci-container");
+ try {
+ dockerHostedManager.declareVpc(REGION, "vpc-1", "10.0.0.0/16");
+ dockerHostedManager.declareSubnet(REGION, "vpc-1", "subnet-a", "10.0.1.0/24");
+ String address = dockerHostedManager.allocatePrivateIp(REGION, "subnet-a").orElseThrow();
+ assertTrue(dockerHostedManager.attach(REGION, "vpc-1", "subnet-a", "instance-1", address).isPresent());
+ dockerHostedManager.detach(REGION, "vpc-1", "instance-1");
+ network.failNextDisconnect.set(true);
+
+ dockerHostedManager.deleteVpcNetwork(REGION, "vpc-1");
+
+ assertTrue(network.removed.await(5, TimeUnit.SECONDS),
+ "teardown must retry disconnecting Floci before retrying network removal");
+ assertTrue(network.endpoints.isEmpty());
+ assertTrue(existingNetworks.isEmpty());
+ } finally {
+ dockerHostedManager.shutdown();
+ }
+ }
+
+ private VpcNetworkManager dockerHostedManager(String containerId) {
+ CurrentContainerNetworkResolver resolver = mock(CurrentContainerNetworkResolver.class);
+ when(resolver.resolveContainerId()).thenReturn(Optional.ofNullable(containerId));
+ return new VpcNetworkManager(config, docker, resolver);
+ }
+
+ private final class NetworkLifecycle {
+ final String name;
+ final Map<String, Network.ContainerNetworkConfig> endpoints = new ConcurrentHashMap<>();
+ final AtomicBoolean failNextDisconnect = new AtomicBoolean();
+ final CountDownLatch removed = new CountDownLatch(1);
+
+ NetworkLifecycle(VpcNetworkManager networkManager, String selfContainerId) {
+ name = networkManager.networkName(REGION, "vpc-1");
+ when(docker.createNetworkCmd().exec()).thenAnswer(call -> {
+ existingNetwork(name, "10.0.0.0/16", ourLabels("vpc-1", "4650"), endpoints);
+ return new CreateNetworkResponse();
+ });
+ when(docker.connectToNetworkCmd()).thenAnswer(call -> {
+ ConnectToNetworkCmd connect = mock(ConnectToNetworkCmd.class, RETURNS_SELF);
+ String[] containerId = new String[1];
+ when(connect.withContainerId(anyString())).thenAnswer(argument -> {
+ String requested = argument.getArgument(0);
+ containerId[0] = selfContainerId.startsWith(requested) ? selfContainerId : requested;
+ return connect;
+ });
+ when(connect.withNetworkId(anyString())).thenAnswer(argument -> {
+ assertEquals(name, argument.getArgument(0));
+ return connect;
+ });
+ doAnswer(execution -> {
+ if (endpoints.putIfAbsent(containerId[0], mock(Network.ContainerNetworkConfig.class)) != null) {
+ throw new ConflictException("container is already connected");
+ }
+ return null;
+ }).when(connect).exec();
+ return connect;
+ });
+ when(docker.disconnectFromNetworkCmd()).thenAnswer(call -> {
+ DisconnectFromNetworkCmd disconnect = mock(DisconnectFromNetworkCmd.class, RETURNS_SELF);
+ String[] containerId = new String[1];
+ when(disconnect.withContainerId(anyString())).thenAnswer(argument -> {
+ String requested = argument.getArgument(0);
+ containerId[0] = selfContainerId.startsWith(requested) ? selfContainerId : requested;
+ return disconnect;
+ });
+ when(disconnect.withNetworkId(anyString())).thenAnswer(argument -> {
+ assertEquals(name, argument.getArgument(0));
+ return disconnect;
+ });
+ doAnswer(execution -> {
+ if (failNextDisconnect.compareAndSet(true, false)) {
+ throw new RuntimeException("temporary Docker disconnect failure");
+ }
+ endpoints.remove(containerId[0]);
+ return null;
+ }).when(disconnect).exec();
+ return disconnect;
+ });
+ when(docker.removeNetworkCmd(anyString())).thenAnswer(call -> {
+ assertEquals(name, call.getArgument(0));
+ RemoveNetworkCmd remove = mock(RemoveNetworkCmd.class, RETURNS_SELF);
+ doAnswer(execution -> {
+ if (!endpoints.isEmpty()) {
+ throw new ConflictException("network has active endpoints");
+ }
+ existingNetworks.removeIf(network -> name.equals(network.getName()));
+ removed.countDown();
+ return null;
+ }).when(remove).exec();
+ return remove;
+ });
+ }
+ }
+
@Test
void recreatesALeftoverNetworkWhoseSubnetIsNotTheRangeThisVpcAllocatesFrom() {
// What a previous run with a different declaration leaves behind: this VPC's own network
diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/net/VpcNetworkTeardownDockerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/net/VpcNetworkTeardownDockerIntegrationTest.java
new file mode 100644
index 0000000000..98b6ea5bbd
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/net/VpcNetworkTeardownDockerIntegrationTest.java
@@ -0,0 +1,148 @@
+package io.github.hectorvent.floci.services.ec2.net;
+
+import com.github.dockerjava.api.DockerClient;
+import com.github.dockerjava.api.exception.NotFoundException;
+import com.github.dockerjava.api.model.Network;
+import io.github.hectorvent.floci.config.EmulatorConfig;
+import io.github.hectorvent.floci.core.common.docker.ContainerBuilder;
+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager;
+import io.github.hectorvent.floci.core.common.docker.ContainerStorageHelper;
+import io.github.hectorvent.floci.core.common.docker.CurrentContainerNetworkResolver;
+import io.github.hectorvent.floci.testing.DockerAvailability;
+import io.github.hectorvent.floci.testing.TestImages;
+import io.quarkus.test.junit.QuarkusTest;
+import jakarta.inject.Inject;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.stream.IntStream;
+
+import static org.awaitility.Awaitility.await;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@QuarkusTest
+class VpcNetworkTeardownDockerIntegrationTest {
+
+ private static final String REGION = "us-east-1";
+
+ @Inject
+ DockerClient docker;
+
+ @Inject
+ ContainerBuilder containerBuilder;
+
+ @Inject
+ ContainerLifecycleManager lifecycleManager;
+
+ @BeforeEach
+ void requireDocker() throws InterruptedException {
+ assumeTrue(DockerAvailability.isAvailable(), "Docker must be available for VPC network teardown tests");
+ }
+
+ @ParameterizedTest
+ @ValueSource(booleans = {false, true})
+ void deletingDockerHostedVpcFreesItsCidrWithoutStoppingFloci(boolean restored) {
+ String namespace = "vpc-delete-" + UUID.randomUUID();
+ EmulatorConfig config = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);
+ when(config.port()).thenReturn(4650);
+ when(config.services().ec2().mock()).thenReturn(false);
+ when(config.services().ec2().vpcNetworks().enabled()).thenReturn(true);
+ when(config.services().ec2().vpcNetworks().driver()).thenReturn("bridge");
+ when(config.services().ec2().vpcNetworks().fallbackPool()).thenReturn("10.240.0.0/12");
+ when(config.services().ec2().vpcNetworks().fallbackPrefixLength()).thenReturn(24);
+ when(config.docker().extraLabels()).thenReturn(List.of());
+ when(config.docker().resourceNamespace()).thenReturn(Optional.of(namespace));
+
+ List<Cidr4> taken = docker.listNetworksCmd().exec().stream()
+ .filter(network -> network.getIpam() != null && network.getIpam().getConfig() != null)
+ .flatMap(network -> network.getIpam().getConfig().stream())
+ .flatMap(ipam -> Cidr4.parse(ipam.getSubnet()).stream())
+ .toList();
+ Cidr4 cidr = IntStream.range(128, 240)
+ .mapToObj(block -> Cidr4.parse("10.200." + block + ".0/24").orElseThrow())
+ .filter(candidate -> taken.stream().noneMatch(candidate::overlaps))
+ .findFirst().orElseThrow(() -> new AssertionError("No free test CIDR in 10.200.128.0/17"));
+ String expectedAddress = cidr.addressAt(10).orElseThrow();
+ CurrentContainerNetworkResolver resolver = mock(CurrentContainerNetworkResolver.class);
+ VpcNetworkManager manager = new VpcNetworkManager(config, docker, resolver);
+ List<String> containers = new ArrayList<>();
+ List<String> networks = new ArrayList<>();
+ try {
+ String self = startContainer(namespace + "-floci");
+ containers.add(self);
+ when(resolver.resolveContainerId()).thenReturn(Optional.of(self.substring(0, 12)));
+ for (int round = 0; round < 2; round++) {
+ String vpcId = "vpc-" + round;
+ String subnetId = "subnet-" + round;
+ manager.declareVpc(REGION, vpcId, cidr.toString());
+ manager.declareSubnet(REGION, vpcId, subnetId, cidr.toString());
+ String address = manager.allocatePrivateIp(REGION, subnetId).orElseThrow();
+ assertEquals(expectedAddress, address);
+ assertFalse(manager.isSubstituted(REGION, vpcId));
+
+ String guest = startContainer(namespace + "-guest-" + round);
+ containers.add(guest);
+ String networkName = manager.networkName(REGION, vpcId);
+ networks.add(networkName);
+ assertTrue(manager.attach(REGION, vpcId, subnetId, guest, address).isPresent());
+ Network network = docker.inspectNetworkCmd().withNetworkId(networkName).exec();
+ assertTrue(network.getContainers().containsKey(self));
+ assertEquals(address + "/24", network.getContainers().get(guest).getIpv4Address());
+
+ if (restored) {
+ manager.shutdown();
+ manager = new VpcNetworkManager(config, docker, resolver);
+ manager.declareVpc(REGION, vpcId, cidr.toString());
+ manager.declareSubnet(REGION, vpcId, subnetId, cidr.toString());
+ assertTrue(manager.attachContainer(REGION, vpcId, guest));
+ }
+
+ docker.removeContainerCmd(guest).withForce(true).exec();
+ containers.remove(guest);
+ manager.forgetSubnet(REGION, subnetId);
+ manager.deleteVpcNetwork(REGION, vpcId);
+
+ await().pollInterval(Duration.ofMillis(25)).atMost(Duration.ofSeconds(12))
+ .untilAsserted(() -> assertThrows(NotFoundException.class,
+ () -> docker.inspectNetworkCmd().withNetworkId(networkName).exec()));
+ assertTrue(docker.inspectContainerCmd(self).exec().getState().getRunning());
+ assertFalse(docker.inspectContainerCmd(self).exec().getNetworkSettings()
+ .getNetworks().containsKey(networkName));
+ }
+ } finally {
+ manager.shutdown();
+ for (String containerId : containers) {
+ docker.removeContainerCmd(containerId).withForce(true).exec();
+ }
+ for (String networkName : networks) {
+ try {
+ Network network = docker.inspectNetworkCmd().withNetworkId(networkName).exec();
+ assertEquals(ContainerStorageHelper.ownerIdentity(config),
+ network.getLabels().get(ContainerStorageHelper.OWNER_LABEL));
+ docker.removeNetworkCmd(network.getId()).exec();
+ } catch (NotFoundException expected) {
+ // A successful teardown already removed this test-owned network.
+ }
+ }
+ }
+ }
+
+ private String startContainer(String name) {
+ return lifecycleManager.createAndStart(containerBuilder.newContainer(TestImages.BUSYBOX)
+ .withName(name).withCmd(List.of("sleep", "120"))
+ .build()).containerId();
+ }
+}