import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
@Test
public void testIncrementMinInstancesForAsgHappy() {

    String logicalId = "asg id";
    String instanceId = "instance id";
    int minSize = 2;

    when(autoScalingClient.describeAutoScalingGroups(
            new DescribeAutoScalingGroupsRequest().withAutoScalingGroupNames(logicalId))
    ).thenReturn(
            new DescribeAutoScalingGroupsResult()
                    .withAutoScalingGroups(
                            new AutoScalingGroup().withInstances(
                                    new Instance().withInstanceId(instanceId))
                    .withMinSize(minSize)
            )
    );

    autoScalingService.updateMinInstancesForAutoScalingGroup(logicalId, minSize - 1);

    verify(autoScalingClient).updateAutoScalingGroup(new UpdateAutoScalingGroupRequest()
            .withAutoScalingGroupName(logicalId)
            .withMinSize(minSize - 1));
}
 

import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
/**
 * Returns auto scaling groups that have the CLUSTER_TAG_KEY tag
 * @return collection of AutoScalingGroup that contain the CLUSTER_TAG_KEY
 */
private Collection<AutoScalingGroup> findAutoscalingGroups() {
    String token = null;
    List<AutoScalingGroup> groupList = new ArrayList<>();
    do {
        DescribeAutoScalingGroupsRequest request = new DescribeAutoScalingGroupsRequest();
        request.setNextToken(token);
        DescribeAutoScalingGroupsResult result = asgClient.describeAutoScalingGroups(request);
        result.getAutoScalingGroups().stream()
                .filter(a -> containsTag(a.getTags()))
                .forEach(groupList::add);

        token = result.getNextToken();
    } while(!Strings.isNullOrEmpty(token));

    return groupList;
}
 

import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
/**
 * For a given AutoScaling group logical id, get the public dns names associated with each instance.
 *
 * @param logicalId AutoScaling group logical id
 * @return List of public dns names
 */
public List<String> getPublicDnsForAutoScalingGroup(final String logicalId) {
    final List<String> instanceIds = Lists.newLinkedList();
    final Optional<AutoScalingGroup> autoScalingGroup = describeAutoScalingGroup(logicalId);
    final List<String> publicDnsNames = Lists.newLinkedList();

    if (autoScalingGroup.isPresent()) {
        autoScalingGroup.get()
                .getInstances().stream().forEach(instance -> instanceIds.add(instance.getInstanceId()));

        final DescribeInstancesRequest describeInstancesRequest = new DescribeInstancesRequest()
                .withInstanceIds(instanceIds);
        final DescribeInstancesResult describeInstancesResult =
                ec2Client.describeInstances(describeInstancesRequest);

        describeInstancesResult.getReservations().forEach(reservation ->
                reservation.getInstances().stream().forEach(instance ->
                        publicDnsNames.add(instance.getPublicDnsName()))
        );
    }

    return publicDnsNames;
}
 

import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
private Optional<AutoScalingGroup> describeAutoScalingGroup(final String autoscalingGroupName) {
    final DescribeAutoScalingGroupsRequest describeAsg = new DescribeAutoScalingGroupsRequest()
            .withAutoScalingGroupNames(autoscalingGroupName);
    final DescribeAutoScalingGroupsResult result = autoScalingClient.describeAutoScalingGroups(describeAsg);

    return result.getAutoScalingGroups().stream().findFirst();
}
 

import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
/***
 * Get list of {@link AutoScalingGroup}s for a given tag
 *
 * @param tag Tag to filter the auto scaling groups
 * @return List of {@link AutoScalingGroup}s qualifying the filter tag
 */
public List<AutoScalingGroup> getAutoScalingGroupsWithTag(Tag tag) {

  final AmazonAutoScaling autoScaling = getAmazonAutoScalingClient();

  final DescribeAutoScalingGroupsRequest describeAutoScalingGroupsRequest = new DescribeAutoScalingGroupsRequest();

  final List<AutoScalingGroup> allAutoScalingGroups = autoScaling
      .describeAutoScalingGroups(describeAutoScalingGroupsRequest)
      .getAutoScalingGroups();

  final List<AutoScalingGroup> filteredAutoScalingGroups = Lists.newArrayList();
  for (AutoScalingGroup autoScalingGroup : allAutoScalingGroups) {
    for (TagDescription tagDescription : autoScalingGroup.getTags()) {
      if (tagDescription.getKey().equalsIgnoreCase(tag.getKey()) &&
          tagDescription.getValue().equalsIgnoreCase(tag.getValue())) {
        filteredAutoScalingGroups.add(autoScalingGroup);
      }
    }
  }

  return filteredAutoScalingGroups;
}
 

import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
private List<Instance> listGroupInstances(AutoScalingGroup autoScalingGroup) throws Exception {
    List<String> instanceIds = autoScalingGroup.getInstances().stream()
            .map(com.amazonaws.services.autoscaling.model.Instance::getInstanceId).collect(Collectors.toList());
    if (instanceIds.isEmpty()) {
        // note: we don't want to call get instances with an emtpy list
        // since this causes DescribeInstances to get *all* instances in the
        // region (not just the ones in our Auto Scaling Group, which is
        // what we want)
        return new ArrayList<>();
    }

    List<Filter> filters = Collections.emptyList();
    Callable<List<Instance>> requester = new GetInstances(getAwsCredentials(), getRegion(), getClientConfig(),
            instanceIds, filters);

    int initialDelay = 1;
    int maxAttempts = 10; // max 2 ^ 9 - 1 seconds = 511 seconds
    String name = String.format("await-describe-instances");
    Retryable<List<Instance>> retryer = Retryers.exponentialBackoffRetryer(name, requester, initialDelay,
            TimeUnit.SECONDS, maxAttempts, instancesPresent(instanceIds));

    return retryer.call();
}
 

import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
@Override
public List<Machine> startMachines(int count) throws StartMachinesException {
    checkState(isConfigured(), "attempt to use unconfigured driver");

    try {
        // We simply set the desired size of the scaling group without
        // waiting for the request to be fulfilled, simply because there is
        // no bulletproof method of knowing when this particular desired
        // size request has taken effect. Waiting for the group size to
        // reach the desired size is problematic, since the desired size may
        // be set to some other value while we are waiting.
        AutoScalingGroup group = this.client.getAutoScalingGroup(scalingGroupName());
        LaunchConfiguration launchConfig = this.client.getLaunchConfiguration(group.getLaunchConfigurationName());
        int newDesiredSize = group.getDesiredCapacity() + count;
        LOG.info("starting {} new instance(s) in scaling group '{}': " + "changing desired capacity from {} to {}",
                count, scalingGroupName(), group.getDesiredCapacity(), newDesiredSize);
        this.client.setDesiredSize(scalingGroupName(), newDesiredSize);
        return pseudoMachines(count, launchConfig);
    } catch (Exception e) {
        List<Machine> empty = Collections.emptyList();
        throw new StartMachinesException(count, empty, e);
    }
}
 

import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
/**
 * Terminates a single machine from the Auto Scaling Group.
 *
 * @param machineId
 *
 * @throws NotFoundException
 * @throws AmazonClientException
 */
private void terminateMachine(String machineId) throws NotFoundException, AmazonClientException {
    checkState(isConfigured(), "attempt to use unconfigured driver");

    if (machineId.startsWith(REQUESTED_ID_PREFIX)) {
        // we were asked to terminate a placeholder instance (a
        // requested, but not yet assigned, instance). just decrement
        // desiredCapacity of the group.
        AutoScalingGroup group = this.client.getAutoScalingGroup(scalingGroupName());
        int desiredSize = group.getDesiredCapacity();
        int newSize = desiredSize - 1;
        LOG.debug("termination request for placeholder instance {}, " + "reducing desiredCapacity from {} to {}",
                machineId, desiredSize, newSize);
        this.client.setDesiredSize(scalingGroupName(), newSize);
    } else {
        LOG.info("terminating instance {}", machineId);
        this.client.terminateInstance(scalingGroupName(), machineId);
    }
}
 

import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
/**
 * Exercises the scenario when a call to describe the autoscaling group
 * yields a different outcome from a call to list the group members, which
 * may happen since there is always a time-window between those calls where
 * things may change. We need to verify that this doesn't confuse the
 * AwsAsDriver when it creates pseudo-instances in REQUESTED state.
 * <p/>
 * In this particular case, the scenario is that a call is made to describe
 * the autoscaling group (desiredCapacity: 1, instances: 0), then the
 * requested instance comes online and the call to get the group members
 * returns 1 RUNNING instance. In this case, the pool driver should act as
 * if the first call to describe the group returned (desiredCapacity: 1,
 * instances: 1) and not return any pseudo-machines in state REQUESTED.
 */
@Test
public void listMachinesOnInconsistentApiInformation() {
    int desiredCapacity = 1;
    List<Instance> emptyGroup = ec2Instances();

    // empty group returned on call to describe autoscaling group
    AutoScalingGroup groupAtT1 = group(GROUP_NAME, ONDEMAND_LAUNCH_CONFIG, desiredCapacity, emptyGroup);
    when(this.mockAwsClient.getLaunchConfiguration(ONDEMAND_LAUNCH_CONFIG.getLaunchConfigurationName()))
            .thenReturn(ONDEMAND_LAUNCH_CONFIG);
    when(this.mockAwsClient.getAutoScalingGroup(GROUP_NAME)).thenReturn(groupAtT1);

    // one running instance returned on later call to get group members
    List<Instance> groupMembersAtT2 = ec2Instances(ec2Instance("i-1", "running"));
    when(this.mockAwsClient.getAutoScalingGroupMembers(GROUP_NAME)).thenReturn(groupMembersAtT2);

    List<Machine> machines = this.driver.listMachines();
    assertThat(machines.size(), is(1));
    assertThat(machines.get(0).getId(), is("i-1"));
    assertThat(machines.get(0).getMachineState(), is(MachineState.RUNNING));

}
 

import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
public static boolean isDeployable(DeployConfiguration activeConfiguration, AutoScalingGroup autoScalingGroup, List<Ec2Instance> instances) {
    boolean canDeploy = false;
    // default calculatorF
    switch (activeConfiguration.getDeployStrategy()) {
        case KEEP_CAPACITY:
            canDeploy = new KeepCapacityStrategy().isDeployable(activeConfiguration, autoScalingGroup, instances);
            break;
        case DEFAULT:
            canDeploy = new DefaultDeployStrategy().isDeployable(activeConfiguration, autoScalingGroup, instances);
            break;
        case GUARANTEE_MINIMUM:
            canDeploy = new GuaranteeMinimumStrategy().isDeployable(activeConfiguration, autoScalingGroup, instances);
            break;
        case WHATEVER:
            canDeploy = new WhateverStrategy().isDeployable(activeConfiguration, autoScalingGroup, instances);
            break;
        case SPIN_AND_REMOVE:
            canDeploy = true;
            break;
        default:

    }
    return canDeploy;
}
 

import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
private AutoScalingGroup getAutoScalingGroup() {
    //there is no possibility to set custom name for AutoScalingGroup from CFT
    //that's why we have to determine created group name in code base on stack name
    //CloudFormation service uses next schema for AutoScalingGroup name
    //$CUSTOM_STACK_NAME-AutoScalingGroup-<some random string>

    Optional<AutoScalingGroup> asg = null;
    if (autoScalingGroup == null) {
        asg = autoScaling.describeAutoScalingGroups().getAutoScalingGroups().stream()
                .filter(autoScalingGroup -> autoScalingGroup.getAutoScalingGroupName()
                        .startsWith(SystemUtils.getCloudFormationStackName() + "-AutoScalingGroup-")).findFirst();
        autoScalingGroup = asg.orElseThrow(() -> new ConfigurationException("No appropriate AutoScalingGroup was found"));
    }
    return autoScalingGroup;
}
 

import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
/**
 * Convert from AWS ASG Instances to Turbine Instances
 *
 * @param asg
 * @return list of Turbine Instances (not AWS Instances)
 */
private List<Instance> getTurbineInstances(AutoScalingGroup asg) {
    String clusterName = asg.getTags()
            .stream()
            .filter(t -> t.getKey().equals(CLUSTER_TAG_KEY.get()))
            .findAny()
            .get().getValue();

    List<com.amazonaws.services.autoscaling.model.Instance> awsInstances = asg.getInstances();

    Collection<String> instanceIds = awsInstances.stream()
            .map(com.amazonaws.services.autoscaling.model.Instance::getInstanceId)
            .collect(Collectors.toSet());

    DescribeInstancesRequest request = new DescribeInstancesRequest();
    request.withInstanceIds(instanceIds);

    DescribeInstancesResult describeInstancesResult = ec2Client.describeInstances(request);
    List<Reservation> reservations = describeInstancesResult.getReservations();
    List<Instance> turbineInstances = new ArrayList<>();

    // add all instances from each of the reservations - after converting to Turbine instance
    reservations.stream()
            .flatMap(r -> r.getInstances().stream())
            .filter(i -> !Strings.isNullOrEmpty(i.getPublicDnsName()))
            .map(i -> createTurbineInstance(clusterName, i))
            .forEach(turbineInstances::add);


    return turbineInstances;
}
 

import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
public AutoScalingGroup createASGroup(CreateAutoScalingGroupRequest request) {
    logger.info("create auto scaling group, request={}", request);
    autoScaling.createAutoScalingGroup(request);

    DescribeAutoScalingGroupsResult result = autoScaling.describeAutoScalingGroups(new DescribeAutoScalingGroupsRequest().withAutoScalingGroupNames(request.getAutoScalingGroupName()));
    return result.getAutoScalingGroups().get(0);
}
 

import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
public List<AutoScalingGroup> listASGroups() {
    logger.info("list all auto scaling groups");
    List<AutoScalingGroup> asGroups = new ArrayList<>();
    String nextToken = null;
    while (true) {
        DescribeAutoScalingGroupsResult result = autoScaling.describeAutoScalingGroups(new DescribeAutoScalingGroupsRequest().withNextToken(nextToken));
        asGroups.addAll(result.getAutoScalingGroups());
        nextToken = result.getNextToken();
        if (nextToken == null) break;
    }
    return asGroups;
}
 

import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
public AutoScalingGroup describeASGroup(String asGroupName) {
    logger.info("describe auto scaling group, name={}", asGroupName);
    List<AutoScalingGroup> groups = autoScaling.describeAutoScalingGroups(new DescribeAutoScalingGroupsRequest()
        .withAutoScalingGroupNames(asGroupName))
                                               .getAutoScalingGroups();
    if (groups.isEmpty()) return null;
    return groups.get(0);
}
 

import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
public void load() {
    String prefix = env.name + "-";

    // find all AS group with prefix
    List<AutoScalingGroup> asGroups = AWS.as.listASGroups().stream()
                                            .filter(group -> group.getAutoScalingGroupName().startsWith(prefix))
                                            .collect(Collectors.toList());

    if (asGroups.isEmpty()) return;

    // load remote launch config in one request to maximize the speed
    List<String> launchConfigNames = asGroups.stream().map(AutoScalingGroup::getLaunchConfigurationName).collect(Collectors.toList());
    Map<String, LaunchConfiguration> configs = AWS.as.describeLaunchConfigs(launchConfigNames);

    for (AutoScalingGroup remoteASGroup : asGroups) {
        String asGroupName = remoteASGroup.getAutoScalingGroupName();
        String asGroupId = asGroupName.substring(prefix.length());
        ASGroup asGroup = resources.find(ASGroup.class, asGroupId)
                                   .orElseGet(() -> resources.add(new ASGroup(asGroupId)));
        asGroup.remoteASGroup = remoteASGroup;
        asGroup.launchConfig.remoteLaunchConfig = configs.get(remoteASGroup.getLaunchConfigurationName());
        asGroup.foundInRemote();

        List<ScalingPolicy> remotePolicies = AWS.as.describeScalingPolicies(asGroupName);
        for (ScalingPolicy remotePolicy : remotePolicies) {
            String policyId = remotePolicy.getPolicyName();
            AutoScalingPolicy policy = resources.find(AutoScalingPolicy.class, policyId)
                                                .orElseGet(() -> resources.add(new AutoScalingPolicy(policyId)));
            policy.remotePolicy = remotePolicy;
            policy.foundInRemote();
        }
    }
}
 

import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
@Override
public List<Instance> call() {
    AutoScalingGroup autoScalingGroup = new GetAutoScalingGroup(getAwsCredentials(), getRegion(), getClientConfig(),
            this.groupName).call();

    try {
        return listGroupInstances(autoScalingGroup);
    } catch (Exception e) {
        throw new RuntimeException(
                String.format("failed waiting for auto scaling group members: %s", e.getMessage()), e);
    }
}
 

import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
@Override
public AutoScalingGroup call() {
    DescribeAutoScalingGroupsRequest request = new DescribeAutoScalingGroupsRequest()
            .withAutoScalingGroupNames(this.groupName);
    DescribeAutoScalingGroupsResult result = getClient().getApi().describeAutoScalingGroups(request);
    List<AutoScalingGroup> autoScalingGroups = result.getAutoScalingGroups();
    if (autoScalingGroups.isEmpty()) {
        throw new IllegalArgumentException(format("Auto Scaling Group '%s' doesn't exist in region '%s'.",
                this.groupName, getClient().getRegion()));
    }
    return getOnlyElement(autoScalingGroups);
}
 

import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
/**
 * Returns the machine instances in the Auto Scaling Group pool.
 * <p/>
 * For the case where {@code desiredCapacity} is greater than the number of
 * started instances, we produce a number of placeholder {@link Machine}s
 * (in {@code REQUESTED} state) for requested, but not yet acquired,
 * instances in an Auto Scaling Group. The number of produced placeholder
 * instances is the the difference between {@code desiredCapacity} and
 * {@code actualCapacity}.
 * <p/>
 * Rationale: the desired capacity of the AWS Auto Scaling Group may differ
 * from the actual number of instances in the group. If the desiredCapacity
 * of the Auto Scaling Group is greater than the actual number of instances
 * in the group, we should return placeholder Machines in {@code REQUESTED}
 * state for the missing instances. This prevents the {@link BaseCloudPool}
 * from regarding the scaling group too small and ordering new machines via
 * startMachines.
 *
 * @see com.elastisys.scale.cloudpool.commons.basepool.driver.CloudPoolDriver#listMachines()
 */
@Override
public List<Machine> listMachines() throws CloudPoolDriverException {
    checkState(isConfigured(), "attempt to use unconfigured driver");

    try {
        AutoScalingGroup group = this.client.getAutoScalingGroup(scalingGroupName());
        int desiredCapacity = group.getDesiredCapacity();

        // fetch actual scaling group members
        List<Instance> groupInstances = this.client.getAutoScalingGroupMembers(scalingGroupName());
        List<Machine> acquiredMachines = groupInstances.stream().map(new InstanceToMachine())
                .collect(Collectors.toList());
        int actualCapacity = acquiredMachines.size();

        // requested, but not yet allocated, machines
        int missingInstances = Math.max(desiredCapacity - actualCapacity, 0);
        LaunchConfiguration launchConfig = this.client.getLaunchConfiguration(group.getLaunchConfigurationName());
        List<Machine> requestedInstances = pseudoMachines(missingInstances, launchConfig);

        List<Machine> pool = new ArrayList<>();
        pool.addAll(acquiredMachines);
        pool.addAll(requestedInstances);
        return pool;
    } catch (Exception e) {
        throw new CloudPoolDriverException(
                format("failed to retrieve machines in cloud pool \"%s\", Auto Scaling Group \"%s\": %s",
                        getPoolName(), scalingGroupName(), e.getMessage()),
                e);
    }
}
 

import com.amazonaws.services.autoscaling.model.AutoScalingGroup; //导入依赖的package包/类
public static AutoScalingGroup group(String name, LaunchConfiguration launchConfig, int desiredCapacity,
        Collection<com.amazonaws.services.ec2.model.Instance> ec2Instances) {
    AutoScalingGroup autoScalingGroup = new AutoScalingGroup().withAutoScalingGroupName(name)
            .withLaunchConfigurationName(launchConfig.getLaunchConfigurationName())
            .withDesiredCapacity(desiredCapacity).withInstances(toAsInstances(ec2Instances));
    return autoScalingGroup;
}