org.arquillian.cube.spi.Binding java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 Connection c =DataSource dataSource;dataSource.getConnection()
String url;DriverManager.getConnection(url)
IdentityDatabaseUtil.getDBConnection()
Smart code suggestions by Codota
}

  public static Binding binding(CubeContainer cubeConfiguration, DockerClientExecutor executor) {

    Binding binding = new Binding(executor.getDockerServerIp());

    if (cubeConfiguration.getPortBindings() != null) {
      for (PortBinding cubePortBinding : cubeConfiguration.getPortBindings()) {
        binding.addPortBinding(cubePortBinding.getExposedPort().getExposed(), cubePortBinding.getBound());
      }
    }
    return binding;
  }
}

public void createCubeSystemProperties(@Observes AfterStart afterStart, CubeRegistry cubeRegistry) {
  String cubeId = afterStart.getCubeId();
  final DockerCube cube = cubeRegistry.getCube(cubeId, DockerCube.class);
  final Binding bindings = cube.bindings();
  final String cubePrefix = String.format("%s.%s", PREFIX, cubeId);
  System.setProperty(String.format("%s.ip", cubePrefix), bindings.getIP());
  System.setProperty(String.format("%s.internal.ip", cubePrefix), bindings.getInternalIP());
  for (Binding.PortBinding portBinding : bindings.getPortBindings()) {
    final int exposedPort = portBinding.getExposedPort();
    final Integer boundPort = portBinding.getBindingPort();
    System.setProperty(String.format("%s.port.%d", cubePrefix, exposedPort), boundPort.toString());
  }
}

private PortBindings() {
  this.mappedPorts = new HashMap<Integer, PortAddress>();
  this.containerPorts = new LinkedHashSet<Integer>();
  final Binding configuredBindings = configuredBindings();
  containerIP = configuredBindings.getIP();
  for (PortBinding portBinding : configuredBindings.getPortBindings()) {
    final int exposedPort = portBinding.getExposedPort();
    final Integer boundPort = portBinding.getBindingPort();
    containerPorts.add(exposedPort);
    if (boundPort != null && containerIP != null) {
      mappedPorts.put(exposedPort, new PortAddressImpl(containerIP, boundPort));
    }
  }
  this.boundPorts = new LinkedHashSet<Integer>(containerPorts.size());
}

private PortBindings() {
  this.mappedPorts = new HashMap<Integer, PortAddress>();
  this.containerPorts = new LinkedHashSet<Integer>();
  final Binding configuredBindings = configuredBindings();
  containerIP = configuredBindings.getIP();
  for (PortBinding portBinding : configuredBindings.getPortBindings()) {
    final int exposedPort = portBinding.getExposedPort();
    final Integer boundPort = portBinding.getBindingPort();
    containerPorts.add(exposedPort);
    if (boundPort != null && containerIP != null) {
      mappedPorts.put(exposedPort, new PortAddressImpl(containerIP, boundPort));
    }
  }
  this.boundPorts = new LinkedHashSet<Integer>(containerPorts.size());
}

  public static Binding binding(CubeContainer cubeConfiguration, DockerClientExecutor executor) {

    Binding binding = new Binding(executor.getDockerServerIp());

    if (cubeConfiguration.getPortBindings() != null) {
      for (PortBinding cubePortBinding : cubeConfiguration.getPortBindings()) {
        binding.addPortBinding(cubePortBinding.getExposedPort().getExposed(), cubePortBinding.getBound());
      }
    }
    return binding;
  }
}

public void createCubeSystemProperties(@Observes AfterStart afterStart, CubeRegistry cubeRegistry) {
  String cubeId = afterStart.getCubeId();
  final DockerCube cube = cubeRegistry.getCube(cubeId, DockerCube.class);
  final Binding bindings = cube.bindings();
  final String cubePrefix = String.format("%s.%s", PREFIX, cubeId);
  System.setProperty(String.format("%s.ip", cubePrefix), bindings.getIP());
  System.setProperty(String.format("%s.internal.ip", cubePrefix), bindings.getInternalIP());
  for (Binding.PortBinding portBinding : bindings.getPortBindings()) {
    final int exposedPort = portBinding.getExposedPort();
    final Integer boundPort = portBinding.getBindingPort();
    System.setProperty(String.format("%s.port.%d", cubePrefix, exposedPort), boundPort.toString());
  }
}

public TestPortBindings(Binding configuredBindings) {
  this.mappedPorts = new HashMap<Integer, PortAddress>();
  this.containerPorts = new LinkedHashSet<Integer>();
  containerIP = configuredBindings.getIP();
  for (PortBinding portBinding : configuredBindings.getPortBindings()) {
    final int exposedPort = portBinding.getExposedPort();
    final Integer boundPort = portBinding.getBindingPort();
    containerPorts.add(exposedPort);
    if (boundPort != null && containerIP != null) {
      mappedPorts.put(exposedPort, new PortAddressImpl(configuredBindings.getIP(), boundPort));
    }
  }
  this.boundPorts = new LinkedHashSet<Integer>(containerPorts.size());
}

public static Binding toBinding(Service pod) {
  Binding binding = null;
  if (pod.getStatus() != null && pod.getSpec().getClusterIP() != null) { // Running
    // pod
    binding = new Binding(pod.getSpec().getClusterIP());
  } else { // Configured pod
    binding = new Binding(null);
  }
  for (ServicePort port : pod.getSpec().getPorts()) {
    // nodePort is service equivalent of pod's hostPort
    binding.addPortBinding(port.getPort(), port.getNodePort());
  }
  return binding;
}

  private synchronized void containerStarted() {
    final Binding bindings = bindings();
    containerIP = bindings.getIP();
    internalIP = bindings.getInternalIP();
    for (PortBinding portBinding : bindings.getPortBindings()) {
      final int exposedPort = portBinding.getExposedPort();
      final Integer boundPort = portBinding.getBindingPort();
      boundPorts.add(exposedPort);
      if (boundPort != null && containerIP != null) {
        // just overwrite existing entries
        mappedPorts.put(exposedPort, new PortAddressImpl(containerIP, boundPort));
      }
    }
  }
}

public static Binding toBinding(Pod pod) {
  Binding binding = null;
  if (pod.getStatus() != null && pod.getStatus().getHostIP() != null) { // Running
    // pod
    binding = new Binding(pod.getStatus().getHostIP());
  } else { // Configured pod
    binding = new Binding(null);
  }
  for (Container container : pod.getSpec().getContainers()) {
    for (ContainerPort port : container.getPorts()) {
      binding.addPortBinding(port.getContainerPort(), port.getHostPort());
    }
  }
  return binding;
}

  private synchronized void containerStarted() {
    final Binding bindings = bindings();
    containerIP = bindings.getIP();
    internalIP = bindings.getInternalIP();
    for (PortBinding portBinding : bindings.getPortBindings()) {
      final int exposedPort = portBinding.getExposedPort();
      final Integer boundPort = portBinding.getBindingPort();
      boundPorts.add(exposedPort);
      if (boundPort != null && containerIP != null) {
        // just overwrite existing entries
        mappedPorts.put(exposedPort, new PortAddressImpl(containerIP, boundPort));
      }
    }
  }
}

public static Binding binding(DockerClientExecutor executor, String cubeId) {
  InspectContainerResponse inspectResponse = executor.getDockerClient().inspectContainerCmd(cubeId).exec();
  String dockerIp = getDockerServerIp(executor);
  String inernalIp = null;
  NetworkSettings networkSettings = inspectResponse.getNetworkSettings();
  if (networkSettings != null) {
    inernalIp = networkSettings.getIpAddress();
  }
  Binding binding = new Binding(dockerIp, inernalIp);
  HostConfig hostConfig = inspectResponse.getHostConfig();
  if (hostConfig.getPortBindings() != null) {
    for (Entry<ExposedPort, com.github.dockerjava.api.model.Ports.Binding[]> bind : hostConfig.getPortBindings()
      .getBindings().entrySet()) {
      com.github.dockerjava.api.model.Ports.Binding[] allBindings = bind.getValue();
      for (com.github.dockerjava.api.model.Ports.Binding bindings : allBindings) {
        binding.addPortBinding(bind.getKey().getPort(), Integer.parseInt(bindings.getHostPortSpec()));
      }
    }
  } else {
    ContainerConfig connectionConfig = inspectResponse.getConfig();
    final ExposedPort[] exposedPorts = connectionConfig.getExposedPorts();
    if (exposedPorts != null) {
      for (ExposedPort port : exposedPorts) {
        binding.addPortBinding(port.getPort(), -1);
      }
    }
  }
  return binding;
}

@Before
public void setupContainers() {
  when(dockerClientExecutor.getDockerServerIp()).thenReturn("192.168.99.100");
  when(cubeRegistry.getCube("image", DockerCube.class)).thenReturn(dockerCube);
  when(dockerCube.bindings()).thenReturn(binding);
  when(binding.getIP()).thenReturn("192.168.99.100");
  when(binding.getInternalIP()).thenReturn("172.0.10.0");
  when(portBinding.getExposedPort()).thenReturn(8080);
  when(portBinding.getBindingPort()).thenReturn(8080);
  Set<Binding.PortBinding> portBindings = new HashSet<>();
  portBindings.add(portBinding);
  when(binding.getPortBindings()).thenReturn(portBindings);
}

public static Binding binding(DockerClientExecutor executor, String cubeId) {
  InspectContainerResponse inspectResponse = executor.getDockerClient().inspectContainerCmd(cubeId).exec();
  String dockerIp = getDockerServerIp(executor);
  String inernalIp = null;
  NetworkSettings networkSettings = inspectResponse.getNetworkSettings();
  if (networkSettings != null) {
    inernalIp = networkSettings.getIpAddress();
  }
  Binding binding = new Binding(dockerIp, inernalIp);
  HostConfig hostConfig = inspectResponse.getHostConfig();
  if (hostConfig.getPortBindings() != null) {
    for (Entry<ExposedPort, com.github.dockerjava.api.model.Ports.Binding[]> bind : hostConfig.getPortBindings()
      .getBindings().entrySet()) {
      com.github.dockerjava.api.model.Ports.Binding[] allBindings = bind.getValue();
      for (com.github.dockerjava.api.model.Ports.Binding bindings : allBindings) {
        binding.addPortBinding(bind.getKey().getPort(), Integer.parseInt(bindings.getHostPortSpec()));
      }
    }
  } else {
    ContainerConfig connectionConfig = inspectResponse.getConfig();
    final ExposedPort[] exposedPorts = connectionConfig.getExposedPorts();
    if (exposedPorts != null) {
      for (ExposedPort port : exposedPorts) {
        binding.addPortBinding(port.getPort(), -1);
      }
    }
  }
  return binding;
}

@Before
public void setup() {
  Yaml yaml = new Yaml();
  @SuppressWarnings("unchecked")
  Map<String, Object> content = (Map<String, Object>) yaml.load(CONTENT);
  when(cube.getId()).thenReturn(CUBE_ID);
  when(cube.configuration()).thenReturn(content);
  when(cube.getMetadata(HasPortBindings.class)).thenReturn(
    new TestPortBindings(new Binding("localhost").addPortBinding(8089, 8090)));
  when(container.getName()).thenReturn(CUBE_ID);
  when(container.getDeployableContainer()).thenReturn(deployableContainer);
  when(deployableContainer.getConfigurationClass()).thenReturn(ContainerConfiguration.class);
  when(container.getContainerConfiguration()).thenReturn(containerDef);
  when(containerRegistry.getContainers()).thenReturn(Arrays.asList(container));
  registry = new LocalCubeRegistry();
  registry.addCube(cube);
  bind(ApplicationScoped.class, CubeRegistry.class, registry);
  bind(ApplicationScoped.class, ContainerRegistry.class, containerRegistry);
}

@Test // equal ip, different ports
public void shouldUpdateWithPortFromDocker() throws Exception {
  Binding binding = new Binding(LOCALHOST);
  binding.addPortBinding(EXPOSED_PORT, BOUND_PORT);
  Mockito.when(cube.getMetadata(HasPortBindings.class)).thenReturn(new TestPortBindings(binding));
  bind(ContainerScoped.class,
    Container.class,
    new ContainerImpl(CUBE_CONTAINER_NAME, deployableContainer, new ContainerDefImpl("arquillian.xml")));
  ProtocolMetaData metadata = new ProtocolMetaData();
  metadata.addContext(new HTTPContext(LOCALHOST, EXPOSED_PORT).add(new Servlet("A", "B")));
  bind(DeploymentScoped.class, ProtocolMetaData.class, metadata);
  fire(metadata);
  ProtocolMetaData updated = getManager().getContext(DeploymentContext.class)
    .getObjectStore().get(ProtocolMetaData.class);
  Assert.assertEquals(BOUND_PORT.intValue(), updated.getContexts(HTTPContext.class).iterator().next().getPort());
  Assert.assertEquals(LOCALHOST, updated.getContexts(HTTPContext.class).iterator().next().getHost());
  assertEventFired(ProtocolMetaData.class, 1); // twice, but original fire is intercepted and never hit the Counter
}

  @Test
  public void shouldNotUpdateIfContainerNotMapped() throws Exception {
    Binding binding = new Binding(GATEWAY_IP);
    binding.addPortBinding(EXPOSED_PORT, EXPOSED_PORT);
    Mockito.when(cube.getMetadata(HasPortBindings.class)).thenReturn(new TestPortBindings(binding));

    bind(ContainerScoped.class,
      Container.class,
      new ContainerImpl("_UNMAPPED_", deployableContainer, new ContainerDefImpl("arquillian.xml")));

    ProtocolMetaData metadata = new ProtocolMetaData();
    metadata.addContext(new HTTPContext(LOCALHOST, EXPOSED_PORT).add(new Servlet("A", "B")));

    bind(DeploymentScoped.class, ProtocolMetaData.class, metadata);
    fire(metadata);

    ProtocolMetaData updated = getManager().getContext(DeploymentContext.class)
      .getObjectStore().get(ProtocolMetaData.class);

    Assert.assertEquals(metadata.getContexts(HTTPContext.class).iterator().next(),
      updated.getContexts(HTTPContext.class).iterator().next());
    assertEventFired(ProtocolMetaData.class, 1);
  }
}

@Test // equal ports, different ip
public void shouldUpdateWithIPFromDocker() throws Exception {
  Binding binding = new Binding(GATEWAY_IP);
  binding.addPortBinding(EXPOSED_PORT, EXPOSED_PORT);
  Mockito.when(cube.getMetadata(HasPortBindings.class)).thenReturn(new TestPortBindings(binding));
  bind(ContainerScoped.class,
    Container.class,
    new ContainerImpl(CUBE_CONTAINER_NAME, deployableContainer, new ContainerDefImpl("arquillian.xml")));
  ProtocolMetaData metadata = new ProtocolMetaData();
  metadata.addContext(new HTTPContext(LOCALHOST, EXPOSED_PORT).add(new Servlet("A", "B")));
  bind(DeploymentScoped.class, ProtocolMetaData.class, metadata);
  fire(metadata);
  ProtocolMetaData updated = getManager().getContext(DeploymentContext.class)
    .getObjectStore().get(ProtocolMetaData.class);
  Assert.assertEquals(EXPOSED_PORT.intValue(), updated.getContexts(HTTPContext.class).iterator().next().getPort());
  Assert.assertEquals(GATEWAY_IP, updated.getContexts(HTTPContext.class).iterator().next().getHost());
  assertEventFired(ProtocolMetaData.class, 1); // twice, but original fire is intercepted and never hit the Counter
}

Most used methods

Popular in Java

Reading from database using SQL prepared statement
onRequestPermissionsResult (Fragment)
startActivity (Activity)
getOriginalFilename (MultipartFile)
Return the original filename in the client's filesystem.This may contain path information depending
NumberFormat (java.text)
The abstract base class for all number formats. This class provides the interface for formatting and
Hashtable (java.util)
Hashtable is a synchronized implementation of Map. All optional operations are supported.Neither key
HttpServletRequest (javax.servlet.http)
Extends the javax.servlet.ServletRequest interface to provide request information for HTTP servlets.
XPath (javax.xml.xpath)
XPath provides access to the XPath evaluation environment and expressions. Evaluation of XPath Expr
FileUtils (org.apache.commons.io)
General file manipulation utilities. Facilities are provided in the following areas: * writing to a
Logger (org.apache.log4j)
This is the central class in the log4j package. Most logging operations, except configuration, are d

How to useBinding in org.arquillian.cube.spi

Best Java code snippets using org.arquillian.cube.spi.Binding (Showing top 18 results out of 315)

How to use
Binding
in
org.arquillian.cube.spi