public void testPropertyChangesDelimiter() { GroupNamingConvention fn = Guice.createInjector(new AbstractModule() { @Override protected void configure() { bindConstant().annotatedWith(Names.named(RESOURCENAME_DELIMITER)).to('#'); } }).getInstance(GroupNamingConvention.Factory.class).create(); assertEquals(fn.sharedNameForGroup("cluster"), "jclouds#cluster"); assertEquals(fn.groupInSharedNameOrNull("jclouds#cluster"), "cluster"); assertEquals(fn.groupInUniqueNameOrNull("jclouds#cluster"), null); assertTrue(fn.containsGroup("cluster").apply("jclouds#cluster")); }
@VisibleForTesting KeyPair createNewKeyPairInRegion(String region, String group) { checkNotNull(region, "region"); checkNotNull(group, "group"); logger.debug(">> creating keyPair region(%s) group(%s)", region, group); KeyPair keyPair = null; String prefix = group; while (keyPair == null) { String keyName = namingConvention.create().uniqueNameForGroup(prefix); try { keyPair = ec2Api.getKeyPairApi().get().createKeyPairInRegion(region, keyName); } catch (IllegalStateException e) { logger.trace(" invalid keyname (%s in %s); retrying", keyName, region); } } logger.debug("<< created keyPair(%s)", keyPair); return keyPair; } }
private String parseGroupFrom(final RunningInstance instance, final Set<String> data) { String group = null; try { Predicate<String> containsAnyGroup = namingConvention.create().containsAnyGroup(); String encodedGroup = Iterables.getOnlyElement(Iterables.filter(data, containsAnyGroup)); group = namingConvention.create().extractGroup(encodedGroup); } catch (NoSuchElementException e) { logger.debug("no group parsed from %s's data: %s", instance.getId(), data); } catch (IllegalArgumentException e) { logger.debug("too many groups match naming convention; %s's data: %s", instance.getId(), data); } return group; }
public void testCanChangeSuffixSupplier() { GroupNamingConvention fn = Guice.createInjector(new AbstractModule() { @Override protected void configure() { bind(new TypeLiteral<Supplier<String>>() { }).toInstance(Suppliers.ofInstance("foo")); } }).getInstance(GroupNamingConvention.Factory.class).create(); assertEquals(fn.uniqueNameForGroup("cluster"), "jclouds-cluster-foo"); // note accidental treatment of a unique node as a shared one can lead to // incorrect group names, as long as we permit delimiter to be in group name assertEquals(fn.groupInSharedNameOrNull("jclouds-cluster-foo"), "cluster-foo"); assertEquals(fn.groupInUniqueNameOrNull("jclouds-cluster-foo"), "cluster"); assertTrue(fn.containsGroup("cluster").apply("jclouds-cluster-foo")); }
private void cleanupOrphanedKeyPairsInZone(Set<String> groups, String zoneId) { Optional<? extends KeyPairApi> keyPairApi = novaApi.getKeyPairExtensionForZone(zoneId); if (keyPairApi.isPresent()) { for (String group : groups) { for (KeyPair pair : keyPairApi.get().list().filter(nameMatches(namingConvention.create().containsGroup(group)))) { ZoneAndName zoneAndName = ZoneAndName.fromZoneAndName(zoneId, pair.getName()); logger.debug(">> deleting keypair(%s)", zoneAndName); keyPairApi.get().delete(pair.getName()); // TODO: test this clear happens keyPairCache.invalidate(zoneAndName); logger.debug("<< deleted keypair(%s)", zoneAndName); } keyPairCache.invalidate(ZoneAndName.fromZoneAndName(zoneId, namingConvention.create().sharedNameForGroup(group))); } } }
@Override public NodeMetadata apply(ServerInfo serverInfo) { NodeMetadataBuilder builder = new NodeMetadataBuilder(); builder.ids(serverInfo.getUuid()); builder.name(serverInfo.getName()); builder.group(groupNamingConventionWithoutPrefix.extractGroup(serverInfo.getName())); builder.location(getOnlyElement(locations.get())); builder.hardware(new HardwareBuilder().ids(serverInfo.getUuid()).processor(new Processor(1, serverInfo.getCpu())) .ram(serverInfo.getMemory().intValue()) .volumes(Iterables.transform(serverInfo.getDrives(), serverDriveToVolume)).build()); builder.tags(readTags(serverInfo)); builder.userMetadata(serverInfo.getMeta()); builder.imageId(extractImageId(serverInfo)); builder.status(serverStatusToNodeStatus.get(serverInfo.getStatus())); builder.publicAddresses(filter(transform(serverInfo.getNics(), nicToAddress), notNull())); // CloudSigma does not provide a way to get the credentials. // Try to return them from the credential store Credentials credentials = credentialStore.get("node#" + serverInfo.getUuid()); if (credentials instanceof LoginCredentials) { builder.credentials(LoginCredentials.class.cast(credentials)); } return builder.build(); }
@VisibleForTesting void deleteKeyPair(String region, String group) { for (KeyPair keyPair : client.getKeyPairServices().describeKeyPairsInRegion(region)) { String keyName = keyPair.getKeyName(); Predicate<String> keyNameMatcher = namingConvention.create().containsGroup(group); String oldKeyNameRegex = String.format("jclouds#%s#%s#%s", group, region, "[0-9a-f]+").replace('#', delimiter); // old keypair pattern too verbose as it has an unnecessary region qualifier if (keyNameMatcher.apply(keyName) || keyName.matches(oldKeyNameRegex)) { Set<String> instancesUsingKeyPair = extractIdsFromInstances(filter(concat(client.getInstanceServices() .describeInstancesInRegion(region)), usingKeyPairAndNotDead(keyPair))); if (instancesUsingKeyPair.size() > 0) { logger.debug("<< inUse keyPair(%s), by (%s)", keyPair.getKeyName(), instancesUsingKeyPair); } else { logger.debug(">> deleting keyPair(%s)", keyPair.getKeyName()); client.getKeyPairServices().deleteKeyPairInRegion(region, keyPair.getKeyName()); // TODO: test this clear happens credentialsMap.remove(new RegionAndName(region, keyPair.getKeyName())); credentialsMap.remove(new RegionAndName(region, group)); logger.debug("<< deleted keyPair(%s)", keyPair.getKeyName()); } } } }
public SecurityGroup createSecurityGroup(String name, String region) { String markerGroup = namingConvention.create().sharedNameForGroup(name); RegionSecurityGroupNameAndPorts regionAndName = new RegionSecurityGroupNameAndPorts(region, markerGroup, ImmutableSet.<Integer> of()); SecurityGroupInRegion rawGroup = groupCreator.getUnchecked(regionAndName); return groupConverter.apply(rawGroup); }
private void configureSecurityGroupForOptions(String group, Location location, AzureTemplateOptions options) { checkArgument(options.getGroups().size() <= 1, "Only one security group can be configured for each network interface"); if (!options.getGroups().isEmpty()) { ResourceGroupAndName securityGroupId = ResourceGroupAndName.fromSlashEncoded(getOnlyElement(options.getGroups())); NetworkSecurityGroup securityGroup = api.getNetworkSecurityGroupApi(securityGroupId.resourceGroup()).get( securityGroupId.name()); checkArgument(securityGroup != null, "Security group %s was not found", securityGroupId.slashEncode()); options.securityGroups(securityGroup.id()); } else if (options.getInboundPorts().length > 0) { String name = namingConvention.create().sharedNameForGroup(group); ResourceGroupAndNameAndIngressRules regionAndIdAndIngressRules = ResourceGroupAndNameAndIngressRules.create( options.getResourceGroup(), location.getId(), name, options.getInboundPorts()); // this will create if not yet exists. String securityGroupId = securityGroupMap.getUnchecked(regionAndIdAndIngressRules); options.securityGroups(securityGroupId); } }
Location location = find(locations.get(), idEquals(dataCenter.location().getId())); .group(groupNamingConvention.extractGroup(server.name())) .hostname(server.hostname()) .name(server.name()) .operatingSystem(mapOsType(server.osType())) .location(location) .privateAddresses(Iterables.filter(addresses, IsPrivateIPAddress.INSTANCE)) .publicAddresses(Iterables.filter(addresses, not(IsPrivateIPAddress.INSTANCE)));
@VisibleForTesting void deleteKeyPair(String region, String group) { for (KeyPair keyPair : client.getKeyPairApi().get().describeKeyPairsInRegionWithFilter(region, ImmutableMultimap.<String, String>builder() .put("key-name", String.format("jclouds#%s#*", group).replace('#', delimiter)) .build())) { String keyName = keyPair.getKeyName(); Predicate<String> keyNameMatcher = namingConvention.create().containsGroup(group); String oldKeyNameRegex = String.format("jclouds#%s#%s#%s", group, region, "[0-9a-f]+").replace('#', delimiter); // old keypair pattern too verbose as it has an unnecessary region qualifier if (keyNameMatcher.apply(keyName) || keyName.matches(oldKeyNameRegex)) { Set<String> instancesUsingKeyPair = extractIdsFromInstances(concat(client.getInstanceApi().get() .describeInstancesInRegionWithFilter(region, ImmutableMultimap.<String, String>builder() .put("instance-state-name", InstanceState.TERMINATED.toString()) .put("instance-state-name", InstanceState.SHUTTING_DOWN.toString()) .put("key-name", keyPair.getKeyName()).build()))); if (!instancesUsingKeyPair.isEmpty()) { logger.debug("<< inUse keyPair(%s), by (%s)", keyPair.getKeyName(), instancesUsingKeyPair); } else { logger.debug(">> deleting keyPair(%s)", keyPair.getKeyName()); client.getKeyPairApi().get().deleteKeyPairInRegion(region, keyPair.getKeyName()); // TODO: test this clear happens credentialsMap.remove(new RegionAndName(region, keyPair.getKeyName())); credentialsMap.remove(new RegionAndName(region, group)); logger.debug("<< deleted keyPair(%s)", keyPair.getKeyName()); } } } }
@Override public NodeMetadata apply(Container container) { String name = cleanUpName(container.name()); String group = nodeNamingConvention.extractGroup(name); NodeMetadataBuilder builder = new NodeMetadataBuilder(); builder.ids(container.id()) .name(name) .group(group) .hostname(container.config().hostname()) // TODO Set up hardware .hardware(new HardwareBuilder() .id("") .ram(container.config().memory()) .processor(new Processor(container.config().cpuShares(), container.config().cpuShares())) .build()); builder.status(toPortableStatus.apply(container.state())); builder.loginPort(loginPortForContainer.apply(container).or(NO_LOGIN_PORT)); builder.publicAddresses(getPublicIpAddresses(container)); builder.privateAddresses(getPrivateIpAddresses(container)); builder.location(Iterables.getOnlyElement(locations.get())); String imageId = container.image(); builder.imageId(imageId); if (images.get().containsKey(imageId)) { Image image = images.get().get(imageId); builder.operatingSystem(image.getOperatingSystem()); } return builder.build(); }
@Override public NodeMetadata apply(ServerInfo from) { NodeMetadataBuilder builder = new NodeMetadataBuilder(); builder.ids(from.getUuid()); builder.name(from.getName()); builder.location(locationSupplier.get()); builder.group(nodeNamingConvention.groupInUniqueNameOrNull(from.getName())); String imageId = getImageIdFromServer.apply(from); if (imageId != null) { Optional<? extends Image> image = FluentIterable.from(images.get()).firstMatch(idEquals(imageId)); if (image.isPresent()) { builder.operatingSystem(image.get().getOperatingSystem()); } } builder.hardware(new HardwareBuilder().ids(from.getUuid()).hypervisor("kvm") .processors(ImmutableList.of(new Processor(1, from.getCpu()))).ram(from.getMem()) .volumes(Iterables.transform(from.getDevices().values(), deviceToVolume)).build()); builder.status(serverStatusToNodeStatus.get(from.getStatus())); builder.publicAddresses(ImmutableSet.<String> of(from.getVnc().getIp())); builder.privateAddresses(ImmutableSet.<String> of()); return builder.build(); }
@Override public SecurityGroup createSecurityGroup(String name, Location location) { String region = location.getId(); if (region == null) { return null; } logger.debug(">> creating security group %s in %s...", name, location); String markerGroup = namingConvention.create().sharedNameForGroup(name); RegionSecurityGroupNameAndPorts regionAndName = new RegionSecurityGroupNameAndPorts(region, markerGroup, ImmutableSet.<Integer> of()); return groupCreator.getUnchecked(regionAndName); }
@Override public NodeMetadata apply(Server from) { NodeMetadataBuilder builder = new NodeMetadataBuilder(); builder.ids(from.getId() + ""); builder.name(from.getName()); Location location = Iterables.find(locations.get(), LocationPredicates.idEquals(from.getDatacenter().getId() + "")); builder.location(location); builder.group(nodeNamingConvention.groupInUniqueNameOrNull(from.getName())); builder.hardware(parseHardware(from)); builder.imageId(from.getImage().getId() + ""); Image image = parseImage(from); if (image != null) builder.operatingSystem(image.getOperatingSystem()); builder.status(serverStateToNodeStatus.get(from.getState())); builder.publicAddresses(ImmutableSet.of(from.getIp().getIp())); return builder.build(); }
Set<String> nodeNames = template.getOptions().getNodeNames(); if (nodeNames.size() >= count) { return ImmutableSet.copyOf(Iterables.limit(nodeNames, count)); } else { names.addAll(nodeNames); int currentTries = 0; while (names.size() < count && currentTries++ < maxTries) { final String name = namingConvention.createWithoutPrefix().uniqueNameForGroup(group); if (!any(currentNodes, new Predicate<ComputeMetadata>() {
/** * @throws IllegalStateException If the security group was in use */ @VisibleForTesting void deleteSecurityGroup(String region, String group) { checkNotNull(emptyToNull(region), "region must be defined"); checkNotNull(emptyToNull(group), "group must be defined"); String groupName = namingConvention.create().sharedNameForGroup(group); if (!client.getSecurityGroupApi().get().describeSecurityGroupsInRegion(region, groupName).isEmpty()) { logger.debug(">> deleting securityGroup(%s)", groupName); client.getSecurityGroupApi().get().deleteSecurityGroupInRegion(region, groupName); // TODO: test this clear happens securityGroupMap.invalidate(new RegionNameAndIngressRules(region, groupName, null, false, null)); logger.debug("<< deleted securityGroup(%s)", groupName); } }
private KeyPair generateKeyPair(String region, String prefix) { logger.debug(">> creating default keypair for node..."); KeyPair keyPair = novaApi.getKeyPairApi(region).get().create(namingConvention.createWithoutPrefix().uniqueNameForGroup(prefix)); logger.debug(">> keypair created! %s", keyPair.getName()); return keyPair; }
/** * Find the next node names that can be used. These will be derived from the group and the * template. We will pre-allocate a specified quantity, and attempt to verify that there is no * name conflict with the current service. * * @param group * @param count * @param template * @return */ protected Set<String> getNextNames(final String group, final Template template, int count) { Set<String> names = newLinkedHashSet(); Iterable<? extends ComputeMetadata> currentNodes = listNodesStrategy.listNodes(); int maxTries = 100; int currentTries = 0; while (names.size() < count && currentTries++ < maxTries) { final String name = namingConvention.createWithoutPrefix().uniqueNameForGroup(group); if (!any(currentNodes, new Predicate<ComputeMetadata>() { @Override public boolean apply(ComputeMetadata input) { return name.equals(input.getName()); } })) { names.add(name); } } return names; }
private void cleanUpFirewallsForGroup(final String groupName) { GroupNamingConvention namingScheme = namingConvention.create(); FirewallApi firewallApi = api.firewalls(); for (Firewall firewall : concat(firewallApi.list())) { String foundGroup = namingScheme.groupInUniqueNameOrNull(firewall.name()); if ((foundGroup != null) && foundGroup.equals(groupName)){ AtomicReference<Operation> operation = Atomics.newReference(firewallApi.delete(firewall.name())); operationDone.apply(operation); if (operation.get().httpErrorStatusCode() != null) { logger.warn("delete orphaned firewall %s failed. Http Error Code: %d HttpError: %s", operation.get().targetId(), operation.get().httpErrorStatusCode(), operation.get().httpErrorMessage()); } } } }