private void blockUntilRunningAndAssignElasticIpsToInstancesOrPutIntoBadMap(Set<RunningInstance> input, Map<NodeMetadata, Exception> badNodes) { Map<RegionAndName, RunningInstance> instancesById = Maps.uniqueIndex(input, instanceToRegionAndName); for (Map.Entry<RegionAndName, RunningInstance> entry : instancesById.entrySet()) { RegionAndName id = entry.getKey(); RunningInstance instance = entry.getValue(); try { logger.debug("<< allocating elastic IP instance(%s)", id); String ip = client.getElasticIPAddressApi().get().allocateAddressInRegion(id.getRegion()); // block until instance is running logger.debug(">> awaiting status running instance(%s)", id); AtomicReference<NodeMetadata> node = newReference(runningInstanceToNodeMetadata .apply(instance)); nodeRunning.apply(node); logger.trace("<< running instance(%s)", id); logger.debug(">> associating elastic IP %s to instance %s", ip, id); client.getElasticIPAddressApi().get().associateAddressInRegion(id.getRegion(), ip, id.getName()); logger.trace("<< associated elastic IP %s to instance %s", ip, id); // add mapping of instance to ip into the cache elasticIpCache.put(id, ip); } catch (RuntimeException e) { badNodes.put(runningInstanceToNodeMetadata.apply(instancesById.get(id)), e); } } }
@Override public String load(final RegionAndName key) throws Exception { try { return Iterables.find(client.getElasticIPAddressApi().get().describeAddressesInRegion(key.getRegion()), new Predicate<PublicIpInstanceIdPair>() { @Override public boolean apply(PublicIpInstanceIdPair input) { return key.getName().equals(input.getInstanceId()); } }).getPublicIp(); } catch (NoSuchElementException e) { return null; } } }
protected void releaseAnyPublicIpForInstanceInRegion(String instanceId, String region) { if (!autoAllocateElasticIps) return; try { String ip = elasticIpCache.get(new RegionAndName(region, instanceId)); logger.debug(">> disassociating elastic IP %s", ip); client.getElasticIPAddressApi().get().disassociateAddressInRegion(region, ip); logger.trace("<< disassociated elastic IP %s", ip); elasticIpCache.invalidate(new RegionAndName(region, instanceId)); logger.debug(">> releasing elastic IP %s", ip); client.getElasticIPAddressApi().get().releaseAddressInRegion(region, ip); logger.trace("<< released elastic IP %s", ip); } catch (CacheLoader.InvalidCacheLoadException e) { // no ip was found return; } catch (ExecutionException e) { // don't propagate as we need to clean up the node regardless logger.warn(e, "error cleaning up elastic ip for instance %s/%s", region, instanceId); } }
@Test void testDescribeAddresses() { for (String region : ec2Api.getConfiguredRegions()) { SortedSet<PublicIpInstanceIdPair> allResults = Sets.newTreeSet(client.describeAddressesInRegion(region)); assertNotNull(allResults); if (!allResults.isEmpty()) { PublicIpInstanceIdPair pair = allResults.last(); SortedSet<PublicIpInstanceIdPair> result = Sets.newTreeSet(client.describeAddressesInRegion(region, pair .getPublicIp())); assertNotNull(result); PublicIpInstanceIdPair compare = result.last(); assertEquals(compare, pair); SortedSet<PublicIpInstanceIdPair> filterResult = Sets.newTreeSet(client.describeAddressesInRegionWithFilter( region, ImmutableMultimap.<String, String>builder().put("public-ip", pair.getPublicIp()).build())); assertNotNull(filterResult); PublicIpInstanceIdPair filterCompare = filterResult.last(); assertEquals(filterCompare, pair); } } }
@Test(enabled = false, dependsOnMethods = "testReboot") void testElasticIpAddress() throws InterruptedException, ExecutionException, TimeoutException, IOException { address = client.getElasticIPAddressApi().get().allocateAddressInRegion(null); assertNotNull(address); PublicIpInstanceIdPair compare = Iterables.getLast(client.getElasticIPAddressApi().get() .describeAddressesInRegion(null, address)); assertEquals(compare.getPublicIp(), address); assert compare.getInstanceId() == null; client.getElasticIPAddressApi().get().associateAddressInRegion(null, address, instanceId); compare = Iterables.getLast(client.getElasticIPAddressApi().get().describeAddressesInRegion(null, address)); assertEquals(compare.getPublicIp(), address); assertEquals(compare.getInstanceId(), instanceId); Reservation<? extends RunningInstance> reservation = Iterables.getOnlyElement(client.getInstanceApi().get() .describeInstancesInRegion(null, instanceId)); assertNotNull(Iterables.getOnlyElement(reservation).getIpAddress()); assertNotEquals(address, Iterables.getOnlyElement(reservation).getIpAddress()); doCheckKey(address); client.getElasticIPAddressApi().get().disassociateAddressInRegion(null, address); compare = Iterables.getLast(client.getElasticIPAddressApi().get().describeAddressesInRegion(null, address)); assertEquals(compare.getPublicIp(), address); assert compare.getInstanceId() == null; reservation = Iterables.getOnlyElement(client.getInstanceApi().get().describeInstancesInRegion(null, instanceId)); // assert reservation.getRunningInstances().last().getIpAddress() == null; // TODO }
@AfterTest void cleanup() throws InterruptedException, ExecutionException, TimeoutException { if (address != null) client.getElasticIPAddressApi().get().releaseAddressInRegion(null, address); if (instanceId != null) client.getInstanceApi().get().terminateInstancesInRegion(null, instanceId); if (keyPair != null) client.getKeyPairApi().get().deleteKeyPairInRegion(null, keyPair.getKeyName()); if (securityGroupName != null) client.getSecurityGroupApi().get().deleteSecurityGroupInRegion(null, securityGroupName); }
public void testFilterWhenResponseIs404() throws Exception { HttpResponse filterResponse = HttpResponse.builder().statusCode(404).build(); EC2Api apiWhenDontExist = requestsSendResponses(describeRegionsRequest, describeRegionsResponse, filter, filterResponse); assertEquals(apiWhenDontExist.getElasticIPAddressApi() .get().describeAddressesInRegionWithFilter("us-east-1", ImmutableMultimap.<String, String>builder() .put("instance-id", "i-f15ebb98") .build()), ImmutableSet.of()); }
public void testFilterWhenResponseIs2xx() throws Exception { HttpResponse filterResponse = HttpResponse.builder().statusCode(200) .payload(payloadFromResourceWithContentType("/describe_addresses_single.xml", "text/xml")).build(); EC2Api apiWhenExist = requestsSendResponses(describeRegionsRequest, describeRegionsResponse, filter, filterResponse); PublicIpInstanceIdPair address = getOnlyElement(apiWhenExist.getElasticIPAddressApi() .get().describeAddressesInRegionWithFilter("us-east-1", ImmutableMultimap.<String, String>builder() .put("instance-id", "i-f15ebb98") .build())); assertNotNull(address, "address should not be null"); assertEquals(address.getPublicIp(), "67.202.55.255"); }
protected void releaseAnyPublicIpForInstanceInRegion(String instanceId, String region) { if (!autoAllocateElasticIps) return; try { String ip = elasticIpCache.get(new RegionAndName(region, instanceId)); logger.debug(">> disassociating elastic IP %s", ip); client.getElasticIPAddressApi().get().disassociateAddressInRegion(region, ip); logger.trace("<< disassociated elastic IP %s", ip); elasticIpCache.invalidate(new RegionAndName(region, instanceId)); logger.debug(">> releasing elastic IP %s", ip); client.getElasticIPAddressApi().get().releaseAddressInRegion(region, ip); logger.trace("<< released elastic IP %s", ip); } catch (CacheLoader.InvalidCacheLoadException e) { // no ip was found return; } catch (ExecutionException e) { // don't propagate as we need to clean up the node regardless logger.warn(e, "error cleaning up elastic ip for instance %s/%s", region, instanceId); } }
private void blockUntilRunningAndAssignElasticIpsToInstancesOrPutIntoBadMap(Set<RunningInstance> input, Map<NodeMetadata, Exception> badNodes) { Map<RegionAndName, RunningInstance> instancesById = Maps.uniqueIndex(input, instanceToRegionAndName); for (Map.Entry<RegionAndName, RunningInstance> entry : instancesById.entrySet()) { RegionAndName id = entry.getKey(); RunningInstance instance = entry.getValue(); try { logger.debug("<< allocating elastic IP instance(%s)", id); String ip = client.getElasticIPAddressApi().get().allocateAddressInRegion(id.getRegion()); // block until instance is running logger.debug(">> awaiting status running instance(%s)", id); AtomicReference<NodeMetadata> node = newReference(runningInstanceToNodeMetadata .apply(instance)); nodeRunning.apply(node); logger.trace("<< running instance(%s)", id); logger.debug(">> associating elastic IP %s to instance %s", ip, id); client.getElasticIPAddressApi().get().associateAddressInRegion(id.getRegion(), ip, id.getName()); logger.trace("<< associated elastic IP %s to instance %s", ip, id); // add mapping of instance to ip into the cache elasticIpCache.put(id, ip); } catch (RuntimeException e) { badNodes.put(runningInstanceToNodeMetadata.apply(instancesById.get(id)), e); } } }
@Override public String load(final RegionAndName key) throws Exception { try { return Iterables.find(client.getElasticIPAddressApi().get().describeAddressesInRegion(key.getRegion()), new Predicate<PublicIpInstanceIdPair>() { @Override public boolean apply(PublicIpInstanceIdPair input) { return key.getName().equals(input.getInstanceId()); } }).getPublicIp(); } catch (NoSuchElementException e) { return null; } } }
protected void releaseAnyPublicIpForInstanceInRegion(String instanceId, String region) { if (!autoAllocateElasticIps) return; try { String ip = elasticIpCache.get(new RegionAndName(region, instanceId)); logger.debug(">> disassociating elastic IP %s", ip); client.getElasticIPAddressApi().get().disassociateAddressInRegion(region, ip); logger.trace("<< disassociated elastic IP %s", ip); elasticIpCache.invalidate(new RegionAndName(region, instanceId)); logger.debug(">> releasing elastic IP %s", ip); client.getElasticIPAddressApi().get().releaseAddressInRegion(region, ip); logger.trace("<< released elastic IP %s", ip); } catch (CacheLoader.InvalidCacheLoadException e) { // no ip was found return; } catch (ExecutionException e) { // don't propagate as we need to clean up the node regardless logger.warn(e, "error cleaning up elastic ip for instance %s/%s", region, instanceId); } }
private void blockUntilRunningAndAssignElasticIpsToInstancesOrPutIntoBadMap(Set<RunningInstance> input, Map<NodeMetadata, Exception> badNodes) { Map<RegionAndName, RunningInstance> instancesById = Maps.uniqueIndex(input, instanceToRegionAndName); for (Map.Entry<RegionAndName, RunningInstance> entry : instancesById.entrySet()) { RegionAndName id = entry.getKey(); RunningInstance instance = entry.getValue(); try { logger.debug("<< allocating elastic IP instance(%s)", id); String ip = client.getElasticIPAddressApi().get().allocateAddressInRegion(id.getRegion()); // block until instance is running logger.debug(">> awaiting status running instance(%s)", id); AtomicReference<NodeMetadata> node = newReference(runningInstanceToNodeMetadata .apply(instance)); nodeRunning.apply(node); logger.trace("<< running instance(%s)", id); logger.debug(">> associating elastic IP %s to instance %s", ip, id); client.getElasticIPAddressApi().get().associateAddressInRegion(id.getRegion(), ip, id.getName()); logger.trace("<< associated elastic IP %s to instance %s", ip, id); // add mapping of instance to ip into the cache elasticIpCache.put(id, ip); } catch (RuntimeException e) { badNodes.put(runningInstanceToNodeMetadata.apply(instancesById.get(id)), e); } } }
@Override public String load(final RegionAndName key) throws Exception { try { return Iterables.find(client.getElasticIPAddressApi().get().describeAddressesInRegion(key.getRegion()), new Predicate<PublicIpInstanceIdPair>() { @Override public boolean apply(PublicIpInstanceIdPair input) { return key.getName().equals(input.getInstanceId()); } }).getPublicIp(); } catch (NoSuchElementException e) { return null; } } }
ipClient.disassociateAddressInRegion("region", "1.1.1.1"); ipClient.releaseAddressInRegion("region", "1.1.1.1"); elasticIpCache.invalidate(new RegionAndName("region", "i-blah"));
expect(ipClient.allocateAddressInRegion(region)).andReturn("1.1.1.1"); expect(strategy.runningInstanceToNodeMetadata.apply(instance)).andReturn(nodeMetadata).atLeastOnce(); ipClient.associateAddressInRegion(region, "1.1.1.1", instanceCreatedId); strategy.elasticIpCache.put(new RegionAndName(region, instanceCreatedId), "1.1.1.1");
@Test public void testReturnsNullWhenNotFound() throws Exception { EC2Api client = createMock(EC2Api.class); ElasticIPAddressApi ipClient = createMock(ElasticIPAddressApi.class); expect(client.getElasticIPAddressApi()).andReturn((Optional) Optional.of(ipClient)).atLeastOnce(); expect(ipClient.describeAddressesInRegion("region")).andReturn(ImmutableSet.<PublicIpInstanceIdPair> of()) .atLeastOnce(); replay(client); replay(ipClient); LoadPublicIpForInstanceOrNull parser = new LoadPublicIpForInstanceOrNull(client); assertEquals(parser.load(new RegionAndName("region", "i-blah")), null); verify(client); verify(ipClient); }
@Test public void testReturnsNullWhenNotAssigned() throws Exception { EC2Api client = createMock(EC2Api.class); ElasticIPAddressApi ipClient = createMock(ElasticIPAddressApi.class); expect(client.getElasticIPAddressApi()).andReturn((Optional) Optional.of(ipClient)).atLeastOnce(); expect(ipClient.describeAddressesInRegion("region")).andReturn( ImmutableSet.<PublicIpInstanceIdPair> of(new PublicIpInstanceIdPair("region", "1.1.1.1", null, null))) .atLeastOnce(); replay(client); replay(ipClient); LoadPublicIpForInstanceOrNull parser = new LoadPublicIpForInstanceOrNull(client); assertEquals(parser.load(new RegionAndName("region", "i-blah")), null); verify(client); verify(ipClient); }
@Test public void testReturnsPublicIpOnMatch() throws Exception { EC2Api client = createMock(EC2Api.class); ElasticIPAddressApi ipClient = createMock(ElasticIPAddressApi.class); expect(client.getElasticIPAddressApi()).andReturn((Optional) Optional.of(ipClient)).atLeastOnce(); expect(ipClient.describeAddressesInRegion("region")).andReturn( ImmutableSet.<PublicIpInstanceIdPair> of(new PublicIpInstanceIdPair("region", "1.1.1.1", "i-blah", null))) .atLeastOnce(); replay(client); replay(ipClient); LoadPublicIpForInstanceOrNull parser = new LoadPublicIpForInstanceOrNull(client); assertEquals(parser.load(new RegionAndName("region", "i-blah")), "1.1.1.1"); verify(client); verify(ipClient); }
ec2.getElasticIPAddressApi().get().describeAddressesInRegion(region, publicIps.toArray(new String[0])); assertEquals(ipidpairs.size(), 1, String.format("there should only be one address pair (%s)", Iterables.toString(ipidpairs))); ec2.getElasticIPAddressApi().get().describeAddressesInRegion(region, ipidpair.getPublicIp()); assertTrue(Iterables.isEmpty(ipidcheck), String.format("there should be no address pairs (%s)", Iterables.toString(ipidcheck)));