public NodeAndInitialCredentials createNodeWithGroupEncodedIntoName()

in apis/docker/src/main/java/org/jclouds/docker/compute/strategy/DockerComputeServiceAdapter.java [104:236]
108 lines of code
20 McCabe index (conditional complexity)

   public NodeAndInitialCredentials<Container> createNodeWithGroupEncodedIntoName(String group, String name,
                                                                                  Template template) {
      checkNotNull(template, "template was null");
      TemplateOptions options = template.getOptions();
      checkNotNull(options, "template options was null");

      String imageId = checkNotNull(template.getImage().getId(), "template image id must not be null");
      String loginUser = template.getImage().getDefaultCredentials().getUser();
      String loginUserPassword = template.getImage().getDefaultCredentials().getOptionalPassword().or("password");

      DockerTemplateOptions templateOptions = DockerTemplateOptions.class.cast(options);

      Config containerConfig = null;
      Config.Builder containerConfigBuilder = templateOptions.getConfigBuilder();
      if (containerConfigBuilder == null) {
         containerConfigBuilder = Config.builder().image(imageId);

         containerConfigBuilder.entrypoint(templateOptions.getEntrypoint());
         containerConfigBuilder.cmd(templateOptions.getCommands());
         containerConfigBuilder.memory(templateOptions.getMemory());
         containerConfigBuilder.hostname(templateOptions.getHostname());
         containerConfigBuilder.cpuShares(templateOptions.getCpuShares());
         containerConfigBuilder.openStdin(templateOptions.getOpenStdin());
         containerConfigBuilder.env(templateOptions.getEnv());

         if (!templateOptions.getVolumes().isEmpty()) {
            Map<String, Object> volumes = Maps.newLinkedHashMap();
            for (String containerDir : templateOptions.getVolumes().values()) {
               volumes.put(containerDir, Maps.newHashMap());
            }
            containerConfigBuilder.volumes(volumes);
         }

         HostConfig.Builder hostConfigBuilder = HostConfig.builder()
               .publishAllPorts(true)
               .privileged(templateOptions.getPrivileged());

         if (!templateOptions.getPortBindings().isEmpty()) {
            Map<String, List<Map<String, String>>> portBindings = Maps.newHashMap();
            for (Map.Entry<Integer, Integer> entry : templateOptions.getPortBindings().entrySet()) {
               portBindings.put(entry.getValue() + "/tcp",
                     Lists.<Map<String, String>>newArrayList(ImmutableMap.of("HostIp", "0.0.0.0", "HostPort", Integer.toString(entry.getKey()))));
            }
            hostConfigBuilder.portBindings(portBindings);
         }

         if (!templateOptions.getDns().isEmpty()) {
            hostConfigBuilder.dns(templateOptions.getDns());
         }

         if (!templateOptions.getExtraHosts().isEmpty()) {
            List<String> extraHosts = Lists.newArrayList();
            for (Map.Entry<String, String> entry : templateOptions.getExtraHosts().entrySet()) {
               extraHosts.add(entry.getKey() + ":" + entry.getValue());
            }
            hostConfigBuilder.extraHosts(extraHosts);
         }

         if (!templateOptions.getVolumes().isEmpty()) {
            List<String> binds = Lists.newArrayList();
            for (Map.Entry<String, String> entry : templateOptions.getVolumes().entrySet()) {
               binds.add(entry.getKey() + ":" + entry.getValue());
            }
            hostConfigBuilder.binds(ImmutableList.copyOf(binds));
         }

         if (!templateOptions.getVolumesFrom().isEmpty()) {
            hostConfigBuilder.volumesFrom(templateOptions.getVolumesFrom());
         }

         hostConfigBuilder.networkMode(templateOptions.getNetworkMode());

         containerConfigBuilder.hostConfig(hostConfigBuilder.build());

         // add the inbound ports into exposed ports map
         containerConfig = containerConfigBuilder.build();
         Map<String, Object> exposedPorts = Maps.newHashMap();
         if (containerConfig.exposedPorts() == null) {
            exposedPorts.putAll(containerConfig.exposedPorts());
         }
         for (int inboundPort : templateOptions.getInboundPorts()) {
            String portKey = inboundPort + "/tcp";
            if (!exposedPorts.containsKey(portKey)) {
               exposedPorts.put(portKey, Maps.newHashMap());
            }
         }
         containerConfigBuilder.exposedPorts(exposedPorts);

         // build once more after setting inboundPorts
         containerConfig = containerConfigBuilder.build();

         // finally update port bindings
         Map<String, List<Map<String, String>>> portBindings = Maps.newHashMap();
         Map<String, List<Map<String, String>>> existingBindings = containerConfig.hostConfig().portBindings();
         if (existingBindings != null) {
            portBindings.putAll(existingBindings);
         }
         for (String exposedPort : containerConfig.exposedPorts().keySet()) {
            if (!portBindings.containsKey(exposedPort)) {
               portBindings.put(exposedPort, Lists.<Map<String, String>>newArrayList(ImmutableMap.of("HostIp", "0.0.0.0")));
            }
         }
         hostConfigBuilder = HostConfig.builder().fromHostConfig(containerConfig.hostConfig());
         hostConfigBuilder.portBindings(portBindings);
         containerConfigBuilder.hostConfig(hostConfigBuilder.build());
      } else {
         containerConfigBuilder.image(imageId);
      }

      containerConfig = containerConfigBuilder.build();

      logger.debug(">> creating new container with containerConfig(%s)", containerConfig);
      Container container = api.getContainerApi().createContainer(name, containerConfig);
      logger.trace("<< container(%s)", container.id());

      if (templateOptions.getNetworks() != null) {
          logger.debug(">> connecting container(%s) to networks(%s)", container.id(), Iterables.toString(templateOptions.getNetworks()));
          for (String networkIdOrName : templateOptions.getNetworks()) {
              api.getNetworkApi().connectContainerToNetwork(networkIdOrName, container.id());
          }
          logger.trace("<< connected(%s)", container.id());
      }

      HostConfig hostConfig = containerConfig.hostConfig();

      logger.debug(">> starting container(%s) with hostConfig(%s)", container.id(), hostConfig);
      api.getContainerApi().startContainer(container.id(), hostConfig);
      logger.trace("<< started(%s)", container.id());

      container = api.getContainerApi().inspectContainer(container.id());
      return new NodeAndInitialCredentials(container, container.id(),
              LoginCredentials.builder().user(loginUser).password(loginUserPassword).build());
   }