import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
/**
 * This method returns all unused EIPs
 * @return returns all unused EIPs
 */
public List<Address> getAllUnusedEIPs(List<Address> allEIPs) {
    
    List<Address> allUnusedEIPs = new ArrayList<>();
    
    if ( allEIPs != null || allEIPs.size() >0 ) {
        for(Address address: allEIPs) {
            if (address.getInstanceId() == null) {
                allUnusedEIPs.add(address);
            }
        }
    }
    
    System.out.println("INFO : Number of Unused EIPs : " + allUnusedEIPs.size());
    List<String> EIPs = allUnusedEIPs.stream().map( e -> e.getPublicIp()).collect(Collectors.toList());
    System.out.println("INFO : Unused EIPs : " + EIPs);
    
    return allUnusedEIPs;
    
}
 

import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
/**
 * This method returns list of Evaluation objects.
 * @param allUnusedEIPs
 * @return List<Evaluation> returns list of Evaluation objects.
 */
private List<Evaluation> createEvaluations(List<Address> allUnusedEIPs) {
    
    List<Evaluation> evaluations = new ArrayList<>();
    
    if ( allUnusedEIPs == null || allUnusedEIPs.size() > 0 ) {
        
        for(Address address: allUnusedEIPs) {
            
            String EIP = address.getPublicIp();
            Evaluation evaluation = new Evaluation();
            evaluation.setComplianceResourceId(EIP);
            evaluation.setComplianceResourceType(COMPLIANCE_RESOURCE_TYPE);
            evaluation.setComplianceType(ComplianceType.NON_COMPLIANT);
            evaluation.setOrderingTimestamp(new Date());
            evaluations.add(evaluation);
        }
    }
    
    System.out.println("INFO : Number of evaluations : " + evaluations.size());
    return evaluations;
}
 

import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
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());
    }
}
 

import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
@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")));
}
 

import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
public Address checkAssociatedAddress(AwsProcessClient awsProcessClient, Long instanceNo, Long addressNo) {
    AwsAddress awsAddress = awsAddressDao.read(addressNo);
    String publicIp = awsAddress.getPublicIp();
    String instanceId = awsAddress.getInstanceId();

    // アドレスが関連付けられているかどうかのチェック
    Address address = awsCommonProcess.describeAddress(awsProcessClient, publicIp);

    if (StringUtils.isEmpty(address.getInstanceId())) {
        // アドレスがどのインスタンスにも関連付けられていない場合
        throw new AutoException("EPROCESS-000120", publicIp, instanceId);

    } else if (!StringUtils.equals(instanceId, address.getInstanceId())) {
        // アドレスが他インスタンスに関連付けられている場合
        throw new AutoException("EPROCESS-000121", publicIp, instanceId, address.getInstanceId());
    }

    return address;
}
 

import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
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);
}
 

import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
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()));
    }
}
 

import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
@Test
public void testGetAllUnusedEIPs() {
    
    EC2UtilsImpl ec2UtilsImpl = new EC2UtilsImpl();
    List<Address> allUnusedEIPs = ec2UtilsImpl.getAllUnusedEIPs(allEIPs);
    assertEquals(2, allUnusedEIPs.size());
}
 

import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
@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()));
}
 

import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
@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()));
}
 

import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
@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()));
}
 

import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
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;
}
 

import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
public static Address allocateAddress(AmazonEC2 ec2, DomainType domainType) {
	AllocateAddressRequest addressRequest = new AllocateAddressRequest().withDomain(domainType);
	AllocateAddressResult addressResult = ec2.allocateAddress(addressRequest);
	Address address = new Address().withAllocationId(addressResult.getAllocationId())
			.withDomain(addressResult.getDomain()).withPublicIp(addressResult.getPublicIp());
	return address;
}
 

import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
public static String associateAddress(AmazonEC2 ec2, Address address, String instanceId) {
	AssociateAddressRequest addressRequest = new AssociateAddressRequest()
			.withAllocationId(address.getAllocationId()).withInstanceId(instanceId);
	AssociateAddressResult addressResult = ec2.associateAddress(addressRequest);
	String associationId = addressResult.getAssociationId();
	return associationId;
}
 

import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
/**
 * Stop Ec2 Instance. Realease EIP for Ec2 Instance. Disassociate EIP.
 */
public int execute(Ec2CommandOptions options) throws FileNotFoundException {
	System.out.println(getClass().getName());
	String name = options.getName();
	InputStream inputStream = new FileInputStream(new File(options.getCredentialsPath()));
	ConfigProvider.loadConfigure(inputStream);
	AmazonEC2 ec2 = AwsEc2Client.getEc2();

	// Check Exists Instance
	Instance instance = AwsEc2Client.findInstanceByName(ec2, name);
	if (instance == null) {
		System.err.println("Not exists instance (name = " + name + ").");
		return 2;
	}
	String instanceId = instance.getInstanceId();
	String publicIp = instance.getPublicIpAddress();
	System.out.println("Exists instance (id = " + instanceId + ")");

	// Stop Ec2 Instance
	InstanceStateChange stateChange = AwsEc2Client.stopInstance(ec2, instanceId);
	AwsEc2Client.showStateChange(stateChange, "Stopping Instance");

	// Disassociate and Release Address
	if (publicIp != null) {
		Address address = AwsEc2Client.checkExistsAddress(ec2, publicIp);
		if (address != null) {
			AwsEc2Client.disassociateAddress(ec2, address);
			System.out.println("Disassociated Address (" + publicIp + ")");
			AwsEc2Client.releaseAddress(ec2, address);
			System.out.println("Released Address (" + publicIp + ")");
		}
	} else {
		System.out.println("No EIP.");
	}
	return 0;
}
 

import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
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()));
    }
}
 

import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
public NatGateway createNATGateway(String subnetId, String ip) {
    logger.info("create nat gateway, subnetId={}, ip={}", subnetId, ip);

    List<Address> addresses = AWS.vpc.ec2.describeAddresses(new DescribeAddressesRequest().withPublicIps(ip)).getAddresses();
    if (addresses.isEmpty()) throw new Error("cannot find eip, ip=" + ip);
    Address address = addresses.get(0);
    if (address.getAssociationId() != null) throw new Error("eip must not associated with other resource, ip=" + ip);

    CreateNatGatewayRequest request = new CreateNatGatewayRequest()
        .withSubnetId(subnetId)
        .withAllocationId(address.getAllocationId());
    String gatewayId = ec2.createNatGateway(request).getNatGateway().getNatGatewayId();

    NatGateway gateway;
    while (true) {
        Threads.sleepRoughly(Duration.ofSeconds(30));
        gateway = describeNATGateway(gatewayId);
        String state = gateway.getState();
        if ("pending".equals(state)) continue;
        if ("available".equals(state)) {
            break;
        } else {
            throw new Error("failed to create nat gateway, gatewayId=" + gatewayId + ", state=" + state);
        }
    }
    return gateway;
}
 

import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
@Override
protected Address convertObject(AddressInfo from) {
    Address to = new Address();

    to.setInstanceId(from.getInstanceId());
    to.setPublicIp(from.getPublicIp());

    return to;
}
 

import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
/**
 * TODO: メソッドコメント
 * 
 * @param awsProcessClient
 * @param instanceNo
 */
public void startAddress(AwsProcessClient awsProcessClient, Long instanceNo) {
    // アドレス情報の取得
    List<AwsAddress> awsAddresses = awsAddressDao.readByInstanceNo(instanceNo);

    if (awsAddresses.size() > 1) {
        // アドレス情報が複数ある場合
        AutoException exception = new AutoException("EPROCESS-000202", instanceNo);
        exception.addDetailInfo("result=" + awsAddresses);
        throw exception;
    }

    if (awsAddresses.isEmpty()) {
        // アドレス情報がない場合は終了
        return;
    }

    AwsAddress awsAddress = awsAddresses.get(0);

    // インスタンスIDがない場合、インスタンスに関連付ける
    if (StringUtils.isEmpty(awsAddress.getInstanceId())) {
        // アドレスのステータスチェック
        Address address = checkAvailableAddress(awsProcessClient, instanceNo, awsAddress.getAddressNo());

        // アドレスの関連付け
        associateAddress(awsProcessClient, instanceNo, awsAddress.getAddressNo(), address);

        // インスタンスのアドレス情報を更新
        updateInstanceAddress(awsProcessClient, instanceNo, awsAddress.getAddressNo());
    }
}
 

import com.amazonaws.services.ec2.model.Address; //导入依赖的package包/类
public Address checkAvailableAddress(AwsProcessClient awsProcessClient, Long instanceNo, Long addressNo) {
    AwsAddress awsAddress = awsAddressDao.read(addressNo);
    String publicIp = awsAddress.getPublicIp();

    Address address = awsCommonProcess.describeAddress(awsProcessClient, publicIp);

    if (!StringUtils.isEmpty(address.getInstanceId())) {
        // アドレスが何らかのインスタンスに関連付けられている場合
        throw new AutoException("EPROCESS-000119", publicIp, address.getInstanceId());
    }

    return address;
}