@Override public NodeMetadata createNodeWithGroupEncodedIntoNameThenStoreCredentials( String group, String name, Template template, Map<String, Credentials> credentialStore) { NodeMetadataBuilder builder = new NodeMetadataBuilder(); String id = idProvider.get() + ""; builder.ids(id); builder.name(name); // using a predictable name so tests will pass builder.hostname(group); builder.tags(template.getOptions().getTags()); builder.group(group); builder.location(location.get()); builder.imageId(template.getImage().getId()); builder.operatingSystem(template.getImage().getOperatingSystem()); builder.state(NodeState.PENDING); builder.publicAddresses(ImmutableSet.<String>of(publicIpPrefix + id)); builder.privateAddresses(ImmutableSet.<String>of(privateIpPrefix + id)); Credentials creds = template.getOptions().getOverridingCredentials(); if (creds == null) creds = new Credentials(null, null); if (creds.identity == null) creds = creds.toBuilder().identity("root").build(); if (creds.credential == null) creds = creds.toBuilder().credential(passwordPrefix + id).build(); builder.credentials(creds); NodeMetadata node = builder.build(); credentialStore.put("node#" + node.getId(), node.getCredentials()); nodes.put(node.getId(), node); StubComputeServiceDependenciesModule.setState(node, NodeState.RUNNING, 100); return node; }
public RunInstancesOptions execute(String region, String group, Template template) { RunInstancesOptions instanceOptions = getOptionsProvider().get().asType(template.getHardware().getId()); String keyPairName = createNewKeyPairUnlessUserSpecifiedOtherwise(region, group, template.getOptions()); addSecurityGroups(region, group, template, instanceOptions); if (template.getOptions() instanceof EC2TemplateOptions) { if (keyPairName != null) instanceOptions.withKeyName(keyPairName); byte[] userData = EC2TemplateOptions.class.cast(template.getOptions()).getUserData(); if (userData != null) instanceOptions.withUserData(userData); Set<BlockDeviceMapping> blockDeviceMappings = EC2TemplateOptions.class.cast(template.getOptions()).getBlockDeviceMappings(); if (!blockDeviceMappings.isEmpty()) { checkState( "ebs".equals(template.getImage().getUserMetadata().get("rootDeviceType")), "BlockDeviceMapping only available on ebs boot"); instanceOptions.withBlockDeviceMappings(blockDeviceMappings); } String clientToken = EC2TemplateOptions.class.cast(template.getOptions()).getClientToken(); if (clientToken != null) { instanceOptions.withClientToken(clientToken); } } return instanceOptions; }
@Override public Map<?, ListenableFuture<Void>> execute( String group, int count, Template template, Set<NodeMetadata> goodNodes, Map<NodeMetadata, Exception> badNodes, Multimap<NodeMetadata, CustomizationResponse> customizationResponses) { Template mutableTemplate = template.clone(); Set<RunningInstance> started = runInstancesAndWarnOnInvisible(group, count, mutableTemplate); if (started.size() == 0) { logger.warn("<< unable to start instances(%s)", mutableTemplate); return ImmutableMap.of(); } populateCredentials(started, template.getOptions()); if (autoAllocateElasticIps) // before customization as the elastic ips may be needed blockUntilRunningAndAssignElasticIpsToInstancesOrPutIntoBadMap(started, badNodes); return utils.customizeNodesAndAddToGoodMapOrPutExceptionIntoBadMap( mutableTemplate.getOptions(), transform(started, runningInstanceToNodeMetadata), goodNodes, badNodes, customizationResponses); }
@Test(enabled = true, dependsOnMethods = "testCreateTwoNodesWithRunScript") public void testCreateTwoNodesWithOneSpecifiedName() throws Exception { template = buildTemplate(client.templateBuilder()); template.getOptions().nodeNames(ImmutableSet.of("first-node")); Set<? extends NodeMetadata> nodes; try { nodes = newTreeSet(client.createNodesInGroup(group, 2, template)); } catch (RunNodesException e) { nodes = newTreeSet(concat(e.getSuccessfulNodes(), e.getNodeErrors().keySet())); throw e; } assertEquals(nodes.size(), 2, "expected two nodes but was " + nodes); NodeMetadata node1 = Iterables.getFirst(nodes, null); NodeMetadata node2 = Iterables.getLast(nodes, null); // credentials aren't always the same // assertEquals(node1.getCredentials(), node2.getCredentials()); assertTrue( node1.getName().equals("first-node") || node2.getName().equals("first-node"), "one node should be named 'first-node'"); assertFalse( node1.getName().equals("first-node") && node2.getName().equals("first-node"), "one node should be named something other than 'first-node"); this.nodes.addAll(nodes); }
@Test(enabled = true, dependsOnMethods = "testTemplateMatch") public void testCreateTwoNodesWithRunScript() throws Exception { try { client.destroyNodesMatching(NodePredicates.withTag(tag)); } catch (HttpResponseException e) { // TODO hosting.com throws 400 when we try to delete a vApp } catch (NoSuchElementException e) { } template = buildTemplate(client.templateBuilder()); template .getOptions() .installPrivateKey(keyPair.get("private")) .authorizePublicKey(keyPair.get("public")) .runScript(buildScript(template.getImage().getOsFamily()).getBytes()); try { nodes = Sets.newTreeSet(client.runNodesWithTag(tag, 2, template)); } catch (RunNodesException e) { nodes = Sets.newTreeSet(Iterables.concat(e.getSuccessfulNodes(), e.getNodeErrors().keySet())); throw e; } assertEquals(nodes.size(), 2); checkNodes(nodes, tag); NodeMetadata node1 = nodes.first(); NodeMetadata node2 = nodes.last(); // credentials aren't always the same // assertEquals(node1.getCredentials(), node2.getCredentials()); assertLocationSameOrChild(node1.getLocation(), template.getLocation()); assertLocationSameOrChild(node2.getLocation(), template.getLocation()); assertEquals(node1.getImage(), template.getImage()); assertEquals(node2.getImage(), template.getImage()); }
@Test(enabled = true) public void testCreateAndRunAService() throws Exception { String tag = this.tag + "service"; try { client.destroyNodesMatching(withTag(tag)); } catch (Exception e) { } template = client .templateBuilder() .options(blockOnComplete(false).blockOnPort(8080, 600).inboundPorts(22, 8080)) .build(); // note this is a dependency on the template resolution template .getOptions() .runScript( RunScriptData.createScriptInstallAndStartJBoss( keyPair.get("public"), template.getImage().getOperatingSystem())); try { NodeMetadata node = getOnlyElement(client.runNodesWithTag(tag, 1, template)); checkHttpGet(node); } finally { client.destroyNodesMatching(withTag(tag)); } }
@Test(enabled = true /* , dependsOnMethods = "testTemplateMatch" */) public void testTemplateOptions() throws Exception { TemplateOptions options = new TemplateOptions().withMetadata(); Template t = client.templateBuilder().smallest().options(options).build(); assert t.getOptions().isIncludeMetadata() : "The metadata option should be 'true' " + "for the created template"; }
private void refreshTemplate() { template = buildTemplate(client.templateBuilder()); template .getOptions() .installPrivateKey(keyPair.get("private")) .authorizePublicKey(keyPair.get("public")) .runScript(buildScript(template.getImage().getOperatingSystem())); }
@Override public NodeAndInitialCredentials<ServerInfo> createNodeWithGroupEncodedIntoName( String tag, String name, Template template) { long bootSize = (long) (template.getHardware().getVolumes().get(0).getSize() * 1024 * 1024 * 1024l); AffinityType affinityType = AffinityType.HDD; if (template.getOptions() instanceof CloudSigmaTemplateOptions) { CloudSigmaTemplateOptions options = CloudSigmaTemplateOptions.class.cast(template.getOptions()); affinityType = options.getDiskDriveAffinity(); } logger.debug( ">> imaging boot drive source(%s) bytes(%d) affinityType(%s)", template.getImage().getId(), bootSize, affinityType); DriveInfo drive = client.cloneDrive( template.getImage().getId(), template.getImage().getId(), new CloneDriveOptions().size(bootSize).affinity(affinityType)); boolean success = driveNotClaimed.apply(drive); logger.debug("<< image(%s) complete(%s)", drive.getUuid(), success); if (!success) { client.destroyDrive(drive.getUuid()); throw new IllegalStateException("could not image drive in time!"); } Server toCreate = Servers.small(name, drive.getUuid(), defaultVncPassword) .mem(template.getHardware().getRam()) .cpu((int) (template.getHardware().getProcessors().get(0).getSpeed())) .build(); logger.debug(">> creating server"); ServerInfo from = client.createServer(toCreate); logger.debug("<< created server(%s)", from.getUuid()); logger.debug(">> starting server(%s)", from.getUuid()); client.startServer(from.getUuid()); return new NodeAndInitialCredentials<ServerInfo>( from, from.getUuid(), LoginCredentials.builder().password(defaultVncPassword).authenticateSudo(true).build()); }
public void testCreateNodeWithGroupEncodedIntoNameThenStoreCredentials() { String group = "foo"; String name = "container" + new Random().nextInt(); Template template = templateBuilder.imageId(defaultImage.id()).build(); DockerTemplateOptions options = template.getOptions().as(DockerTemplateOptions.class); options.env(ImmutableList.of("ROOT_PASSWORD=password")); guest = adapter.createNodeWithGroupEncodedIntoName(group, name, template); assertEquals(guest.getNodeId(), guest.getNode().id()); }
@Test public void testDefaultTemplateBuilder() throws IOException { Template defaultTemplate = view.getComputeService().templateBuilder().build(); assertEquals(defaultTemplate.getImage().getOperatingSystem().getVersion(), "10.04"); assertEquals(defaultTemplate.getImage().getOperatingSystem().is64Bit(), true); assertEquals(defaultTemplate.getImage().getOperatingSystem().getFamily(), OsFamily.UBUNTU); assertEquals(getCores(defaultTemplate.getHardware()), 1.0d); assertEquals(defaultTemplate.getHardware().getRam(), 1); assertEquals(getSpace(defaultTemplate.getHardware()), 25.0d); assertEquals(defaultTemplate.getHardware().getVolumes().get(0).getType(), Volume.Type.LOCAL); // test that we bound the correct templateoptions in guice assertEquals(defaultTemplate.getOptions().getClass(), SoftLayerTemplateOptions.class); }
protected void createAndRunAServiceInGroup(String group) throws RunNodesException { // note that some cloud providers do not support mixed case tag names ImmutableMap<String, String> userMetadata = ImmutableMap.<String, String>of("test", group); ImmutableSet<String> tags = ImmutableSet.of(group); Stopwatch watch = Stopwatch.createStarted(); template = buildTemplate(client.templateBuilder()); template .getOptions() .inboundPorts(22, 8080) .blockOnPort(22, 300) .userMetadata(userMetadata) .tags(tags); NodeMetadata node = getOnlyElement(client.createNodesInGroup(group, 1, template)); long createSeconds = watch.elapsed(TimeUnit.SECONDS); final String nodeId = node.getId(); checkUserMetadataContains(node, userMetadata); checkTagsInNodeEquals(node, tags); getAnonymousLogger() .info( format( "<< available node(%s) os(%s) in %ss", node.getId(), node.getOperatingSystem(), createSeconds)); watch.reset().start(); client.runScriptOnNode(nodeId, JettyStatements.install(), nameTask("configure-jetty")); long configureSeconds = watch.elapsed(TimeUnit.SECONDS); getAnonymousLogger() .info( format( "<< configured node(%s) with %s and jetty %s in %ss", nodeId, exec(nodeId, "java -fullversion"), exec(nodeId, JettyStatements.version()), configureSeconds)); trackAvailabilityOfProcessOnNode(JettyStatements.start(), "start jetty", node); client.runScriptOnNode( nodeId, JettyStatements.stop(), runAsRoot(false).wrapInInitScript(false)); trackAvailabilityOfProcessOnNode(JettyStatements.start(), "start jetty", node); }
private void setSecurityGroupOnTemplate( final JcloudsLocation location, final Template template, final SecurityGroupExtension securityApi) { SecurityGroup shared; Tasks.setBlockingDetails( "Loading security group shared by instances in " + template.getLocation() + " in app " + applicationId); try { shared = sharedGroupCache.get( template.getLocation(), new Callable<SecurityGroup>() { @Override public SecurityGroup call() throws Exception { return getOrCreateSharedSecurityGroup(template.getLocation(), securityApi); } }); } catch (ExecutionException e) { throw Throwables.propagate(new Exception(e.getCause())); } finally { Tasks.resetBlockingDetails(); } Set<String> originalGroups = template.getOptions().getGroups(); template.getOptions().securityGroups(shared.getName()); if (!originalGroups.isEmpty()) { LOG.info( "Replaced configured security groups: configured={}, replaced with={}", originalGroups, template.getOptions().getGroups()); } else { LOG.debug( "Configured security groups at {} to: {}", location, template.getOptions().getGroups()); } }
public Set<NodeMetadata> createNodes(int count) throws RunNodesException { Set<NodeMetadata> result = Sets.newHashSet(); Template template = mComputeService.templateBuilder().hardwareId(mInstanceType).imageId(mImageId).build(); template .getOptions() .as(AWSEC2TemplateOptions.class) .keyPair(mkeyPair) .securityGroupIds(mSecurityGroup) .blockOnPort(22, 60) .spotPrice(mMaxBid) .tags(Collections.singletonList(mGroupTag)); result.addAll(mComputeService.createNodesInGroup(mGroupName, count, template)); return result; }
private LoginCredentials resolveNodeCredentials(Template template) { TemplateOptions options = template.getOptions(); LoginCredentials.Builder credentials = LoginCredentials.builder(template.getImage().getDefaultCredentials()); if (!Strings.isNullOrEmpty(options.getLoginUser())) { credentials.user(options.getLoginUser()); } if (!Strings.isNullOrEmpty(options.getLoginPrivateKey())) { credentials.privateKey(options.getLoginPrivateKey()); } if (!Strings.isNullOrEmpty(options.getLoginPassword())) { credentials.password(options.getLoginPassword()); } if (options.shouldAuthenticateSudo() != null) { credentials.authenticateSudo(options.shouldAuthenticateSudo()); } return credentials.build(); }
public void testStartCCInstance() throws Exception { Template template = view.getComputeService() .templateBuilder() .fromHardware(EC2HardwareBuilder.cc2_8xlarge().build()) .osFamily(OsFamily.AMZN_LINUX) .build(); assert template != null : "The returned template was null, but it should have a value."; assertEquals(template.getHardware().getProviderId(), InstanceType.CC2_8XLARGE); assertEquals(template.getImage().getUserMetadata().get("rootDeviceType"), "ebs"); assertEquals(template.getImage().getUserMetadata().get("virtualizationType"), "hvm"); assertEquals(template.getImage().getUserMetadata().get("hypervisor"), "xen"); template .getOptions() .runScript(Statements.newStatementList(AdminAccess.standard(), InstallJDK.fromOpenJDK())); String group = PREFIX + "cccluster"; view.getComputeService().destroyNodesMatching(NodePredicates.inGroup(group)); // TODO make this not lookup an explicit region client .getPlacementGroupApi() .get() .deletePlacementGroupInRegion(null, "jclouds#" + group + "#us-east-1"); try { Set<? extends NodeMetadata> nodes = view.getComputeService().createNodesInGroup(group, 1, template); NodeMetadata node = getOnlyElement(nodes); getOnlyElement( getOnlyElement( client.getInstanceApi().get().describeInstancesInRegion(null, node.getProviderId()))); } catch (RunNodesException e) { System.err.println(e.getNodeErrors().keySet()); Throwables.propagate(e); } finally { view.getComputeService().destroyNodesMatching(NodePredicates.inGroup(group)); } }
@Test(enabled = true, dependsOnMethods = "testCompareSizes") public void testConcurrentUseOfComputeServiceToCreateNodes() throws Exception { final long timeoutMs = 20 * 60 * 1000; List<String> groups = Lists.newArrayList(); List<ListenableFuture<NodeMetadata>> futures = Lists.newArrayList(); ListeningExecutorService userExecutor = context .utils() .injector() .getInstance( Key.get(ListeningExecutorService.class, Names.named(PROPERTY_USER_THREADS))); try { for (int i = 0; i < 2; i++) { final int groupNum = i; final String group = "twin" + groupNum; groups.add(group); template = buildTemplate(client.templateBuilder()); template.getOptions().inboundPorts(22, 8080).blockOnPort(22, 300 + groupNum); ListenableFuture<NodeMetadata> future = userExecutor.submit( new Callable<NodeMetadata>() { public NodeMetadata call() throws Exception { NodeMetadata node = getOnlyElement(client.createNodesInGroup(group, 1, template)); getAnonymousLogger().info("Started node " + node.getId()); return node; } }); futures.add(future); } ListenableFuture<List<NodeMetadata>> compoundFuture = Futures.allAsList(futures); compoundFuture.get(timeoutMs, TimeUnit.MILLISECONDS); } finally { for (String group : groups) { client.destroyNodesMatching(inGroup(group)); } } }
@Override public NodeMetadata createNodeWithGroupEncodedIntoName( String group, String name, Template template) { Server addedServer = null; boolean notStarted = true; int numOfRetries = 20; GetIpListOptions unassignedIps = new GetIpListOptions() .onlyUnassigned() .inDatacenter(template.getLocation().getId()) .onlyWithType(IpType.PUBLIC); // lock-free consumption of a shared resource: IP address pool while (notStarted) { // TODO: replace with Predicate-based thread // collision avoidance for simplicity Set<Ip> availableIps = client.getIpServices().getIpList(unassignedIps); if (availableIps.isEmpty()) throw new RuntimeException("No IPs available on this identity."); int ipIndex = new SecureRandom().nextInt(availableIps.size()); Ip availableIp = Iterables.get(availableIps, ipIndex); try { addedServer = addServer(name, template, availableIp); notStarted = false; } catch (Exception e) { if (--numOfRetries == 0) Throwables.propagate(e); notStarted = true; } } if (template.getOptions().shouldBlockUntilRunning()) { serverLatestJobCompleted.apply(addedServer); client.getServerServices().power(addedServer.getName(), PowerCommand.START); serverLatestJobCompletedShort.apply(addedServer); addedServer = Iterables.getOnlyElement( client.getServerServices().getServersByName(addedServer.getName())); } Credentials credentials = client.getServerServices().getServerCredentialsList().get(addedServer.getName()); if (credentials != null) credentialStore.put("node#" + addedServer.getId(), credentials); else logger.warn("couldn't get credentials for server %s", addedServer.getName()); return serverToNodeMetadata.apply(addedServer); }
public void testOptionToNotBlock() throws Exception { String group = this.group + "block"; try { client.destroyNodesMatching(inGroup(group)); } catch (Exception e) { } // no inbound ports template = buildTemplate(client.templateBuilder()); template.getOptions().blockUntilRunning(false).inboundPorts(); try { long time = currentTimeMillis(); Set<? extends NodeMetadata> nodes = client.createNodesInGroup(group, 1, template); NodeMetadata node = getOnlyElement(nodes); assert node.getStatus() != Status.RUNNING : node; long duration = (currentTimeMillis() - time) / 1000; assert duration < nonBlockDurationSeconds : format( "duration(%d) longer than expected(%d) seconds! ", duration, nonBlockDurationSeconds); } finally { client.destroyNodesMatching(inGroup(group)); } }
public void buildTemplate() { IaasProvider iaasInfo = getIaasProvider(); if (iaasInfo.getComputeService() == null) { String msg = "Compute service is null for IaaS provider: " + iaasInfo.getName(); log.fatal(msg); throw new CloudControllerException(msg); } TemplateBuilder templateBuilder = iaasInfo.getComputeService().templateBuilder(); // set image id specified templateBuilder.imageId(iaasInfo.getImage()); if (iaasInfo.getProperty(CloudControllerConstants.AVAILABILITY_ZONE) != null) { Set<? extends Location> locations = iaasInfo.getComputeService().listAssignableLocations(); for (Location location : locations) { if (location.getScope().toString().equalsIgnoreCase(CloudControllerConstants.ZONE_ELEMENT) && location .getId() .equals(iaasInfo.getProperty(CloudControllerConstants.AVAILABILITY_ZONE))) { templateBuilder.locationId(location.getId()); log.info( "ZONE has been set as " + iaasInfo.getProperty(CloudControllerConstants.AVAILABILITY_ZONE) + " with id: " + location.getId()); break; } } } if (iaasInfo.getProperty(CloudControllerConstants.INSTANCE_TYPE) != null) { // set instance type eg: m1.large templateBuilder.hardwareId(iaasInfo.getProperty(CloudControllerConstants.INSTANCE_TYPE)); } // build the Template Template template = templateBuilder.build(); if (iaasInfo.getProperty(CloudControllerConstants.AVAILABILITY_ZONE) != null) { if (!template .getLocation() .getId() .equals(iaasInfo.getProperty(CloudControllerConstants.AVAILABILITY_ZONE))) { log.warn( "couldn't find assignable ZONE of id :" + iaasInfo.getProperty(CloudControllerConstants.AVAILABILITY_ZONE) + " in the IaaS. " + "Hence using the default location as " + template.getLocation().getScope().toString() + " with the id " + template.getLocation().getId()); } } // if you wish to auto assign IPs, instance spawning call should be // blocking, but if you // wish to assign IPs manually, it can be non-blocking. // is auto-assign-ip mode or manual-assign-ip mode? boolean blockUntilRunning = Boolean.parseBoolean(iaasInfo.getProperty(CloudControllerConstants.AUTO_ASSIGN_IP)); template.getOptions().as(TemplateOptions.class).blockUntilRunning(blockUntilRunning); // this is required in order to avoid creation of additional security // groups by jclouds. template.getOptions().as(TemplateOptions.class).inboundPorts(); // set EC2 specific options if (iaasInfo.getProperty(CloudControllerConstants.ASSOCIATE_PUBLIC_IP_ADDRESS) != null) { boolean associatePublicIp = Boolean.parseBoolean( iaasInfo.getProperty(CloudControllerConstants.ASSOCIATE_PUBLIC_IP_ADDRESS)); if (associatePublicIp) { template.getOptions().as(AWSEC2TemplateOptions.class).associatePublicIpAddress(); } } if (iaasInfo.getProperty(CloudControllerConstants.SUBNET_ID) != null) { template .getOptions() .as(AWSEC2TemplateOptions.class) .subnetId(iaasInfo.getProperty(CloudControllerConstants.SUBNET_ID)); } if (iaasInfo.getProperty(CloudControllerConstants.AVAILABILITY_ZONE) != null) { template .getOptions() .as(AWSEC2TemplateOptions.class) .placementGroup(iaasInfo.getProperty(CloudControllerConstants.AVAILABILITY_ZONE)); } // security group names if (iaasInfo.getProperty(CloudControllerConstants.SECURITY_GROUPS) != null) { template .getOptions() .as(AWSEC2TemplateOptions.class) .securityGroups( iaasInfo .getProperty(CloudControllerConstants.SECURITY_GROUPS) .split(CloudControllerConstants.ENTRY_SEPARATOR)); } // ability to define tags if (iaasInfo.getProperty(CloudControllerConstants.TAGS) != null) { template .getOptions() .as(AWSEC2TemplateOptions.class) .tags( Arrays.asList( iaasInfo .getProperty(CloudControllerConstants.TAGS) .split(CloudControllerConstants.ENTRY_SEPARATOR))); } // ability to define tags with Key-value pairs Map<String, String> keyValuePairTagsMap = new HashMap<String, String>(); for (String propertyKey : iaasInfo.getProperties().keySet()) { if (propertyKey.startsWith(CloudControllerConstants.TAGS_AS_KEY_VALUE_PAIRS_PREFIX)) { keyValuePairTagsMap.put( propertyKey.substring(CloudControllerConstants.TAGS_AS_KEY_VALUE_PAIRS_PREFIX.length()), iaasInfo.getProperties().get(propertyKey)); template.getOptions().as(AWSEC2TemplateOptions.class).userMetadata(keyValuePairTagsMap); } } if (iaasInfo.getProperty(CloudControllerConstants.SECURITY_GROUP_IDS) != null) { template .getOptions() .as(AWSEC2TemplateOptions.class) .securityGroupIds( iaasInfo .getProperty(CloudControllerConstants.SECURITY_GROUP_IDS) .split(CloudControllerConstants.ENTRY_SEPARATOR)); } if (iaasInfo.getProperty(CloudControllerConstants.KEY_PAIR) != null) { template .getOptions() .as(AWSEC2TemplateOptions.class) .keyPair(iaasInfo.getProperty(CloudControllerConstants.KEY_PAIR)); } if (iaasInfo.getNetworkInterfaces() != null) { List<String> networks = new ArrayList<String>(iaasInfo.getNetworkInterfaces().length); for (NetworkInterface ni : iaasInfo.getNetworkInterfaces()) { networks.add(ni.getNetworkUuid()); } template.getOptions().as(AWSEC2TemplateOptions.class).networks(networks); } // set Template iaasInfo.setTemplate(template); }
public void testInstantiateVAppFromTemplateWhenUsingOverriddenNetworkAndFenceMode() throws Exception { String name = "group-abcd"; FenceMode fenceMode = FenceMode.NAT_ROUTED; URI parentNetwork = URI.create(ENDPOINT + "/v1.0/network/" + "foooooooo"); String instantiateXML = XMLBuilder.create("InstantiateVAppTemplateParams") .a("xmlns", ns) .a("xmlns:ovf", "http://schemas.dmtf.org/ovf/envelope/1") .a("deploy", "false") .a("name", name) .a("powerOn", "false") .e("Description") .up() .e("InstantiationParams") .e("NetworkConfigSection") .e("ovf:Info") .t("Configuration parameters for logical networks") .up() .e("NetworkConfig") .a("networkName", "jclouds") // NOTE not "None" .e("Configuration") .e("ParentNetwork") .a("href", parentNetwork.toASCIIString()) .up() .e("FenceMode") .t(fenceMode.toString()) .up() .up() .up() .up() .up() .e("Source") .a("href", ENDPOINT + "/v1.0/vAppTemplate/" + templateId) .up() .e("AllEULAsAccepted") .t("true") .up() .asString(outputProperties); HttpRequest version1_0InstantiateWithCustomizedNetwork = HttpRequest.builder() .method("POST") .endpoint(ENDPOINT + "/v1.0/vdc/" + vdcId + "/action/instantiateVAppTemplate") .addHeader(HttpHeaders.ACCEPT, "application/vnd.vmware.vcloud.vApp+xml") .addHeader("x-vcloud-authorization", sessionToken) .addHeader(HttpHeaders.COOKIE, "vcloud-token=" + sessionToken) .payload( payloadFromStringWithContentType( instantiateXML, "application/vnd.vmware.vcloud.instantiateVAppTemplateParams+xml")) .build(); ComputeService compute = requestsSendResponses( ImmutableMap.<HttpRequest, HttpResponse>builder() .put(versionsRequest, versionsResponseFromVCD1_5) .put( version1_0LoginRequest, successfulVersion1_0LoginResponseFromVCD1_5WithSingleOrg) .put( version1_0GetOrgRequest, successfulVersion1_0GetOrgResponseFromVCD1_5WithSingleTasksListVDCAndNetwork) .put( version1_0GetCatalogRequest, successfulVersion1_0GetCatalogResponseFromVCD1_5WithSingleTemplate) .put( version1_0GetCatalogItemRequest, successfulVersion1_0GetCatalogItemResponseFromVCD1_5ForTemplate) .put( version1_0GetVDCRequest, successfulVersion1_0GetVDCResponseFromVCD1_5WithSingleTemplateAndNetwork) .put( version1_0GetVAppTemplateRequest, successfulVersion1_0GetVAppTemplateResponseFromVCD1_5WithSingleVMAndVDCParent) .put( version1_0GetOVFForVAppTemplateRequest, successfulVersion1_0GetOVFForVAppTemplateResponseFromVCD1_5WithSingleVM) .put( version1_0InstantiateWithCustomizedNetwork, successfulVersion1_0InstantiatedVApp) .build()); InstantiateVAppTemplateWithGroupEncodedIntoNameThenCustomizeDeployAndPowerOn starter = compute .getContext() .utils() .injector() .getInstance( InstantiateVAppTemplateWithGroupEncodedIntoNameThenCustomizeDeployAndPowerOn.class); Template template = compute.templateBuilder().build(); template .getOptions() .as(VCloudTemplateOptions.class) .parentNetwork(parentNetwork) .fenceMode(fenceMode); starter.instantiateVAppFromTemplate(name, template); }
protected void addSecurityGroups( String region, String group, Template template, RunInstancesOptions instanceOptions) { Set<String> groups = getSecurityGroupsForTagAndOptions(region, group, template.getOptions()); instanceOptions.withSecurityGroups(groups); }
// since surefire and eclipse don't otherwise guarantee the order, we are // starting this one alphabetically before create2nodes.. @Test( enabled = true, dependsOnMethods = {"testCompareSizes"}) public void testAScriptExecutionAfterBootWithBasicTemplate() throws Exception { String group = this.group + "r"; try { client.destroyNodesMatching(inGroup(group)); } catch (Exception e) { } template = buildTemplate(client.templateBuilder()); template.getOptions().blockOnPort(22, 120); try { Set<? extends NodeMetadata> nodes = client.createNodesInGroup(group, 1, template); NodeMetadata node = get(nodes, 0); LoginCredentials good = node.getCredentials(); assert good.identity != null : nodes; for (Entry<? extends NodeMetadata, ExecResponse> response : client .runScriptOnNodesMatching( runningInGroup(group), "hostname", wrapInInitScript(false).runAsRoot(false).overrideLoginCredentials(good)) .entrySet()) { checkResponseEqualsHostname(response.getValue(), response.getKey()); } // test single-node execution ExecResponse response = client.runScriptOnNode( node.getId(), "hostname", wrapInInitScript(false).runAsRoot(false)); checkResponseEqualsHostname(response, node); OperatingSystem os = node.getOperatingSystem(); // test bad password tryBadPassword(group, good); runScriptWithCreds(group, os, good); checkNodes(nodes, group, "runScriptWithCreds"); // test adding AdminAccess later changes the default boot user, in this // case to foo, with home dir /over/ridden/foo ListenableFuture<ExecResponse> future = client.submitScriptOnNode( node.getId(), AdminAccess.builder().adminUsername("foo").adminHome("/over/ridden/foo").build(), nameTask("adminUpdate")); response = future.get(3, TimeUnit.MINUTES); assert response.getExitStatus() == 0 : node.getId() + ": " + response; node = client.getNodeMetadata(node.getId()); // test that the node updated to the correct admin user! assertEquals(node.getCredentials().identity, "foo"); assert node.getCredentials().credential != null : nodes; weCanCancelTasks(node); assert response.getExitStatus() == 0 : node.getId() + ": " + response; response = client.runScriptOnNode( node.getId(), "echo $USER", wrapInInitScript(false).runAsRoot(false)); assert response.getOutput().trim().equals("foo") : node.getId() + ": " + response; } finally { client.destroyNodesMatching(inGroup(group)); } }
@Override public NodeAndInitialCredentials<Instance> createNodeWithGroupEncodedIntoName( String group, String name, Template template) { GoogleComputeEngineTemplateOptions options = GoogleComputeEngineTemplateOptions.class.cast(template.getOptions()); checkNotNull(options.getNetworks(), "template options must specify a network"); checkNotNull(template.getHardware().getUri(), "hardware must have a URI"); checkNotNull(template.getImage().getUri(), "image URI is null"); List<AttachDisk> disks = Lists.newArrayList(); disks.add(AttachDisk.newBootDisk(template.getImage().getUri())); Iterator<String> networks = options.getNetworks().iterator(); URI network = URI.create(networks.next()); assert !networks.hasNext() : "Error: Options should specify only one network"; // Add tags from template ArrayList<String> tags = new ArrayList<String>(options.getTags()); // Add tags for firewalls FirewallTagNamingConvention naming = firewallTagNamingConvention.get(group); List<String> ports = simplifyPorts(options.getInboundPorts()); if (ports != null) { tags.add(naming.name(ports)); } NewInstance newInstance = new NewInstance.Builder( name, template.getHardware().getUri(), // machineType network, disks) .description(group) .tags(Tags.create(null, ImmutableList.copyOf(tags))) .serviceAccounts(options.serviceAccounts()) .build(); // Add metadata from template and for ssh key and image id newInstance.metadata().putAll(options.getUserMetadata()); LoginCredentials credentials = resolveNodeCredentials(template); if (options.getPublicKey() != null) { newInstance .metadata() .put( "sshKeys", format( "%s:%s %s@localhost", credentials.getUser(), options.getPublicKey(), credentials.getUser())); } String zone = template.getLocation().getId(); InstanceApi instanceApi = api.instancesInZone(zone); Operation create = instanceApi.create(newInstance); // We need to see the created instance so that we can access the newly created disk. AtomicReference<Instance> instance = Atomics.newReference( Instance.create( // "0000000000000000000", // id can't be null, but isn't available until provisioning // is done. null, // creationTimestamp create.targetLink(), // selfLink newInstance.name(), // name newInstance.description(), // description newInstance.tags(), // tags newInstance.machineType(), // machineType Instance.Status.PROVISIONING, // status null, // statusMessage create.zone(), // zone null, // canIpForward null, // networkInterfaces null, // disks newInstance.metadata(), // metadata newInstance.serviceAccounts(), // serviceAccounts Scheduling.create(OnHostMaintenance.MIGRATE, true) // scheduling )); checkState(instanceVisible.apply(instance), "instance %s is not api visible!", instance.get()); // Add lookup for InstanceToNodeMetadata diskToSourceImage.put(instance.get().disks().get(0).source(), template.getImage().getUri()); return new NodeAndInitialCredentials<Instance>( instance.get(), instance.get().selfLink().toString(), credentials); }
protected static Template addRunScriptToTemplate(Template template) { template .getOptions() .runScript(Statements.newStatementList(AdminAccess.standard(), InstallJDK.fromOpenJDK())); return template; }
@Test public void testFromSpecWithLoginUser() { final Supplier<Set<? extends Location>> locations = Suppliers.<Set<? extends Location>>ofInstance(ImmutableSet.<Location>of(region)); final Supplier<Set<? extends Image>> images = Suppliers.<Set<? extends Image>>ofInstance( ImmutableSet.<Image>of( new ImageBuilder() .id("us-east-2/ami-ffff") .providerId("ami-ffff") .name("Ubuntu 11.04 x64") .description("Ubuntu 11.04 x64") .location(region2) .status(Status.AVAILABLE) .operatingSystem( OperatingSystem.builder() .name("Ubuntu 11.04 x64") .description("Ubuntu 11.04 x64") .is64Bit(true) .version("11.04") .family(OsFamily.UBUNTU) .build()) .build())); final Supplier<Set<? extends Hardware>> hardwares = Suppliers.<Set<? extends Hardware>>ofInstance( ImmutableSet.<Hardware>of( new HardwareBuilder() .ids("m1.small") .ram(512) .processors(ImmutableList.of(new Processor(1, 1.0))) .volumes(ImmutableList.<Volume>of(new VolumeImpl((float) 5, true, true))) .build())); final Provider<TemplateOptions> optionsProvider = new Provider<TemplateOptions>() { @Override public TemplateOptions get() { return new TemplateOptions(); } }; Provider<TemplateBuilder> templateBuilderProvider = new Provider<TemplateBuilder>() { @Override public TemplateBuilder get() { return createTemplateBuilder( null, locations, images, hardwares, region, optionsProvider, this); } }; TemplateBuilder templateBuilder = templateBuilderProvider .get() .from( "hardwareId=m1.small,imageId=us-east-2/ami-ffff,loginUser=user:Password01,authenticateSudo=true"); assertEquals(templateBuilder.toString(), "{imageId=us-east-2/ami-ffff, hardwareId=m1.small}"); Template template = templateBuilder.build(); assertEquals(template.getLocation().getId(), "us-east-2"); assertEquals(template.getOptions().getLoginUser(), "user"); assertEquals(template.getOptions().getLoginPassword(), "Password01"); assertEquals(template.getOptions().getLoginPrivateKey(), null); assertEquals(template.getOptions().shouldAuthenticateSudo(), Boolean.TRUE); }