public ContainerBuilder addLinks(Collection<String> links) { Collection<Link> listOfLinks = new HashSet<Link>(); for (String link : links) { listOfLinks.add(Link.valueOf(link)); } if (configuration.getLinks() != null) { Collection<Link> oldLinks = configuration.getLinks(); oldLinks.addAll(listOfLinks); } else { configuration.setLinks(listOfLinks); } return this; }
private static void setDefaultSeleniumCubeProperties(CubeContainer cubeContainer, int seleniumBoundedPort) { final ArrayList<PortBinding> portBindings = new ArrayList<>(); portBindings.add(PortBinding.valueOf(seleniumBoundedPort + "->4444")); final Image image = cubeContainer.getImage(); if (null != image && image.getName().toLowerCase().contains("debug")) { //Expose VNC portBindings.add(PortBinding.valueOf("5900->5900")); } cubeContainer.setPortBindings( portBindings ); Await await = new Await(); await.setStrategy("http"); await.setResponseCode(getSeleniumExpectedResponseCode()); await.setUrl("http://dockerHost:" + seleniumBoundedPort); cubeContainer.setAwait(await); cubeContainer.setKillContainer(true); }
private static boolean hasOnlyOneBindPort(CubeContainer cubeContainer) { final Collection<PortBinding> portBindings = cubeContainer.getPortBindings(); if (portBindings == null) { return false; } return portBindings.size() == 1; }
private void setExposedPorts(List<ExposedPort> exposedPorts) { if (cubeContainer.getExposedPorts() == null) { cubeContainer.setExposedPorts(exposedPorts); } else { cubeContainer.getExposedPorts().addAll(exposedPorts); } }
private void setPortBinding(List<PortBinding> portBindings) { if (cubeContainer.getPortBindings() == null) { cubeContainer.setPortBindings(portBindings); } else { cubeContainer.getPortBindings().addAll(portBindings); } }
private ContainerBuilder addNetworks(Collection<String> networks) { if (configuration.getNetworks() != null) { configuration.getNetworks().addAll(networks); } else { configuration.setNetworks(new HashSet<>(networks)); } return this; }
if (containerConfiguration.getReadonlyRootfs() != null) { createContainerCmd.withReadonlyRootfs(containerConfiguration.getReadonlyRootfs()); if (containerConfiguration.getLabels() != null) { createContainerCmd.withLabels(containerConfiguration.getLabels()); if (containerConfiguration.getWorkingDir() != null) { createContainerCmd.withWorkingDir(containerConfiguration.getWorkingDir()); if (containerConfiguration.getDisableNetwork() != null) { createContainerCmd.withNetworkDisabled(containerConfiguration.getDisableNetwork()); if (containerConfiguration.getHostName() != null) { createContainerCmd.withHostName(containerConfiguration.getHostName()); if (containerConfiguration.getPortSpecs() != null) { createContainerCmd.withPortSpecs(containerConfiguration.getPortSpecs().toArray(new String[0])); if (containerConfiguration.getUser() != null) { createContainerCmd.withUser(containerConfiguration.getUser()); if (containerConfiguration.getTty() != null) { createContainerCmd.withTty(containerConfiguration.getTty()); if (containerConfiguration.getStdinOpen() != null) { createContainerCmd.withStdinOpen(containerConfiguration.getStdinOpen()); if (containerConfiguration.getStdinOnce() != null) { createContainerCmd.withStdInOnce(containerConfiguration.getStdinOnce());
if (configuration.getImage() != null) { reportBuilder.addKeyValueEntry(IMAGE_NAME, configuration.getImage().toString()); } else { reportBuilder.addKeyValueEntry(BUILD_LOCATION, configuration.getBuildImage().getDockerfileLocation()); if (configuration.getExposedPorts() != null) { reportBuilder.addKeyValueEntry(EXPOSED_PORTS, configuration.getExposedPorts().toString()); if (configuration.getPortBindings() != null) { reportBuilder.addKeyValueEntry(PORT_BINDING, configuration.getPortBindings().toString()); if (configuration.getLinks() != null) { reportBuilder.addKeyValueEntry(LINKS, configuration.getLinks().toString()); if (configuration.getVolumes() != null) { reportBuilder.addKeyValueEntry(VOLUMES, configuration.getVolumes().toString()); if (configuration.getBinds() != null) { reportBuilder.addKeyValueEntry(BINDS, configuration.getBinds().toString()); if (configuration.getEntryPoint() != null) { reportBuilder.addKeyValueEntry(ENTRY_POINT, configuration.getEntryPoint().toString()); if (configuration.getNetworkMode() != null) { reportBuilder.addKeyValueEntry(NETWORK_MODE, configuration.getNetworkMode());
final CubeContainer overrideCubeContainer = overrideDockerCompositions.get(containerId); cubeContainer.setRemoveVolumes(overrideCubeContainer.getRemoveVolumes()); cubeContainer.setAlwaysPull(overrideCubeContainer.getAlwaysPull()); if (overrideCubeContainer.hasAwait()) { cubeContainer.setAwait(overrideCubeContainer.getAwait()); if (overrideCubeContainer.hasBeforeStop()) { cubeContainer.setBeforeStop(overrideCubeContainer.getBeforeStop()); if (overrideCubeContainer.isManual()) { cubeContainer.setManual(overrideCubeContainer.isManual()); if (overrideCubeContainer.isKillContainer()) { cubeContainer.setKillContainer(overrideCubeContainer.isKillContainer());
@Test public void shouldTransformSimpleDockerComposeFormat() throws URISyntaxException, IOException { URI simpleDockerCompose = DockerComposeConverterTest.class.getResource("/simple-docker-compose.yml").toURI(); DockerComposeConverter dockerComposeConverter = DockerComposeConverter.create(Paths.get(simpleDockerCompose)); DockerCompositions convert = dockerComposeConverter.convert(); CubeContainer webapp = convert.get("webapp"); assertThat(webapp.getBuildImage(), is(notNullValue())); assertThat(webapp.getPortBindings(), is(notNullValue())); Collection<PortBinding> ports = webapp.getPortBindings(); assertThat(ports, containsInAnyOrder(PortBinding.valueOf("8000->8000"))); assertThat(webapp.getDevices(), is(notNullValue())); assertThat(webapp.getVolumes(), is(notNullValue())); Collection<String> volumes = (Collection<String>) webapp.getVolumes(); assertThat(volumes, containsInAnyOrder("/data")); CubeContainer webapp2 = convert.get("webapp2"); assertThat(webapp2.getImage(), is(notNullValue())); assertThat(webapp2.getPortBindings(), is(notNullValue())); assertThat(webapp2.getLinks(), is(notNullValue())); Collection<Link> links = webapp2.getLinks(); assertThat(links, containsInAnyOrder(Link.valueOf("webapp:webapp"))); assertThat(webapp2.getEnv(), is(notNullValue())); Collection<String> env = webapp2.getEnv(); assertThat(env, containsInAnyOrder("RACK_ENV=development")); }
final Collection<Link> links = data.getLinks(); final Collection<PortBinding> portBindings = linkedContainer.getPortBindings(); if (portBindings != null) { for (PortBinding portBinding : portBindings) { final Collection<ExposedPort> exposedPorts = linkedContainer.getExposedPorts(); if (exposedPorts != null) { for (ExposedPort exposedPort : exposedPorts) { data.setLinks(updateLinks(builder, data.getLinks())); if (data.getPortBindings() != null) { Collection<PortBinding> ports = data.getPortBindings(); for (PortBinding binding : ports) { builder.containerBinds(cubeName, binding.getBound(), binding.getExposedPort().getExposed(), binding.getExposedPort().getType()); removedBoundPorts.add(binding); data.setPortBindings(null); if (data.getExposedPorts() != null) { Collection<ExposedPort> ports = data.getExposedPorts(); for (ExposedPort port : ports) { builder.containerExpose(cubeName, port.getExposed(), port.getType()); if (data.getExposedPorts() != null) { ports = data.getExposedPorts(); data.setExposedPorts(ports);
@Test public void should_load_docker_compose_format() { Map<String, String> parameters = new HashMap<String, String>(); parameters.put("serverVersion", "1.13"); parameters.put("serverUri", "http://localhost:25123"); parameters.put("dockerContainers", DOCKER_COMPOSE_CONTENT); parameters.put("definitionFormat", DefinitionFormat.COMPOSE.name()); CubeDockerConfiguration cubeConfiguration = CubeDockerConfiguration.fromMap(parameters, null); final DockerCompositions dockerContainersContent = cubeConfiguration.getDockerContainersContent(); CubeContainer actualWeb = dockerContainersContent.get("web"); assertThat(actualWeb.getBuildImage(), is(notNullValue())); assertThat(actualWeb.getPortBindings(), is(notNullValue())); assertThat(actualWeb.getVolumes(), is(notNullValue())); assertThat(actualWeb.getLinks(), is(notNullValue())); CubeContainer actualRedis = dockerContainersContent.get("redis"); assertThat(actualRedis.getImage(), is(notNullValue())); }
@Test public void should_create_polling_await_strategy() { Await await = new Await(); await.setStrategy("polling"); CubeContainer cubeContainer = new CubeContainer(); cubeContainer.setAwait(await); AwaitStrategy strategy = AwaitStrategyFactory.create(null, cube, cubeContainer); assertThat(strategy, instanceOf(PollingAwaitStrategy.class)); }
@Test public void shouldCreateContainerForFirefox() { when(cubeDroneConfiguration.isBrowserDockerfileDirectorySet()).thenReturn(false); when(cubeDroneConfiguration.isBrowserImageSet()).thenReturn(false); when(cubeDroneConfiguration.getContainerNameStrategy()).thenReturn(ContainerNameStrategy.STATIC); when(cubeDroneConfiguration.getDockerRegistry()).thenReturn(""); final SeleniumContainers firefox = SeleniumContainers.create("firefox", cubeDroneConfiguration); assertThat(firefox.getBrowser(), is("firefox")); assertThat(firefox.getSeleniumContainer().getImage().toString(), is("selenium/standalone-firefox-debug:2.53.0")); assertThat(firefox.getSeleniumContainer().getPortBindings(), hasItem(PortBinding.valueOf("14444->4444"))); assertThat(firefox.getSeleniumContainer().getAwait().getResponseCode(), is(403)); }
CubeContainer container = containers.get("tomcat"); Assert.assertEquals("tutum/tomcat", container.getImage().getName()); Assert.assertEquals("7.0", container.getImage().getTag()); Assert.assertEquals(1, container.getExposedPorts().size()); ExposedPort exposedPort = container.getExposedPorts().iterator().next(); Assert.assertEquals(8089, exposedPort.getExposed()); Assert.assertEquals("tcp", exposedPort.getType()); Assert.assertEquals(2, container.getPortBindings().size()); Iterator<PortBinding> portBindingIterator = container.getPortBindings().iterator(); PortBinding portBinding1 = portBindingIterator.next(); PortBinding portBinding2 = portBindingIterator.next(); Assert.assertEquals("tcp", portBinding2.getExposedPort().getType()); Assert.assertEquals("static", container.getAwait().getStrategy()); Assert.assertEquals("localhost", container.getAwait().getIp()); Assert.assertEquals(2, container.getAwait().getPorts().size());
@Override public String[] getLinks() { return Optional.ofNullable(configuration.getLinks()) .map(links -> links.stream().map(Link::toString).toArray(String[]::new)) .orElse(null); } }
public void connectToNetworks(@Observes AfterCreate event, CubeDockerConfiguration dockerConfiguration) { final DockerCompositions dockerContainersContent = dockerConfiguration.getDockerContainersContent(); final DockerClientExecutor dockerClientExecutor = dockerClientExecutorInstance.get(); String cubeId = event.getCubeId(); CubeContainer container = dockerContainersContent.get(cubeId); if (container != null && container.getNetworks() != null) { for (String network : container.getNetworks()) { if (!network.equals(container.getNetworkMode())) { dockerClientExecutor.connectToNetwork(network, cubeId); } } } } }
@Test public void shouldTakePrecedenceDockerfileDirectoryThanImage() { when(cubeDroneConfiguration.isBrowserDockerfileDirectorySet()).thenReturn(true); when(cubeDroneConfiguration.isBrowserImageSet()).thenReturn(true); when(cubeDroneConfiguration.getBrowserDockerfileLocation()).thenReturn("src/test/resources/browser"); when(cubeDroneConfiguration.getContainerNameStrategy()).thenReturn(ContainerNameStrategy.STATIC); final SeleniumContainers firefox = SeleniumContainers.create("firefox", cubeDroneConfiguration); assertThat(firefox.getBrowser(), is("firefox")); assertThat(firefox.getSeleniumContainer().getBuildImage().getDockerfileLocation().toString(), is("src/test/resources/browser")); assertThat(firefox.getSeleniumContainer().getImage(), is(nullValue())); assertThat(firefox.getSeleniumContainer().getPortBindings(), hasItem(PortBinding.valueOf("14444->4444"))); }
public static void adaptNetworksToParalledRun(Map<String,String> networkResolutions, CubeContainer cubeContainer) { String networkMode = cubeContainer.getNetworkMode(); if (networkMode != null && networkResolutions.containsKey(networkMode)) { cubeContainer.setNetworkMode(networkResolutions.get(networkMode)); } if (cubeContainer.getNetworks() != null) { ArrayList<String> networks = new ArrayList<>(); for (String network : cubeContainer.getNetworks()) { networks.add(networkResolutions.getOrDefault(network, network)); } cubeContainer.setNetworks(networks); } }
@Test public void should_be_able_to_extend_and_override_toplevel() throws Exception { String config = "tomcat6:\n" + " image: tutum/tomcat:6.0\n" + " exposedPorts: [8089/tcp]\n" + " await:\n" + " strategy: static\n" + " ip: localhost\n" + " ports: [8080, 8089]\n" + "tomcat7:\n" + " extends: tomcat6\n" + " image: tutum/tomcat:7.0\n"; Map<String, String> parameters = new HashMap<String, String>(); parameters.put("dockerContainers", config); parameters.put("definitionFormat", DefinitionFormat.CUBE.name()); CubeDockerConfiguration cubeConfiguration = CubeDockerConfiguration.fromMap(parameters, null); CubeContainer tomcat7 = cubeConfiguration.getDockerContainersContent().get("tomcat7"); Assert.assertEquals("tutum/tomcat:7.0", tomcat7.getImage().toImageRef()); Assert.assertTrue(tomcat7.getAwait() != null); Assert.assertEquals("8089/tcp", tomcat7.getExposedPorts().iterator().next().toString()); }