Refine search
@Inject ServerToNodeMetadata(Map<String, Credentials> credentialStore, @Memoized Supplier<Set<? extends Hardware>> hardware, @Memoized Supplier<Set<? extends Location>> locations, @Memoized Supplier<Set<? extends Image>> images, GroupNamingConvention.Factory namingConvention) { this.nodeNamingConvention = checkNotNull(namingConvention, "namingConvention").createWithoutPrefix(); this.credentialStore = checkNotNull(credentialStore, "credentialStore"); this.hardware = checkNotNull(hardware, "hardware"); this.locations = checkNotNull(locations, "locations"); this.images = checkNotNull(images, "images"); }
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 cleanupOrphanedSecurityGroupsInZone(Set<String> groups, String zoneId) { Zone zone = zoneIdToZone.get().getUnchecked(zoneId); if (supportsSecurityGroups().apply(zone)) { for (String group : groups) { for (SecurityGroup securityGroup : Iterables.filter(client.getSecurityGroupApi().listSecurityGroups(), SecurityGroupPredicates.nameMatches(namingConvention.create().containsGroup(group)))) { ZoneAndName zoneAndName = ZoneAndName.fromZoneAndName(zoneId, securityGroup.getName()); logger.debug(">> deleting securityGroup(%s)", zoneAndName); client.getSecurityGroupApi().deleteSecurityGroup(securityGroup.getId()); // TODO: test this clear happens securityGroupMap.invalidate(zoneAndName); logger.debug("<< deleted securityGroup(%s)", zoneAndName); } } } }
@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); }
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 Map<?, Future<Void>> execute(String group, int count, Template template, Set<NodeMetadata> goodNodes, Map<NodeMetadata, Exception> badNodes, Multimap<NodeMetadata, CustomizationResponse> customizationResponses) { Template mutableTemplate = template.clone(); SDCTemplateOptions templateOptions = SDCTemplateOptions.class.cast(mutableTemplate.getOptions()); assert template.getOptions().equals(templateOptions) : "options didn't clone properly"; String datacenter = mutableTemplate.getLocation().getId(); if (templateOptions.shouldGenerateKey()) { KeyAndPrivateKey keyPair = keyCache.getUnchecked(DatacenterAndName.fromDatacenterAndName(datacenter, namingConvention.create() .sharedNameForGroup(group))); // in order to delete the key later keyCache.asMap().put(DatacenterAndName.fromDatacenterAndName(datacenter, keyPair.getKey().getName()), keyPair); templateOptions.overrideLoginPrivateKey(keyPair.getPrivateKey()); } checkArgument(templateOptions.getRunScript() == null || templateOptions.getLoginPrivateKey() != null, "when specifying runScript, you must either set overrideLoginPrivateKey, or generateKey(true)"); return super.execute(group, count, mutableTemplate, goodNodes, badNodes, customizationResponses); } }
/** * @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); Multimap<String, String> securityGroupFilterByName = ImmutableMultimap.of("group-name", groupName); Set<SecurityGroup> securityGroupsToDelete = client.getSecurityGroupApi().get() .describeSecurityGroupsInRegionWithFilter(region, securityGroupFilterByName); if (securityGroupsToDelete.size() > 1) { logger.warn("When trying to delete security group %s found more than one matching the name. Will delete all - %s.", group, securityGroupsToDelete); } for (SecurityGroup securityGroup : securityGroupsToDelete) { logger.debug(">> deleting securityGroup(%s)", groupName); client.getSecurityGroupApi().get().deleteSecurityGroupInRegionById(region, securityGroup.getId()); securityGroupMap.invalidate(new RegionNameAndIngressRules(region, groupName, null, false, null)); logger.debug("<< deleted securityGroup(%s)", groupName); } }
/** * @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 void cleanupOrphanedSecurityGroupsInZone(Set<String> groups, String zoneId) { Optional<? extends SecurityGroupApi> securityGroupApi = novaApi.getSecurityGroupExtensionForZone(zoneId); if (securityGroupApi.isPresent()) { for (String group : groups) { for (SecurityGroup securityGroup : Iterables.filter(securityGroupApi.get().list(), SecurityGroupPredicates.nameMatches(namingConvention.create().containsGroup(group)))) { ZoneAndName zoneAndName = ZoneAndName.fromZoneAndName(zoneId, securityGroup.getName()); logger.debug(">> deleting securityGroup(%s)", zoneAndName); securityGroupApi.get().delete(securityGroup.getId()); // TODO: test this clear happens securityGroupMap.invalidate(zoneAndName); logger.debug("<< deleted securityGroup(%s)", zoneAndName); } } } }
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; }
@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; }
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()); } } } }
protected synchronized void createDefaultNetworkIfNeeded(String group, String location, AzureTemplateOptions options) { if (options.getIpOptions().isEmpty()) { String name = namingConvention.create().sharedNameForGroup(group); Subnet subnet = Subnet.builder().name(name) .properties(SubnetProperties.builder().addressPrefix(defaultSubnetAddressPrefix).build()).build(); VirtualNetworkProperties properties = VirtualNetworkProperties.builder() .addressSpace(AddressSpace.create(Arrays.asList(defaultVnetAddressPrefix))) .subnets(Arrays.asList(subnet)).build(); logger.debug(">> network options have not been configured. Creating network %s(%s) and subnet %s(%s)", name, defaultVnetAddressPrefix, name, defaultSubnetAddressPrefix); api.getVirtualNetworkApi(options.getResourceGroup()).createOrUpdate(name, location, null, properties); checkState(networkAvailable.create(options.getResourceGroup()).apply(name), "Network/Subnet was not created in the configured timeout"); Subnet createdSubnet = api.getSubnetApi(options.getResourceGroup(), name).get(name); options.ipOptions(IpOptions.builder().subnet(createdSubnet.id()).allocateNewPublicIp(true).build()); } }
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")); }
public SecurityGroup createSecurityGroup(String name, String zone) { String markerGroup = namingConvention.create().sharedNameForGroup(name); ZoneSecurityGroupNameAndPorts zoneAndName = new ZoneSecurityGroupNameAndPorts(zone, markerGroup, ImmutableSet.<Integer> of()); SecurityGroupInZone rawGroup = groupCreator.apply(zoneAndName); return groupConverter.apply(rawGroup); }
@SuppressWarnings("unchecked") private CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions setupStrategy() { Function<RegionAndName, KeyPair> makeKeyPair = createMock(Function.class); ConcurrentMap<RegionAndName, KeyPair> credentialsMap = createMock(ConcurrentMap.class); LoadingCache<RegionAndName, String> securityGroupMap = createMock(LoadingCache.class); GroupNamingConvention.Factory namingConventionFactory = createMock(GroupNamingConvention.Factory.class); GroupNamingConvention namingConvention = createMock(GroupNamingConvention.class); expect(namingConventionFactory.create()).andReturn(namingConvention).anyTimes(); expect(namingConvention.sharedNameForGroup("group")).andReturn("jclouds#group").anyTimes(); replay(namingConventionFactory); replay(namingConvention); return new CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions(makeKeyPair, credentialsMap, securityGroupMap, OPTIONS_PROVIDER, namingConventionFactory); }
@Inject ServerDetailsToNodeMetadata(@Memoized Supplier<Set<? extends Location>> locations, @Memoized Supplier<Set<? extends Image>> images, GroupNamingConvention.Factory namingConvention) { this.nodeNamingConvention = checkNotNull(namingConvention, "namingConvention").createWithoutPrefix(); this.locations = checkNotNull(locations, "locations"); this.images = checkNotNull(images, "images"); }
@Inject ServerToNodeMetadata(Map<ServerStatus, Status> serverStateToNodeStatus, @Memoized Supplier<Set<? extends Image>> images, Supplier<Location> location, @Memoized Supplier<Set<? extends Hardware>> hardwares, GroupNamingConvention.Factory namingConvention) { this.nodeNamingConvention = checkNotNull(namingConvention, "namingConvention").createWithoutPrefix(); this.serverToNodeStatus = checkNotNull(serverStateToNodeStatus, "serverStateToNodeStatus"); this.images = checkNotNull(images, "images"); this.location = checkNotNull(location, "location"); this.hardwares = checkNotNull(hardwares, "hardwares"); }
@Inject ServerToNodeMetadata(Map<ServerState, Status> serverStateToNodeStatus, @Memoized Supplier<Set<? extends Image>> images, @Memoized Supplier<Set<? extends Hardware>> hardwares, @Memoized Supplier<Set<? extends Location>> locations, GroupNamingConvention.Factory namingConvention) { this.nodeNamingConvention = checkNotNull(namingConvention, "namingConvention").createWithoutPrefix(); this.serverStateToNodeStatus = checkNotNull(serverStateToNodeStatus, "serverStateToNodeStatus"); this.images = checkNotNull(images, "images"); this.hardwares = checkNotNull(hardwares, "hardwares"); this.locations = checkNotNull(locations, "locations"); }