@Override public void reload() { String publicIPId = getRequiredConfig(PUBLIC_IP_ID); String lbId = getAttribute(LOAD_BALANCER_ID); if (lbId == null) { LOG.warn("Not updating load balancer {} ({} in {}), ipId {}, because id not set", new Object[] {this, lbId, loc, publicIPId}); } LOG.debug("Updating load balancer {} ({} in {}), ipId {}", new Object[] {this, lbId, loc, publicIPId}); Set<VirtualMachine> oldVirtualMachines = loadBalancerApi.listVirtualMachinesAssignedToLoadBalancerRule(lbId); Set<String> oldVirtualMachineIds = Sets.newLinkedHashSet(); for (VirtualMachine virtualMachine : oldVirtualMachines) { oldVirtualMachineIds.add(virtualMachine.getId()); } Set<String> currentVirtualMachineIds = Sets.newLinkedHashSet(); for (String address : getServerPoolAddresses()) { currentVirtualMachineIds.add(address); } Set<String> removedVirtualMachineIds = Sets.difference(oldVirtualMachineIds, currentVirtualMachineIds); Set<String> addedVirtualMachineIds = Sets.difference(currentVirtualMachineIds, oldVirtualMachineIds); LOG.debug("Updating load balancer {} ({} in {}), ipId {}: adding {}, removing {}", new Object[] {this, lbId, loc, publicIPId, addedVirtualMachineIds, removedVirtualMachineIds}); if (addedVirtualMachineIds.size() > 0) { loadBalancerApi.assignVirtualMachinesToLoadBalancerRule(lbId, addedVirtualMachineIds); } if (removedVirtualMachineIds.size() > 0) { loadBalancerApi.removeVirtualMachinesFromLoadBalancerRule(lbId, removedVirtualMachineIds); } }
@Override public void deleteLoadBalancer() { String lbId = getAttribute(LOAD_BALANCER_ID); LOG.info("Deleting load balancer {} ({}, in {})", new Object[] {lbId, this, loc}); loadBalancerApi.deleteLoadBalancerRule(lbId); }
private LoadBalancerRule refresh(LoadBalancerRule rule) { return client.getLoadBalancerApi().getLoadBalancerRule(rule.getId()); } }
@Test(dependsOnMethods = "testAssignToLoadBalancerRule", expectedExceptions = SshException.class) public void testRemoveFromLoadBalancerRule() throws Exception { if (networksDisabled) throw new SshException(); assertTrue(jobComplete.apply(client.getLoadBalancerApi().removeVirtualMachinesFromLoadBalancerRule( rule.getId(), vm.getId()))); assertEquals(client.getLoadBalancerApi().listVirtualMachinesAssignedToLoadBalancerRule(rule.getId()).size(), 0); assertEquals(rule.getState(), State.ADD); checkSSH(HostAndPort.fromParts(ip.getIPAddress(), 22)); }
@Test(dependsOnMethods = "testCreateLoadBalancerRule") public void testAssignToLoadBalancerRule() throws Exception { if (networksDisabled) return; String jobId = client.getLoadBalancerApi().assignVirtualMachinesToLoadBalancerRule(rule.getId(), vm.getId()); assertTrue(jobComplete.apply(jobId)); AsyncJob<JobResult> result = client.getAsyncJobApi().getAsyncJob(jobId); assertTrue(result.hasSucceed()); Set<VirtualMachine> machines = client.getLoadBalancerApi().listVirtualMachinesAssignedToLoadBalancerRule( rule.getId()); assertEquals(machines.size(), 1); assertTrue(loadBalancerRuleActive.apply(rule), rule.toString()); }
@Test(dependsOnMethods = "testCreateVm") public void testCreateLoadBalancerRule() throws Exception { if (networksDisabled) return; int attempts = 0; while (rule == null && attempts < 10) { ip = reuseOrAssociate.apply(network); try { String jobId = client.getLoadBalancerApi().createLoadBalancerRuleForPublicIP(ip.getId(), Algorithm.LEASTCONN, prefix, 22, 22); assertTrue(jobComplete.apply(jobId)); AsyncJob<LoadBalancerRule> asyncJob = client.getAsyncJobApi().getAsyncJob(jobId); LoadBalancerRule result = asyncJob.getResult(); rule = result; } catch (IllegalStateException e) { // very likely an ip conflict, so retry; attempts++; } } assertNotNull(rule, "Failed to get a load balancer rule after " + attempts + " attempts"); assertEquals(rule.getPublicIPId(), ip.getId()); assertEquals(rule.getPublicPort(), 22); assertEquals(rule.getPrivatePort(), 22); assertEquals(rule.getAlgorithm(), Algorithm.LEASTCONN); assertEquals(rule.getName(), prefix); assertEquals(rule.getState(), State.ADD); assertEquals(client.getLoadBalancerApi().listVirtualMachinesAssignedToLoadBalancerRule(rule.getId()).size(), 0); checkRule(rule); }
String jobId = loadBalancerApi.createLoadBalancerRuleForPublicIP(publicIPId, algorithm, lbName, instancePort, loadBalancerPort, options); AsyncJob<Object> job = client.waitForJobSuccess(jobId); LoadBalancerRule rule = (LoadBalancerRule) job.getResult();
private LoadBalancerRule findRuleWithId(final String id) { return find(client.getLoadBalancerApi().listLoadBalancerRules(), new Predicate<LoadBalancerRule>() { @Override public boolean apply(LoadBalancerRule arg0) { return Objects.equal(arg0.getId(), id); } }); }
public void testListLoadBalancerRules() throws Exception { Set<LoadBalancerRule> response = client.getLoadBalancerApi().listLoadBalancerRules(); assert null != response; assertTrue(response.size() > 0); for (LoadBalancerRule rule : response) { LoadBalancerRule newDetails = findRuleWithId(rule.getId()); assertEquals(rule.getId(), newDetails.getId()); checkRule(rule); } }
@AfterGroups(groups = "live") @Override protected void tearDownContext() { if (rule != null) { assertTrue(jobComplete.apply(client.getLoadBalancerApi().deleteLoadBalancerRule(rule.getId()))); } if (vm != null) { assertTrue(jobComplete.apply(client.getVirtualMachineApi().destroyVirtualMachine(vm.getId()))); } if (ip != null) { client.getAddressApi().disassociateIPAddress(ip.getId()); } super.tearDownContext(); }