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

private DeferredResult<Void> validateCredentials(
        AuthCredentialsServiceState credentials, String regionId) {
    AmazonEC2AsyncClient client = AWSUtils.getAsyncClient(credentials, regionId,
            this.clientManager.getExecutor());

    AWSDeferredResultAsyncHandler<DescribeAvailabilityZonesRequest, DescribeAvailabilityZonesResult> asyncHandler = new AWSDeferredResultAsyncHandler<>(
            this, "Validate Credentials");

    client.describeAvailabilityZonesAsync(asyncHandler);

    return asyncHandler
            .toDeferredResult()
            .handle((describeAvailabilityZonesResult, e) -> {
                if (e instanceof AmazonServiceException) {
                    AmazonServiceException ase = (AmazonServiceException) e;
                    if (ase.getStatusCode() == STATUS_CODE_UNAUTHORIZED) {

                        throw new LocalizableValidationException(
                                e,
                                PHOTON_MODEL_ADAPTER_UNAUTHORIZED_MESSAGE,
                                PHOTON_MODEL_ADAPTER_UNAUTHORIZED_MESSAGE_CODE);
                    }
                }
                return null;
            });
}

@Override
public void handleSuccess(DescribeAvailabilityZonesRequest request,
        DescribeAvailabilityZonesResult result) {

    List<AvailabilityZone> zones = result.getAvailabilityZones();
    if (zones == null || zones.isEmpty()) {
        this.service
                .logFine(() -> "No AvailabilityZones found. Nothing to be created locally");
        this.context.refreshSubStage = this.next;
        this.service.processRefreshSubStages(this.context);
        return;
    }

    loadLocalResources(this.service, this.context,
            zones.stream()
                    .map(AvailabilityZone::getZoneName)
                    .collect(Collectors.toList()),
            cm -> createMissingLocalInstances(zones, cm),
            cm -> {
                this.service.logFine(() -> "No AvailabilityZones found. Nothing to be"
                        + " created locally");
                this.context.refreshSubStage = this.next;
                this.service.processRefreshSubStages(this.context);
            });
}

@Test
public void testGetAvailabilityZones() {

    String zoneName = "zone-name";

    when(ec2Client.describeAvailabilityZones()).thenReturn(
            new DescribeAvailabilityZonesResult()
                    .withAvailabilityZones(
                            new AvailabilityZone()
                                    .withZoneName(zoneName)
                                    .withState(AvailabilityZoneState.Available),
                            new AvailabilityZone()
                                    .withZoneName("not-available-zone")
                                    .withState(AvailabilityZoneState.Unavailable)
                    )
    );

    // invoke method under test
    List<String> results = ec2Service.getAvailabilityZones();

    assertEquals(1, results.size());
    assertEquals(zoneName, results.get(0));
}

/**
 * This implementation uses the DescribeAvailabilityZones API to get the list of AZs.
 */
@Override
public List<AvailabilityZone> getAvailabilityZonesForSubnetIds(Collection<Subnet> subnets, AwsParamsDto awsParamsDto)
{
    Set<String> zoneNames = new HashSet<>();
    for (Subnet subnet : subnets)
    {
        zoneNames.add(subnet.getAvailabilityZone());
    }

    AmazonEC2Client ec2Client = getEc2Client(awsParamsDto);
    DescribeAvailabilityZonesRequest describeAvailabilityZonesRequest = new DescribeAvailabilityZonesRequest();
    describeAvailabilityZonesRequest.setZoneNames(zoneNames);
    DescribeAvailabilityZonesResult describeAvailabilityZonesResult = ec2Operations.describeAvailabilityZones(ec2Client, describeAvailabilityZonesRequest);
    return describeAvailabilityZonesResult.getAvailabilityZones();
}

public static List<String> getAllAvailabilityZones() {
    connect();

    DescribeAvailabilityZonesRequest req = new DescribeAvailabilityZonesRequest();

    ArrayList<Filter> filters = new ArrayList<Filter>();
    ArrayList<String> regions = new ArrayList<String>();
    regions.add(Configuration.REGION);
    filters.add(new Filter("region-name", regions));
    req.setFilters(filters);

    DescribeAvailabilityZonesResult res = client.describeAvailabilityZones(req);

    List<AvailabilityZone> zones = res.getAvailabilityZones();
    ArrayList<String> zonesStr = new ArrayList<String>();
    for (AvailabilityZone zone : zones)
        zonesStr.add(zone.getZoneName());

    return zonesStr;
}

private Zone getZoneByName(String zoneName)
{
    checkState(!isNullOrEmpty(zoneName));

    try
    {
        DescribeAvailabilityZonesResult zones = ec2_
                .describeAvailabilityZones(new DescribeAvailabilityZonesRequest()
                .withZoneNames(zoneName)
                .withFilters(new Filter().withName("region-name").withValues(credentials_.getRegion().getName())));

        if (zones != null && zones.getAvailabilityZones().size() == 1)
        {
            //available | impaired | unavailable
            AvailabilityZone availabilityZone = zones.getAvailabilityZones().get(0);
            return new Zone().setName(availabilityZone.getZoneName()).setRegion(credentials_.getRegion()).setStatus(availabilityZone.getState());
        }

    }
    catch (AmazonClientException exception)
    {
        LOG.debug("Invalid zone [{}]! Error message: [{}]", zoneName, exception.getMessage(), exception);
    }

    return null;
}

@Override
public List<AvailabilityZone> getAvailabilityZones(Region region) throws Exception {
  OperationStats op = new OperationStats("ec2InstanceStore", "getAvailabilityZones");
  try {
    DescribeAvailabilityZonesRequest request = new DescribeAvailabilityZonesRequest();
    DescribeAvailabilityZonesResult result = getClient(region).describeAvailabilityZones();
    List<AvailabilityZone> ret = result.getAvailabilityZones();
    op.succeed();
    return ret;
  } catch (Exception ex) {
    op.failed();
    throw ex;
  }
}

private void validateAWSCredentials(final AWSInstanceContext aws) {
    if (aws.computeRequest.isMockRequest || AWSUtils.isAwsClientMock()) {
        aws.operation.complete();
        return;
    }

    // make a call to validate credentials
    aws.amazonEC2Client
            .describeAvailabilityZonesAsync(
                    new DescribeAvailabilityZonesRequest(),
                    new AsyncHandler<DescribeAvailabilityZonesRequest, DescribeAvailabilityZonesResult>() {
                        @Override
                        public void onError(Exception e) {
                            if (e instanceof AmazonServiceException) {
                                AmazonServiceException ase = (AmazonServiceException) e;
                                if (ase.getStatusCode() == STATUS_CODE_UNAUTHORIZED) {
                                    ServiceErrorResponse r = Utils.toServiceErrorResponse(e);
                                    r.statusCode = STATUS_CODE_UNAUTHORIZED;
                                    aws.operation.fail(e, r);
                                    return;
                                }
                            }

                            aws.operation.fail(e);
                        }

                        @Override
                        public void onSuccess(DescribeAvailabilityZonesRequest request,
                                DescribeAvailabilityZonesResult describeAvailabilityZonesResult) {
                            aws.operation.complete();
                        }
                    });
}

public static void validateCredentials(AmazonEC2AsyncClient ec2Client,
        AWSClientManager clientManager, AuthCredentialsServiceState credentials,
        ComputeEnumerateAdapterRequest context, Operation op, StatelessService service,
        Consumer<DescribeAvailabilityZonesResult> onSuccess, Consumer<Throwable> onFail) {

    if (clientManager.isEc2ClientInvalid(credentials, context.regionId)) {
        op.complete();
        return;
    }

    ec2Client.describeAvailabilityZonesAsync(new DescribeAvailabilityZonesRequest(),
            new AsyncHandler<DescribeAvailabilityZonesRequest, DescribeAvailabilityZonesResult>() {

                @Override
                public void onError(Exception e) {
                    if (e instanceof AmazonServiceException) {
                        AmazonServiceException ase = (AmazonServiceException) e;
                        if (ase.getStatusCode() == STATUS_CODE_UNAUTHORIZED) {
                            clientManager.markEc2ClientInvalid(service, credentials,
                                    context.regionId);
                            op.complete();
                            return;
                        }
                        onFail.accept(e);
                    }
                }

                @Override
                public void onSuccess(DescribeAvailabilityZonesRequest request,
                        DescribeAvailabilityZonesResult describeAvailabilityZonesResult) {
                    onSuccess.accept(describeAvailabilityZonesResult);
                }
            });
}

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

    DescribeRegionsResult regions_response = ec2.describeRegions();

    for(Region region : regions_response.getRegions()) {
        System.out.printf(
            "Found region %s " +
            "with endpoint %s",
            region.getRegionName(),
            region.getEndpoint());
    }

    DescribeAvailabilityZonesResult zones_response =
        ec2.describeAvailabilityZones();

    for(AvailabilityZone zone : zones_response.getAvailabilityZones()) {
        System.out.printf(
            "Found availability zone %s " +
            "with status %s " +
            "in region %s",
            zone.getZoneName(),
            zone.getState(),
            zone.getRegionName());
    }
}

/**
 * Determines all availability zones for a region that are marked as available.
 *
 * @return List of availability zones
 */
public List<String> getAvailabilityZones() {
    final DescribeAvailabilityZonesResult result = ec2Client.describeAvailabilityZones();

    return result.getAvailabilityZones()
            .stream()
            .filter(az -> AvailabilityZoneState.Available == AvailabilityZoneState.fromValue(az.getState()))
            .map(AvailabilityZone::getZoneName).collect(Collectors.toList());
}

/**
 * Validates the configured availability zone.
 *
 * @param client              the EC2 client
 * @param configuration       the configuration to be validated
 * @param accumulator         the exception condition accumulator
 * @param localizationContext the localization context
 */
@VisibleForTesting
void checkAvailabilityZone(AmazonEC2Client client,
    Configured configuration,
    PluginExceptionConditionAccumulator accumulator,
    LocalizationContext localizationContext) {

  String zoneName = configuration.getConfigurationValue(AVAILABILITY_ZONE, localizationContext);
  if (zoneName != null) {
    LOG.info(">> Describing zone '{}'", zoneName);

    try {
      DescribeAvailabilityZonesResult result = client.describeAvailabilityZones(
          new DescribeAvailabilityZonesRequest().withZoneNames(zoneName));

      checkCount(accumulator, AVAILABILITY_ZONE, localizationContext, "Availability zone",
          result.getAvailabilityZones());
    } catch (AmazonServiceException e) {
      if (e.getErrorCode().equals(INVALID_PARAMETER_VALUE) &&
          e.getMessage().contains(INVALID_AVAILABILITY_ZONE)) {
        addError(accumulator, AVAILABILITY_ZONE, localizationContext,
            null, INVALID_AVAILABILITY_ZONE_MSG, zoneName);
      } else {
        throw Throwables.propagate(e);
      }
    }
  }
}

@Override
public DescribeAvailabilityZonesResult describeAvailabilityZones(AmazonEC2Client ec2Client,
    DescribeAvailabilityZonesRequest describeAvailabilityZonesRequest)
{
    List<AvailabilityZone> availabilityZones = new ArrayList<>();

    List<String> requestedZoneNames = describeAvailabilityZonesRequest.getZoneNames();

    // add all AZ if request is empty (this is AWS behavior)
    if (requestedZoneNames.isEmpty())
    {
        requestedZoneNames.addAll(mockAvailabilityZones.keySet());
    }

    for (String requestedZoneName : requestedZoneNames)
    {
        // ignore AZ name which does not exist (this is AWS behavior)
        MockAvailabilityZone mockAvailabilityZone = mockAvailabilityZones.get(requestedZoneName);
        if (mockAvailabilityZone != null)
        {
            availabilityZones.add(mockAvailabilityZone.toAwsObject());
        }
    }

    DescribeAvailabilityZonesResult describeAvailabilityZonesResult = new DescribeAvailabilityZonesResult();
    describeAvailabilityZonesResult.setAvailabilityZones(availabilityZones);

    return describeAvailabilityZonesResult;
}

public synchronized List<String> availabilityZones() {
    if (availabilityZones == null) {
        DescribeAvailabilityZonesResult result = ec2.describeAvailabilityZones();
        availabilityZones = result.getAvailabilityZones().stream()
                                  .filter(zone -> "available".equals(zone.getState()))
                                  .map(AvailabilityZone::getZoneName)
                                  .collect(Collectors.toList());
        logger.info("availability zones => {}", availabilityZones);
    }
    return availabilityZones;
}

private List<Zone> listAvailableZonesOfRegion(Region region)
{
    checkNotNull(region);
    checkState(!isNullOrEmpty(region.getName()));
    checkState(!isNullOrEmpty(region.getEndpoint()));

    List<Zone> zones = newArrayList();

    AmazonEC2Client client = new AmazonEC2Client(awsCredentials_);
    client.setEndpoint(region.getEndpoint());

    try
    {
        DescribeAvailabilityZonesResult availabilityZonesResult = client.describeAvailabilityZones(new DescribeAvailabilityZonesRequest()
                .withFilters(new com.amazonaws.services.ec2.model.Filter().withName("region-name").withValues(region.getName()),
                             new com.amazonaws.services.ec2.model.Filter().withName("state").withValues("available"))
                            );

        for (AvailabilityZone zone : availabilityZonesResult.getAvailabilityZones())
        {
            zones.add(new Zone().setName(zone.getZoneName()).setRegion(region));
        }

        Collections.sort(zones);
    }
    catch (AmazonClientException exception)
    {
        LOG.warn("Error on listing the available zones of region [name:{}, endpoint:{}]. Error message: [{}]", 
                region.getName(), region.getEndpoint(), exception.getMessage(), exception);
    }

    return zones;
}

/**
 * {@inheritDoc}
 */
@Override
public List<AvailabilityZone> getAvailabilityZones(Long userNo, Long platformNo) {
    // アベイラビリティゾーンを取得
    AwsProcessClient awsProcessClient = awsProcessClientFactory.createAwsProcessClient(userNo, platformNo);
    DescribeAvailabilityZonesRequest request = new DescribeAvailabilityZonesRequest();
    DescribeAvailabilityZonesResult result = awsProcessClient.getEc2Client().describeAvailabilityZones(request);
    List<AvailabilityZone> availabilityZones = result.getAvailabilityZones();

    // ソート
    Collections.sort(availabilityZones, Comparators.COMPARATOR_AVAILABILITY_ZONE);

    return availabilityZones;
}

public List<AvailabilityZone> describeAvailabilityZones(AwsProcessClient awsProcessClient) {
    DescribeAvailabilityZonesRequest request = new DescribeAvailabilityZonesRequest();
    DescribeAvailabilityZonesResult result = awsProcessClient.getEc2Client().describeAvailabilityZones(request);
    List<AvailabilityZone> availabilityZones = result.getAvailabilityZones();

    return availabilityZones;
}

/***
 * Get availability zones in an Amazon AWS region
 *
 * @return List of availability zones
 */
public List<AvailabilityZone> getAvailabilityZones() {

  final AmazonEC2 amazonEC2 = getEc2Client();

  final DescribeAvailabilityZonesResult describeAvailabilityZonesResult = amazonEC2.describeAvailabilityZones();
  final List<AvailabilityZone> availabilityZones = describeAvailabilityZonesResult.getAvailabilityZones();
  LOGGER.info("Found: " + availabilityZones.size() + " availability zone");

  return availabilityZones;
}

public static void ec2_demo(){

        System.out.println("- - - - - - - - - - - - - - - - - - - - - -");
        System.out.println("EC2 DEMO");


            /*
         * Amazon EC2
         *
         * The AWS EC2 client allows you to create, delete, and administer
         * instances programmatically.
         *
         * In this sample, we use an EC2 client to get a list of all the
         * availability zones, and all instances sorted by reservation id.
         */
        try {
            DescribeAvailabilityZonesResult availabilityZonesResult = ec2.describeAvailabilityZones();
            System.out.println("You have access to " + availabilityZonesResult.getAvailabilityZones().size() +
                    " Availability Zones.");

            DescribeInstancesResult describeInstancesRequest = ec2.describeInstances();
            List<Reservation> reservations = describeInstancesRequest.getReservations();
            Set<Instance> instances = new HashSet<Instance>();

            for (Reservation reservation : reservations) {
                instances.addAll(reservation.getInstances());
            }

            System.out.println("You have " + instances.size() + " Amazon EC2 instance(s) running.");
        } catch (AmazonServiceException ase) {
                System.out.println("Caught Exception: " + ase.getMessage());
                System.out.println("Reponse Status Code: " + ase.getStatusCode());
                System.out.println("Error Code: " + ase.getErrorCode());
                System.out.println("Request ID: " + ase.getRequestId());
        }

    }

/**
 * Describe AvailabilityZone.
 *
 * @return AvailabilityZone
 */
protected final AvailabilityZone getAvailiablityZones() {
    AvailabilityZone availabilityZone = null;

    DescribeAvailabilityZonesResult result = amazonEC2Client.describeAvailabilityZones();
    if (result != null && !result.getAvailabilityZones().isEmpty()) {
        availabilityZone = result.getAvailabilityZones().get(0);
    }

    return availabilityZone;
}

@Override
public DescribeAvailabilityZonesResult describeAvailabilityZones(DescribeAvailabilityZonesRequest describeAvailabilityZonesRequest) throws AmazonServiceException, AmazonClientException {
    throw new UnsupportedOperationException("Not supported in mock");
}

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

public List<AvailabilityZone> getAvailabilityZones() {
    DescribeAvailabilityZonesResult res = this.client.describeAvailabilityZones();
    return res.getAvailabilityZones();
}

@Override
public DescribeAvailabilityZonesResult describeAvailabilityZones(AmazonEC2Client ec2Client,
    DescribeAvailabilityZonesRequest describeAvailabilityZonesRequest)
{
    return ec2Client.describeAvailabilityZones(describeAvailabilityZonesRequest);
}

@Override
@Cacheable(cacheNames = "cloudResourceRegionCache", key = "#cloudCredential?.id")
public CloudRegions regions(CloudCredential cloudCredential, Region region, Map<String, String> filters) throws Exception {
    AmazonEC2Client ec2Client = awsClient.createAccess(cloudCredential);
    Map<Region, List<AvailabilityZone>> regionListMap = new HashMap<>();
    Map<Region, String> displayNames = new HashMap<>();

    DescribeRegionsRequest describeRegionsRequest = new DescribeRegionsRequest();
    DescribeRegionsResult describeRegionsResult = ec2Client.describeRegions(describeRegionsRequest);
    String defaultRegion = awsZoneParameterDefault;

    for (com.amazonaws.services.ec2.model.Region awsRegion : describeRegionsResult.getRegions()) {
        if (region == null || Strings.isNullOrEmpty(region.value()) || awsRegion.getRegionName().equals(region.value())) {
            DescribeAvailabilityZonesRequest describeAvailabilityZonesRequest = new DescribeAvailabilityZonesRequest();

            ec2Client.setRegion(RegionUtils.getRegion(awsRegion.getRegionName()));
            Filter filter = new Filter();
            filter.setName("region-name");
            List<String> list = new ArrayList<>();
            list.add(awsRegion.getRegionName());
            filter.setValues(list);

            describeAvailabilityZonesRequest.withFilters(filter);

            DescribeAvailabilityZonesResult describeAvailabilityZonesResult = ec2Client.describeAvailabilityZones(describeAvailabilityZonesRequest);

            List<AvailabilityZone> tmpAz = new ArrayList<>();
            for (com.amazonaws.services.ec2.model.AvailabilityZone availabilityZone : describeAvailabilityZonesResult.getAvailabilityZones()) {
                tmpAz.add(availabilityZone(availabilityZone.getZoneName()));
            }
            regionListMap.put(region(awsRegion.getRegionName()), tmpAz);
            DisplayName displayName = regionDisplayNames.get(region(awsRegion.getRegionName()));
            if (displayName == null || Strings.isNullOrEmpty(displayName.value())) {
                displayNames.put(region(awsRegion.getRegionName()), awsRegion.getRegionName());
            } else {
                displayNames.put(region(awsRegion.getRegionName()), displayName.value());
            }
        }
    }
    if (region != null && !Strings.isNullOrEmpty(region.value())) {
        defaultRegion = region.value();
    }
    return new CloudRegions(regionListMap, displayNames, defaultRegion);
}

/**
 * {@link AmazonEC2#describeAvailabilityZones()}
 * 
 * @param ec2Client {@link AmazonEC2} to use.
 * @param describeAvailabilityZonesRequest The request object.
 * @return {@link DescribeAvailabilityZonesResult}
 */
public DescribeAvailabilityZonesResult describeAvailabilityZones(AmazonEC2Client ec2Client,
    DescribeAvailabilityZonesRequest describeAvailabilityZonesRequest);