Java 类com.amazonaws.services.elasticloadbalancing.model.DeregisterInstancesFromLoadBalancerRequest 实例源码

/**
 * Requests deregistration of the ec2 instance from the ELB.
 * <p/>
 * After calling here, you need to call DescribeLoadBalancers to see if registration is complete.
 */
public void deregisterInstance(String elbName, String ec2InstanceId)
{
  LOGGER.debug("deregisterInstancesFromLoadBalancer(elbName: " + elbName + ", ec2InstanceId: " + ec2InstanceId + ")");
  assertNonBlankArgs(elbName, ec2InstanceId);
  StopWatch stopWatch = new StopWatch();
  try
  {
    stopWatch.start();
    DeregisterInstancesFromLoadBalancerRequest request = new DeregisterInstancesFromLoadBalancerRequest();
    request.setLoadBalancerName(elbName);
    request.setInstances(Arrays.asList(new Instance(ec2InstanceId)));
    awsElbClient.deregisterInstancesFromLoadBalancer(request);
    //Currently not doing anything with the DeregisterInstancesFromLoadBalancerResult
  }
  finally
  {
    stopWatch.stop();
    LOGGER.debug("deregisterInstancesFromLoadBalancer time elapsed " + stopWatch);
  }
}

private DeferredResult<AWSLoadBalancerContext> deregisterInstances(
        AWSLoadBalancerContext context) {
    // Do not try to deregister instances if there aren't any
    if (context.instanceIdsToDeregister.isEmpty()) {
        return DeferredResult.completed(context);
    }

    DeregisterInstancesFromLoadBalancerRequest request = buildInstanceDeregistrationRequest(
            context);

    String message = "Deregistering instances to AWS Load Balancer with name ["
            + context.loadBalancerStateExpanded.name + "]";

    AWSDeferredResultAsyncHandler<DeregisterInstancesFromLoadBalancerRequest, DeregisterInstancesFromLoadBalancerResult> handler =
            new AWSDeferredResultAsyncHandler<>(this, message);

    context.client.deregisterInstancesFromLoadBalancerAsync(request, handler);

    return handler.toDeferredResult().thenApply(ignore -> context);
}

public static void removeInstancesFromLoadBalancer(String name,
        String... instanceIds) {
    if (name == null || name.trim().length() == 0)
        throw new RuntimeException(
                "The name of the load balancer cannot be empty!");

    if (instanceIds == null || instanceIds.length == 0)
        throw new RuntimeException(
                "You need to specify at least one instance id!");

    connect();

    ArrayList<com.amazonaws.services.elasticloadbalancing.model.Instance> instances = new ArrayList<com.amazonaws.services.elasticloadbalancing.model.Instance>();
    for (String instanceId : instanceIds)
        instances
                .add(new com.amazonaws.services.elasticloadbalancing.model.Instance(
                        instanceId));

    DeregisterInstancesFromLoadBalancerRequest req = new DeregisterInstancesFromLoadBalancerRequest(
            name, instances);
    client.deregisterInstancesFromLoadBalancer(req);
}

private List<DeregisterInstancesFromLoadBalancerRequest> deregisterRequests(BaragonGroup group, Collection<BaragonAgentMetadata> agents, List<LoadBalancerDescription> elbs) {
  List<String> agentInstanceIds = agentInstanceIds(agents);
  List<DeregisterInstancesFromLoadBalancerRequest> requests = new ArrayList<>();
  for (LoadBalancerDescription elb : elbs) {
    if (group.getTrafficSources().contains(new TrafficSource(elb.getLoadBalancerName(), TrafficSourceType.CLASSIC))) {
      for (Instance instance : elb.getInstances()) {
        if (!agentInstanceIds.contains(instance.getInstanceId()) && canDeregisterAgent(group, instance.getInstanceId())) {
          List<Instance> instanceList = new ArrayList<>(1);
          instanceList.add(instance);
          requests.add(new DeregisterInstancesFromLoadBalancerRequest(elb.getLoadBalancerName(), instanceList));
          LOG.info("Will deregister instance {} from ELB {}", instance.getInstanceId(), elb.getLoadBalancerName());
        }
      }
    }
  }
  return requests;
}

/**
 * Proves the client method is called.
 */
@Test
public void testDeregisterInstance()
{
  elbClient.deregisterInstance(ELB_NAME, EC2_INSTANCE_ID);
  verify(mockELBClient).deregisterInstancesFromLoadBalancer(any(DeregisterInstancesFromLoadBalancerRequest.class));
}

private DeregisterInstancesFromLoadBalancerRequest buildInstanceDeregistrationRequest(
        AWSLoadBalancerContext context) {

    return new DeregisterInstancesFromLoadBalancerRequest()
            .withLoadBalancerName(context.loadBalancerStateExpanded.name)
            .withInstances(context.instanceIdsToDeregister.stream()
                    .map(Instance::new)
                    .collect(Collectors.toList())
            );
}

public void detachInstances(String elbName, List<String> instanceIds) {
    logger.info("detach instances from elb, elb={}, instances={}", elbName, instanceIds);

    List<Instance> instances = instanceIds.stream().map(Instance::new).collect(Collectors.toList());

    elb.deregisterInstancesFromLoadBalancer(new DeregisterInstancesFromLoadBalancerRequest()
        .withLoadBalancerName(elbName)
        .withInstances(instances));
}

public List<Instance> degisterInstancesFromLB(List<Instance> toRemove,
        String loadBalancerName) {

    DeregisterInstancesFromLoadBalancerRequest request= new DeregisterInstancesFromLoadBalancerRequest();
    request.setInstances(toRemove);

    request.setLoadBalancerName(loadBalancerName);
    DeregisterInstancesFromLoadBalancerResult result = elbClient.deregisterInstancesFromLoadBalancer(request);
    List<Instance> remaining = result.getInstances();
    logger.info(String.format("ELB %s now has %s instances registered", loadBalancerName, remaining.size()));
    return remaining;
}

@DELETE
@Path("/{elbName}/update")
public DeregisterInstancesFromLoadBalancerResult removeFromElb(@PathParam("elbName") String elbName, @QueryParam("instanceId") String instanceId) {
  if (config.isPresent()) {
    DeregisterInstancesFromLoadBalancerRequest request = new DeregisterInstancesFromLoadBalancerRequest(elbName, Arrays.asList(new Instance(instanceId)));
    return elbClient.deregisterInstancesFromLoadBalancer(request);
  } else {
    throw new BaragonWebException("ElbSync and related actions are not currently enabled");
  }
}

public AgentCheckInResponse removeInstance(Instance instance, String elbName, String agentId) {
  Optional<LoadBalancerDescription> elb = getElb(elbName);
  if (elb.isPresent()) {
    if (elb.get().getInstances().contains(instance)) {
      DeregisterInstancesFromLoadBalancerRequest request = new DeregisterInstancesFromLoadBalancerRequest(elbName, Arrays.asList(instance));
      elbClient.deregisterInstancesFromLoadBalancer(request);
      LOG.info("Deregistered instance {} from ELB {}", request.getInstances(), request.getLoadBalancerName());
    } else {
      LOG.debug("Agent {} already de-registered from ELB {}", agentId, elbName);
    }
  }
  return new AgentCheckInResponse(TrafficSourceState.DONE, Optional.absent(), 0L);
}

private boolean isLastHealthyInstance(DeregisterInstancesFromLoadBalancerRequest request) throws AmazonClientException {
  DescribeInstanceHealthRequest describeRequest = new DescribeInstanceHealthRequest(request.getLoadBalancerName());
  DescribeInstanceHealthResult result = elbClient.describeInstanceHealth(describeRequest);
  boolean instanceIsHealthy = false;
  int healthyCount = 0;
  for (InstanceState instanceState : result.getInstanceStates()) {
    if (instanceState.getState().equals("InService")) {
      healthyCount++;
      if (instanceState.getInstanceId().equals(request.getInstances().get(0).getInstanceId())) { //Will only ever be one instance per request
        instanceIsHealthy = true;
      }
    }
  }
  return (instanceIsHealthy && healthyCount == 1);
}