Java Network类代码示例

import com.github.dockerjava.api.model.Network; //导入依赖的package包/类
/**
 * Create network which is used as default in docker-compose.yml
 * This should be run before {@link DockerComposeExecutor#run(TestEnvironment)}
 */
@Override
public void createNetwork() {
    removeNetwork();

    String apmNetwork = apmBindAddress.substring(0, apmBindAddress.lastIndexOf(".")) + ".0/24";

    log.info(String.format("Creating network %s:", apmNetwork));

    Network.Ipam ipam = new Network.Ipam()
            .withConfig(new Network.Ipam.Config()
                    .withSubnet(apmNetwork)
                    .withGateway(apmBindAddress));

    CreateNetworkResponse createNetworkResponse = dockerClient.createNetworkCmd()
            .withName(Constants.HOST_ADDED_TO_ETC_HOSTS)
            .withIpam(ipam)
            .exec();

    try {
        network = dockerClient.inspectNetworkCmd().withNetworkId(createNetworkResponse.getId()).exec();
    } catch (DockerException ex) {
        log.severe(String.format("Could not create network: %s", createNetworkResponse));
        throw new EnvironmentException("Could not create network: " + createNetworkResponse, ex);
    }
}
 

import com.github.dockerjava.api.model.Network; //导入依赖的package包/类
@Override
protected List<Network> execute(ListNetworksCmd command) {
    WebTarget webTarget = getBaseResource().path("/networks");

    if (command.getFilters() != null && !command.getFilters().isEmpty()) {
        webTarget = webTarget
                .queryParam("filters", urlPathSegmentEscaper().escape(FiltersEncoder.jsonEncode(command.getFilters())));
    }

    LOGGER.trace("GET: {}", webTarget);
    List<Network> networks = webTarget.request().accept(MediaType.APPLICATION_JSON)
            .get(new GenericType<List<Network>>() {
            });
    LOGGER.trace("Response: {}", networks);

    return networks;
}
 

import com.github.dockerjava.api.model.Network; //导入依赖的package包/类
@Test
public void inspectNetwork() throws DockerException {
    assumeNotSwarm("no network in swarm", dockerRule);

    List<Network> networks = dockerRule.getClient().listNetworksCmd().exec();

    Network expected = findNetwork(networks, "bridge");

    Network network = dockerRule.getClient().inspectNetworkCmd().withNetworkId(expected.getId()).exec();

    assertThat(network.getName(), equalTo(expected.getName()));
    assertThat(network.getScope(), equalTo(expected.getScope()));
    assertThat(network.getDriver(), equalTo(expected.getDriver()));
    assertThat(network.getIpam().getConfig().get(0).getSubnet(), equalTo(expected.getIpam().getConfig().get(0).getSubnet()));
    assertThat(network.getIpam().getDriver(), equalTo(expected.getIpam().getDriver()));
}
 

import com.github.dockerjava.api.model.Network; //导入依赖的package包/类
@Test
public void testUpdateServiceReplicate() {
    DockerClient docker1 = startDockerInDocker();
    docker1.initializeSwarmCmd(new SwarmSpec()).exec();
    //create network
    String networkId = docker1.createNetworkCmd().withName("networkname").withDriver("overlay")
            .withIpam(new Network.Ipam().withDriver("default")).exec().getId();
    TaskSpec taskSpec = new TaskSpec().withContainerSpec(
            new ContainerSpec().withImage("busybox").withArgs(Arrays.asList("sleep", "3600")));
    ServiceSpec serviceSpec = new ServiceSpec()
            .withMode(new ServiceModeConfig().withReplicated(new ServiceReplicatedModeOptions().withReplicas(1)))
            .withTaskTemplate(taskSpec)
            .withNetworks(Lists.newArrayList(new NetworkAttachmentConfig().withTarget(networkId)))
            .withName("worker");
    String serviceId = docker1.createServiceCmd(serviceSpec).exec().getId();
    //list the service
    List<Service> services = docker1.listServicesCmd().withIdFilter(Arrays.asList(serviceId)).exec();
    assertThat(services.size(), is(1));
    Service service = services.get(0);
    ServiceSpec updateServiceSpec = service.getSpec()
            .withMode(new ServiceModeConfig().withReplicated(new ServiceReplicatedModeOptions().withReplicas(2)));
    docker1.updateServiceCmd(service.getId(), updateServiceSpec).withVersion(service.getVersion().getIndex()).exec();
    //verify the replicate
    Service updateService = docker1.listServicesCmd().withIdFilter(Arrays.asList(serviceId)).exec().get(0);
    assertThat(updateService.getSpec().getMode().getReplicated().getReplicas(), is(2L));
}
 

import com.github.dockerjava.api.model.Network; //导入依赖的package包/类
@Test
public void removeNetwork() throws DockerException {
    assumeNotSwarm("Swarm has no network", dockerRule);

    CreateNetworkResponse network = dockerRule.getClient().createNetworkCmd()
            .withName("test-network")
            .exec();

    LOG.info("Removing network: {}", network.getId());
    dockerRule.getClient().removeNetworkCmd(network.getId()).exec();

    List<Network> networks = dockerRule.getClient().listNetworksCmd().exec();

    Matcher matcher = not(hasItem(hasField("id", startsWith(network.getId()))));
    assertThat(networks, matcher);

}
 

import com.github.dockerjava.api.model.Network; //导入依赖的package包/类
@Test
public void createNetworkWithIpamConfig() throws DockerException {
    assumeNotSwarm("no network in swarm", dockerRule);

    String networkName = "networkIpam" + dockerRule.getKind();
    String subnet = getFactoryType() == FactoryType.JERSEY ? "10.67.79.0/24" : "10.67.90.0/24";

    Network.Ipam ipam = new Network.Ipam().withConfig(new Network.Ipam.Config().withSubnet(subnet));
    CreateNetworkResponse createNetworkResponse = dockerRule.getClient().createNetworkCmd().withName(networkName).withIpam(ipam).exec();

    assertNotNull(createNetworkResponse.getId());

    Network network = dockerRule.getClient().inspectNetworkCmd().withNetworkId(createNetworkResponse.getId()).exec();
    assertEquals(network.getName(), networkName);
    assertEquals("bridge", network.getDriver());
    assertEquals(subnet, network.getIpam().getConfig().iterator().next().getSubnet());
}
 

import com.github.dockerjava.api.model.Network; //导入依赖的package包/类
@Test
public void forceDisconnectFromNetwork() throws InterruptedException {
    assumeNotSwarm("no network in swarm", dockerRule);

    CreateNetworkResponse network = dockerRule.getClient().createNetworkCmd().withName("testNetwork2" + dockerRule.getKind()).exec();

    CreateContainerResponse container = dockerRule.getClient().createContainerCmd("busybox")
            .withNetworkMode("testNetwork2" + dockerRule.getKind())
            .withCmd("sleep", "9999")
            .exec();

    dockerRule.getClient().startContainerCmd(container.getId()).exec();

    dockerRule.getClient().disconnectFromNetworkCmd()
            .withNetworkId(network.getId())
            .withContainerId(container.getId())
            .withForce(true)
            .exec();

    Network updatedNetwork = dockerRule.getClient().inspectNetworkCmd().withNetworkId(network.getId()).exec();
    assertFalse(updatedNetwork.getContainers().containsKey(container.getId()));
}
 

import com.github.dockerjava.api.model.Network; //导入依赖的package包/类
public static String createNetwork(String subnet) {
  CreateNetworkResponse createNetworkResponse =
      dockerClient
          .createNetworkCmd()
          .withName(subnet)
          .withCheckDuplicate(true)
          .withIpam(new Network.Ipam().withConfig(new Network.Ipam.Config().withSubnet(subnet)))
          .exec();
  return createNetworkResponse.getId();
}
 

import com.github.dockerjava.api.model.Network; //导入依赖的package包/类
public static void createDockerTestNetworkIfNeeded(DockerImpl docker) {
    if (! docker.dockerClient.listNetworksCmd().withNameFilter(DockerImpl.DOCKER_CUSTOM_MACVLAN_NETWORK_NAME).exec().isEmpty()) return;

    Network.Ipam ipam = new Network.Ipam().withConfig(new Network.Ipam.Config()
            .withSubnet("172.18.0.0/16")
            .withGateway("172.18.0.1"));
    docker.dockerClient.createNetworkCmd()
            .withName(DockerImpl.DOCKER_CUSTOM_MACVLAN_NETWORK_NAME).withDriver("bridge").withIpam(ipam).exec();
}
 

import com.github.dockerjava.api.model.Network; //导入依赖的package包/类
private void setupDockerNetworkIfNeeded() throws IOException {
    if (!dockerClient.listNetworksCmd().withNameFilter(DOCKER_CUSTOM_MACVLAN_NETWORK_NAME).exec().isEmpty()) return;

    // Use IPv6 address if there is a mix of IP4 and IPv6 by taking the longest address.
    List<InetAddress> hostAddresses = Arrays.asList(InetAddress.getAllByName(com.yahoo.net.HostName.getLocalhost()));
    InetAddress hostAddress = Collections.max(hostAddresses,
            (o1, o2) -> o1.getAddress().length - o2.getAddress().length);

    NetworkAddressInterface networkAddressInterface = DockerNetworkCreator.getInterfaceForAddress(hostAddress);
    boolean isIPv6 = networkAddressInterface.interfaceAddress.getAddress() instanceof Inet6Address;

    Network.Ipam ipam = new Network.Ipam().withConfig(new Network.Ipam.Config()
            .withSubnet(hostAddress.getHostAddress() + "/" + networkAddressInterface.interfaceAddress.getNetworkPrefixLength())
            .withGateway(DockerNetworkCreator.getDefaultGatewayLinux(isIPv6).getHostAddress()));

    Map<String, String> dockerNetworkOptions = new HashMap<>();
    dockerNetworkOptions.put("parent", networkAddressInterface.networkInterface.getDisplayName());
    dockerNetworkOptions.put("macvlan_mode", "bridge");

    dockerClient.createNetworkCmd()
            .withName(DOCKER_CUSTOM_MACVLAN_NETWORK_NAME)
            .withDriver("macvlan")
            .withEnableIpv6(isIPv6)
            .withIpam(ipam)
            .withOptions(dockerNetworkOptions)
            .exec();
}
 

import com.github.dockerjava.api.model.Network; //导入依赖的package包/类
@Override
protected Network execute(InspectNetworkCmd command) {

    WebTarget webResource = getBaseResource().path("/networks/{id}").resolveTemplate("id",
            command.getNetworkId());

    LOGGER.debug("GET: {}", webResource);
    return webResource.request().accept(MediaType.APPLICATION_JSON).get(Network.class);
}
 

import com.github.dockerjava.api.model.Network; //导入依赖的package包/类
@Override
protected List<Network> execute(ListNetworksCmd command) {
    WebTarget webTarget = getBaseResource().path("/networks");

    if (command.getFilters() != null && !command.getFilters().isEmpty()) {
        webTarget = webTarget.queryParam("filters", FiltersEncoder.jsonEncode(command.getFilters()));
    }

    LOGGER.trace("GET: {}", webTarget);

    return webTarget.request().accept(MediaType.APPLICATION_JSON).get(new TypeReference<List<Network>>() {
    });
}
 

import com.github.dockerjava.api.model.Network; //导入依赖的package包/类
@Override
protected Network execute(InspectNetworkCmd command) {
    WebTarget webResource = getBaseResource().path("/networks/{id}").resolveTemplate("id", command.getNetworkId());

    LOGGER.trace("GET: {}", webResource);
    return webResource.request().accept(MediaType.APPLICATION_JSON).get(new TypeReference<Network>() {
    });
}
 

import com.github.dockerjava.api.model.Network; //导入依赖的package包/类
public static Network findNetwork(List<Network> networks, String name) {

        for (Network network : networks) {
            if (StringUtils.equals(network.getName(), name)) {
                return network;
            }
        }

        throw new AssertionError("No network found.");
    }
 

import com.github.dockerjava.api.model.Network; //导入依赖的package包/类
@Test
public void listNetworks() throws DockerException {
    assumeNotSwarm("Swarm has no network", dockerRule);

    List<Network> networks = dockerRule.getClient().listNetworksCmd().exec();

    Network network = TestUtils.findNetwork(networks, "bridge");

    assertThat(network.getName(), equalTo("bridge"));
    assertThat(network.getScope(), equalTo("local"));
    assertThat(network.getDriver(), equalTo("bridge"));
    assertThat(network.getIpam().getDriver(), equalTo("default"));
}