import com.amazonaws.services.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerRequest; //导入依赖的package包/类
/**
 * Requests registration of the ec2 instance with the ELB.
 * <p/>
 * After calling here, you need to call DescribeLoadBalancers or DescribeInstanceHealth to see if registration is
 * complete.
 */
public void registerInstance(String elbName, String ec2InstanceId)
{
  LOGGER.debug("registerInstancesWithLoadBalancer(elbName: " + elbName + ", ec2InstanceId: " + ec2InstanceId + ")");
  assertNonBlankArgs(elbName, ec2InstanceId);
  StopWatch stopWatch = new StopWatch();
  try
  {
    stopWatch.start();
    RegisterInstancesWithLoadBalancerRequest request = new RegisterInstancesWithLoadBalancerRequest();
    request.setLoadBalancerName(elbName);
    request.setInstances(Arrays.asList(new Instance(ec2InstanceId)));
    awsElbClient.registerInstancesWithLoadBalancer(request);
    //Currently not doing anything with the RegisterInstancesWithLoadBalancerResult
  }
  finally
  {
    stopWatch.stop();
    LOGGER.debug("registerInstancesWithLoadBalancer time elapsed " + stopWatch);
  }
}
 

import com.amazonaws.services.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerRequest; //导入依赖的package包/类
private DeferredResult<AWSLoadBalancerContext> registerInstances(
        AWSLoadBalancerContext context) {
    // Do not try to assign instances if there aren't any
    if (context.instanceIdsToRegister.isEmpty()) {
        return DeferredResult.completed(context);
    }

    RegisterInstancesWithLoadBalancerRequest request = buildInstanceRegistrationRequest(
            context);

    String message = "Registering instances to AWS Load Balancer with name ["
            + context.loadBalancerStateExpanded.name + "]";
    AWSDeferredResultAsyncHandler<RegisterInstancesWithLoadBalancerRequest, RegisterInstancesWithLoadBalancerResult> handler =
            new AWSDeferredResultAsyncHandler<>(this, message);

    context.client.registerInstancesWithLoadBalancerAsync(request, handler);

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

import com.amazonaws.services.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerRequest; //导入依赖的package包/类
private static void registerAWSInstancesToLoadBalancer(VerificationHost host,
        AmazonElasticLoadBalancingAsyncClient client, String name, List<String> instanceIds) {
    RegisterInstancesWithLoadBalancerRequest registerRequest = new RegisterInstancesWithLoadBalancerRequest()
            .withLoadBalancerName(name)
            .withInstances(instanceIds.stream()
                    .map(com.amazonaws.services.elasticloadbalancing.model.Instance::new)
                    .collect(Collectors.toList())
            );

    RegisterInstancesWithLoadBalancerResult result = null;
    try {
        result = client.registerInstancesWithLoadBalancer(registerRequest);
    } catch (Exception e) {
        host.log(Level.SEVERE, "Error registering instances with load balancer %s",
                Utils.toString(e));
    }

    assertNotNull(result);
    assertFalse(result.getInstances().isEmpty());
}
 

import com.amazonaws.services.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerRequest; //导入依赖的package包/类
public static void addInstancesToLoadBalancer(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));

	RegisterInstancesWithLoadBalancerRequest req = new RegisterInstancesWithLoadBalancerRequest(
			name, instances);
	client.registerInstancesWithLoadBalancer(req);
}
 

import com.amazonaws.services.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerRequest; //导入依赖的package包/类
public AgentCheckInResponse registerInstance(Instance instance, String elbName, BaragonAgentMetadata agent) {
  Optional<String> maybeException = Optional.absent();
  Optional<LoadBalancerDescription> elb = getElb(elbName);
  if (elb.isPresent()) {
    if (isVpcOk(agent, elb.get())) {
      if (!elb.get().getInstances().contains(instance)) {
        checkAZEnabled(agent, elbName, elb.get());
        RegisterInstancesWithLoadBalancerRequest request = new RegisterInstancesWithLoadBalancerRequest(elbName, Arrays.asList(instance));
        elbClient.registerInstancesWithLoadBalancer(request);
        LOG.info("Registered instances {} with ELB {}", request.getInstances(), request.getLoadBalancerName());
      } else {
        LOG.debug("Agent {} already registered with ELB {}", agent.getAgentId(), elbName);
      }
    } else {
      maybeException = Optional.of(String.format("No ELB found for vpc %s", agent.getEc2().getVpcId()));
    }
  }
  return new AgentCheckInResponse(TrafficSourceState.DONE, maybeException, 0L);
}
 

import com.amazonaws.services.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerRequest; //导入依赖的package包/类
private void registerNewInstances(List<LoadBalancerDescription> elbs, BaragonGroup group) {
  Collection<BaragonAgentMetadata> agents = loadBalancerDatastore.getAgentMetadata(group.getName());
  List<RegisterInstancesWithLoadBalancerRequest> requests = registerRequests(group, agents, elbs);
  if (!requests.isEmpty()) {
    for (RegisterInstancesWithLoadBalancerRequest request : requests) {
      try {
        elbClient.registerInstancesWithLoadBalancer(request);
        LOG.info("Registered instances {} with ELB {}", request.getInstances(), request.getLoadBalancerName());
      } catch (AmazonClientException e) {
        LOG.error("Could not register {} with elb {} due to error", request.getInstances(), request.getLoadBalancerName(), e);
        exceptionNotifier.notify(e, ImmutableMap.of("elb", request.getLoadBalancerName(), "toAdd", request.getInstances().toString()));
      }
    }
  } else {
    LOG.debug("No new instances to register for group {}", group.getName());
  }
}
 

import com.amazonaws.services.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerRequest; //导入依赖的package包/类
/**
 * Proves the client method is called.
 */
@Test
public void testRegisterInstance()
{
  elbClient.registerInstance(ELB_NAME, EC2_INSTANCE_ID);
  verify(mockELBClient).registerInstancesWithLoadBalancer(any(RegisterInstancesWithLoadBalancerRequest.class));
}
 

import com.amazonaws.services.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerRequest; //导入依赖的package包/类
private RegisterInstancesWithLoadBalancerRequest buildInstanceRegistrationRequest(
        AWSLoadBalancerContext context) {

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

import com.amazonaws.services.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerRequest; //导入依赖的package包/类
public void attachInstances(String elbName, List<String> instanceIds, boolean waitUntilInService) throws InterruptedException {
    logger.info("attach instances to elb, elb={}, instances={}", elbName, instanceIds);

    String expectedState = waitUntilInService ? "InService" : "Service";    // if not waitUntilInService, state can be InService or OutOfService

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

    elb.registerInstancesWithLoadBalancer(new RegisterInstancesWithLoadBalancerRequest()
        .withLoadBalancerName(elbName)
        .withInstances(instances));

    int attempts = 0;
    while (true) {
        attempts++;
        Threads.sleepRoughly(Duration.ofSeconds(15));

        List<InstanceState> states = describeInstanceHealth(elbName, instanceIds);

        for (InstanceState state : states) {
            logger.info("instance elb state {} => {}", state.getInstanceId(), state.getState());
        }

        boolean allAttached = states.stream().allMatch(state -> state.getState().contains(expectedState));
        if (allAttached) {
            logger.info("all instances are attached to elb");
            break;
        } else if (attempts >= 30) {
            throw new Error("failed to wait all instances to be attached to elb, please check aws console for more details");
        } else {
            logger.info("continue to wait, not all new instances are attached");
        }
    }
}
 

import com.amazonaws.services.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerRequest; //导入依赖的package包/类
public void registerInstances(List<Instance> instances, String lbName) {
	logger.info(String.format("Registering instances %s with loadbalancer %s", instances, lbName));
	RegisterInstancesWithLoadBalancerRequest regInstances = new RegisterInstancesWithLoadBalancerRequest();
	regInstances.setInstances(instances);
	regInstances.setLoadBalancerName(lbName);
	RegisterInstancesWithLoadBalancerResult result = elbClient.registerInstancesWithLoadBalancer(regInstances);
	
	logger.info("ELB Add instance call result: " + result.toString());	
}
 

import com.amazonaws.services.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerRequest; //导入依赖的package包/类
@POST
@Path("/{elbName}/update")
public RegisterInstancesWithLoadBalancerResult addToElb(@PathParam("elbName") String elbName, @QueryParam("instanceId") String instanceId) {
  if (config.isPresent()) {
    RegisterInstancesWithLoadBalancerRequest request = new RegisterInstancesWithLoadBalancerRequest(elbName, Arrays.asList(new Instance(instanceId)));
    return elbClient.registerInstancesWithLoadBalancer(request);
  } else {
    throw new BaragonWebException("ElbSync and related actions are not currently enabled");
  }
}
 

import com.amazonaws.services.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerRequest; //导入依赖的package包/类
private List<RegisterInstancesWithLoadBalancerRequest> registerRequests(BaragonGroup group, Collection<BaragonAgentMetadata> agents, List<LoadBalancerDescription> elbs) {
  List<RegisterInstancesWithLoadBalancerRequest> requests = new ArrayList<>();
  for (BaragonAgentMetadata agent : agents) {
    try {
      for (TrafficSource source : group.getTrafficSources()) {
        if (source.getType() != TrafficSourceType.CLASSIC) {
          continue;
        }
        if (agent.getEc2().getInstanceId().isPresent()) {
          if (shouldRegister(agent, source.getName(), elbs)) {
            Instance instance = new Instance(agent.getEc2().getInstanceId().get());
            requests.add(new RegisterInstancesWithLoadBalancerRequest(source.getName(), Arrays.asList(instance)));
            checkAZEnabled(agent, source.getName(), elbs);
            LOG.info("Will register {}-{} with ELB {}", agent.getAgentId(), agent.getEc2().getInstanceId().get(), source.getName());
          } else {
            LOG.debug("Agent {} is already registered", agent);
          }
        } else {
          throw new IllegalArgumentException(String.format("Agent Instance Id must be present to register with an ELB (agent: %s)", agent.getAgentId()));
        }
      }
    } catch (Exception e) {
      LOG.error("Could not create request for BaragonAgent {} due to error: {}", agent, e);
    }
  }
  return requests;
}