Java 类com.amazonaws.services.ec2.model.DescribeAddressesResult 实例源码

public static void main(String[] args)
{
    final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();

    DescribeAddressesResult response = ec2.describeAddresses();

    for(Address address : response.getAddresses()) {
        System.out.printf(
                "Found address with public IP %s, " +
                "domain %s, " +
                "allocation id %s " +
                "and NIC id %s",
                address.getPublicIp(),
                address.getDomain(),
                address.getAllocationId(),
                address.getNetworkInterfaceId());
    }
}

@Test
public void itShouldStartAnEC2InstanceFromAnAMI()
        throws ServiceBrokerException {

    when(
            ec2Client.runInstances(awsRqst(r -> r.getImageId().equals(
                    "test_image")))).thenReturn(runInstanceResult);

    when(ec2Client.describeAddresses()).thenReturn(
            new DescribeAddressesResult().withAddresses(Collections
                    .singleton(new Address().withPublicIp("10.10.10.10"))));

    when(ec2Client.describeInstanceStatus(any())).thenReturn(
            new DescribeInstanceStatusResult()
                    .withInstanceStatuses(Collections
                            .singleton(new InstanceStatus()
                                    .withInstanceState(new InstanceState()
                                            .withName("running")))));

    when(hostUtils.waitForBoot(anyString(), anyInt())).thenReturn(true);
    assertThat(aws.startEC2Instance("test_image"),
            is(equalTo("test_instance")));
}

public Address describeAddress(AwsProcessClient awsProcessClient, String publicIp) {
    // 単一アドレスの参照
    DescribeAddressesRequest request = new DescribeAddressesRequest();
    request.withPublicIps(publicIp);
    DescribeAddressesResult result = awsProcessClient.getEc2Client().describeAddresses(request);
    List<Address> addresses = result.getAddresses();

    // API実行結果チェック
    if (addresses.size() == 0) {
        // アドレスが存在しない場合
        throw new AutoException("EPROCESS-000117", publicIp);

    } else if (addresses.size() > 1) {
        // アドレスを複数参照できた場合
        AutoException exception = new AutoException("EPROCESS-000118", publicIp);
        exception.addDetailInfo("result=" + addresses);
        throw exception;
    }

    return addresses.get(0);
}

private void releaseReservedIp(AmazonEC2Client client, List<CloudResource> resources) {
    CloudResource elasticIpResource = getReservedIp(resources);
    if (elasticIpResource != null && elasticIpResource.getName() != null) {
        Address address;
        try {
            DescribeAddressesResult describeResult = client.describeAddresses(
                    new DescribeAddressesRequest().withAllocationIds(elasticIpResource.getName()));
            address = describeResult.getAddresses().get(0);
        } catch (AmazonServiceException e) {
            if (e.getErrorMessage().equals("The allocation ID '" + elasticIpResource.getName() + "' does not exist")) {
                LOGGER.warn("Elastic IP with allocation ID '{}' not found. Ignoring IP release.", elasticIpResource.getName());
                return;
            } else {
                throw e;
            }
        }
        if (address.getAssociationId() != null) {
            client.disassociateAddress(new DisassociateAddressRequest().withAssociationId(elasticIpResource.getName()));
        }
        client.releaseAddress(new ReleaseAddressRequest().withAllocationId(elasticIpResource.getName()));
    }
}

/**
 * Pull back a list of the elastic ip's that aren't attached to anything and
 * return the first one.
 * 
 * @return the first available IP.
 * @throws ServiceBrokerException
 */
public String getAvaliableElasticIp() throws ServiceBrokerException {
    DescribeAddressesResult result = ec2Client.describeAddresses();
    log.info("Found " + result.getAddresses().size() + " addresses!");
    return result
            .getAddresses()
            .stream()
            .filter(a -> null == a.getInstanceId())
            .findAny()
            .orElseThrow(
                    () -> new ServiceBrokerException(
                            "No elastic IP's avaliable!")).getPublicIp();

}

@Test
public void itShouldReturnAFreeElasticIp() throws ServiceBrokerException {
    when(ec2Client.describeAddresses()).thenReturn(
            new DescribeAddressesResult().withAddresses(Collections
                    .singleton(new Address().withPublicIp("10.10.10.10"))));
    assertThat("10.10.10.10", is(aws.getAvaliableElasticIp()));
}

@Test
public void itShouldReturnOnlyOneFreeElasticIp()
        throws ServiceBrokerException {
    when(ec2Client.describeAddresses()).thenReturn(
            new DescribeAddressesResult().withAddresses(Arrays.asList(
                    new Address().withPublicIp("10.10.10.10")
                            .withInstanceId(null),
                    new Address().withPublicIp("10.10.10.11")
                            .withInstanceId(null))));
    assertThat("10.10.10.10", is(aws.getAvaliableElasticIp()));
}

@Test(expected = ServiceBrokerException.class)
public void itShouldReturnNullIfNoElasticIpIsAvaliable()
        throws ServiceBrokerException {
    when(ec2Client.describeAddresses()).thenReturn(
            new DescribeAddressesResult().withAddresses(new ArrayList<>()));
    assertNull(aws.getAvaliableElasticIp());
}

@Test
public void itShouldFilterOutAttachedElasticIPs()
        throws ServiceBrokerException {
    when(ec2Client.describeAddresses()).thenReturn(
            new DescribeAddressesResult().withAddresses(Arrays.asList(
                    new Address().withPublicIp("10.10.10.10")
                            .withInstanceId("the-instance"),
                    new Address().withPublicIp("10.10.10.11")
                            .withInstanceId(null))));
    assertThat("10.10.10.11", is(aws.getAvaliableElasticIp()));
}

public static Address checkExistsAddress(AmazonEC2 ec2, String targetIp) {
    DescribeAddressesRequest addressRequest = new DescribeAddressesRequest().withPublicIps(targetIp);
    DescribeAddressesResult addressResult = ec2.describeAddresses(addressRequest);
    List<Address> addresses = addressResult.getAddresses();
    for (Address address : addresses) {
        String publicIp = address.getPublicIp();
        if (targetIp.equals(publicIp)) {
            return address;
        }
        break;
    }
    return null;
}

public void releaseEIP(List<String> instanceIds) {
    logger.info("release EIP for instances, instanceIds={}", instanceIds);

    DescribeAddressesResult result = ec2.describeAddresses(new DescribeAddressesRequest().withFilters(new Filter("instance-id").withValues(instanceIds)));
    for (Address address : result.getAddresses()) {
        logger.info("release EIP, ip={}, instanceId={}", address.getPublicIp(), address.getInstanceId());
        ec2.disassociateAddress(new DisassociateAddressRequest().withAssociationId(address.getAssociationId()));
        ec2.releaseAddress(new ReleaseAddressRequest().withAllocationId(address.getAllocationId()));
    }
}

@Override
public List<AbstractResource<?>> describeElasticIPs(Account account, Region region, DateTime dt, Ec2Filter... filters) {
    AmazonEC2 ec2 = findClient(account, region);

    DescribeAddressesRequest req = new DescribeAddressesRequest();
    for (Ec2Filter filter : filters) {
        Filter f = new Filter().withName(filter.getName()).withValues(filter.getValues());
        req.withFilters(f);
    }

    log.debug("start describing elastic ips for account:{} in region:{} via api", account.getId() + "=>" + account.getName(), region);
    DescribeAddressesResult res = ec2.describeAddresses(req);

    return converter.toEc2ElasticIPs(res.getAddresses(), account.getId(), region, dt);
}

@Override
public DescribeAddressesResult describeAddresses(DescribeAddressesRequest describeAddressesRequest) throws AmazonServiceException, AmazonClientException {
    throw new UnsupportedOperationException("Not supported in mock");
}

@Override
public DescribeAddressesResult describeAddresses() throws AmazonServiceException, AmazonClientException {
    throw new UnsupportedOperationException("Not supported in mock");
}

private List<String> getFreeIps(List<String> eips, AmazonEC2Client amazonEC2Client) {
    DescribeAddressesResult addresses = amazonEC2Client.describeAddresses(new DescribeAddressesRequest().withAllocationIds(eips));
    return addresses.getAddresses().stream().filter(address -> address.getInstanceId() == null)
            .map(Address::getAllocationId).collect(Collectors.toList());
}