Apache
/
jclouds
mirror of https://github.com/apache/jclouds.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

added load balancer rule tests for cloudstack

This commit is contained in:
Adrian Cole 2011-02-23 08:02:14 -08:00
parent cc37ac1847
commit c715e3c208
6 changed files with 234 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/domain/LoadBalancerRule.java
View File

@ -21,6 +21,7 @@ package org.jclouds.cloudstack.domain;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.base.CaseFormat;
import com.google.gson.annotations.SerializedName;
/**
@ -28,6 +29,22 @@ import com.google.gson.annotations.SerializedName;
* @author Adrian Cole
*/
public class LoadBalancerRule implements Comparable<LoadBalancerRule> {
public static enum State {
ADD, ACTIVE, UNRECOGNIZED;
@Override
public String toString() {
return CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, name());
}
public static State fromValue(String state) {
try {
return valueOf(CaseFormat.UPPER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, checkNotNull(state, "state")));
} catch (IllegalArgumentException e) {
return UNRECOGNIZED;
}
}
}
public static enum Algorithm {
SOURCE, ROUNDROBIN, LEASTCONN, UNRECOGNIZED;
@ -62,7 +79,7 @@ public class LoadBalancerRule implements Comparable<LoadBalancerRule> {
private String publicIP;
private long publicIPId;
private int publicPort;
private String state;
private State state;
public Builder id(long id) {
this.id = id;
@ -119,7 +136,7 @@ public class LoadBalancerRule implements Comparable<LoadBalancerRule> {
return this;
}
public Builder state(String state) {
public Builder state(State state) {
this.state = state;
return this;
}
@ -146,7 +163,7 @@ public class LoadBalancerRule implements Comparable<LoadBalancerRule> {
private long publicIPId;
@SerializedName("publicport")
private int publicPort;
private String state;
private State state;
// for deserializer
LoadBalancerRule() {
@ -154,7 +171,7 @@ public class LoadBalancerRule implements Comparable<LoadBalancerRule> {
}
public LoadBalancerRule(long id, String account, Algorithm algorithm, String description, String domain,
long domainId, String name, int privatePort, String publicIP, long publicIPId, int publicPort, String state) {
long domainId, String name, int privatePort, String publicIP, long publicIPId, int publicPort, State state) {
this.id = id;
this.account = account;
this.algorithm = algorithm;
@ -249,7 +266,7 @@ public class LoadBalancerRule implements Comparable<LoadBalancerRule> {
/**
* @return the state of the rule
*/
public String getState() {
public State getState() {
return state;
}

1
sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/features/AddressClient.java
View File

@ -71,5 +71,6 @@ public interface AddressClient {
* @param id
* the id of the public ip address to disassociate
*/
@Timeout(duration = 120, timeUnit = TimeUnit.SECONDS)
void disassociateIPAddress(long id);
}

56
sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/features/LoadBalancerAsyncClient.java
View File

@ -31,7 +31,9 @@ import org.jclouds.cloudstack.domain.VirtualMachine;
import org.jclouds.cloudstack.domain.LoadBalancerRule.Algorithm;
import org.jclouds.cloudstack.filters.QuerySigner;
import org.jclouds.cloudstack.options.ListLoadBalancerRulesOptions;
import org.jclouds.functions.JoinOnComma;
import org.jclouds.rest.annotations.ExceptionParser;
import org.jclouds.rest.annotations.ParamParser;
import org.jclouds.rest.annotations.QueryParams;
import org.jclouds.rest.annotations.RequestFilters;
import org.jclouds.rest.annotations.Unwrap;
@ -62,6 +64,16 @@ public interface LoadBalancerAsyncClient {
@ExceptionParser(ReturnEmptySetOnNotFoundOr404.class)
ListenableFuture<Set<LoadBalancerRule>> listLoadBalancerRules(ListLoadBalancerRulesOptions... options);
/**
* @see LoadBalancerClient#getLoadBalancerRule
*/
@GET
@QueryParams(keys = "command", values = "listLoadBalancerRules")
@Unwrap(depth = 3, edgeCollection = Set.class)
@Consumes(MediaType.APPLICATION_JSON)
@ExceptionParser(ReturnNullOnNotFoundOr404.class)
ListenableFuture<LoadBalancerRule> getLoadBalancerRule(@QueryParam("id") long id);
/**
* @see LoadBalancerClient#createLoadBalancerRuleForPublicIp
*/
@ -83,6 +95,50 @@ public interface LoadBalancerAsyncClient {
@ExceptionParser(ReturnNullOnNotFoundOr404.class)
ListenableFuture<Long> deleteLoadBalancerRule(@QueryParam("id") long id);
/**
* @see LoadBalancerClient#assignVirtualMachinesToLoadBalancerRule(long,Iterable)
*/
@GET
@QueryParams(keys = "command", values = "assignToLoadBalancerRule")
@ExceptionParser(ReturnNullOnNotFoundOr404.class)
@Unwrap(depth = 2)
@Consumes(MediaType.APPLICATION_JSON)
ListenableFuture<Long> assignVirtualMachinesToLoadBalancerRule(@QueryParam("id") long id,
@QueryParam("virtualmachineids") @ParamParser(JoinOnComma.class) Iterable<Long> virtualMachineIds);
/**
* @see LoadBalancerClient#assignVirtualMachinesToLoadBalancerRule(long,long[])
*/
@GET
@QueryParams(keys = "command", values = "assignToLoadBalancerRule")
@ExceptionParser(ReturnNullOnNotFoundOr404.class)
@Unwrap(depth = 2)
@Consumes(MediaType.APPLICATION_JSON)
ListenableFuture<Long> assignVirtualMachinesToLoadBalancerRule(@QueryParam("id") long id,
@QueryParam("virtualmachineids") @ParamParser(JoinOnComma.class) long... virtualMachineIds);
/**
* @see LoadBalancerClient#removeVirtualMachinesFromLoadBalancerRule(long,Iterable)
*/
@GET
@QueryParams(keys = "command", values = "removeFromLoadBalancerRule")
@ExceptionParser(ReturnNullOnNotFoundOr404.class)
@Unwrap(depth = 2)
@Consumes(MediaType.APPLICATION_JSON)
ListenableFuture<Long> removeVirtualMachinesFromLoadBalancerRule(@QueryParam("id") long id,
@QueryParam("virtualmachineids") @ParamParser(JoinOnComma.class) Iterable<Long> virtualMachineIds);
/**
* @see LoadBalancerClient#removeVirtualMachinesFromLoadBalancerRule(long,long[])
*/
@GET
@QueryParams(keys = "command", values = "removeFromLoadBalancerRule")
@ExceptionParser(ReturnNullOnNotFoundOr404.class)
@Unwrap(depth = 2)
@Consumes(MediaType.APPLICATION_JSON)
ListenableFuture<Long> removeVirtualMachinesFromLoadBalancerRule(@QueryParam("id") long id,
@QueryParam("virtualmachineids") @ParamParser(JoinOnComma.class) long... virtualMachineIds);
/**
* @see LoadBalancerClient#listVirtualMachinesAssignedToLoadBalancerRule
*/

56
sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/features/LoadBalancerClient.java
View File

@ -47,6 +47,15 @@ public interface LoadBalancerClient {
*/
Set<LoadBalancerRule> listLoadBalancerRules(ListLoadBalancerRulesOptions... options);
/**
* get a specific LoadBalancerRule by id
*
* @param id
* LoadBalancerRule to get
* @return LoadBalancerRule or null if not found
*/
LoadBalancerRule getLoadBalancerRule(long id);
/**
* Creates a load balancer rule.
*
@ -85,4 +94,51 @@ public interface LoadBalancerClient {
*/
Set<VirtualMachine> listVirtualMachinesAssignedToLoadBalancerRule(long id);
/**
* Assigns virtual machine or a list of virtual machines to a load balancer rule.
*
* @param id
* the ID of the load balancer rule
* @param virtualMachineIds
* the list of IDs of the virtual machine that are being assigned to the load balancer
* rule
* @return job id related to the operation
*/
long assignVirtualMachinesToLoadBalancerRule(long id, Iterable<Long> virtualMachineIds);
/**
* Assigns virtual machine or a list of virtual machines to a load balancer rule.
*
* @param id
* the ID of the load balancer rule
* @param virtualMachineIds
* the list of IDs of the virtual machine that are being assigned to the load balancer
* rule
* @return job id related to the operation
*/
long assignVirtualMachinesToLoadBalancerRule(long id, long... virtualMachineIds);
/**
* Removes a virtual machine or a list of virtual machines from a load balancer rule.
*
* @param id
* the ID of the load balancer rule
* @param virtualMachineIds
* the list of IDs of the virtual machine that are being removed from the load balancer
* rule
* @return job id related to the operation
*/
long removeVirtualMachinesFromLoadBalancerRule(long id, Iterable<Long> virtualMachineIds);
/**
* Removes a virtual machine or a list of virtual machines from a load balancer rule.
*
* @param id
* the ID of the load balancer rule
* @param virtualMachineIds
* the list of IDs of the virtual machine that are being removed from the load balancer
* rule
* @return job id related to the operation
*/
long removeVirtualMachinesFromLoadBalancerRule(long id, long... virtualMachineIds);
}

66
sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/predicates/LoadBalancerRuleActive.java Normal file
View File

@ -0,0 +1,66 @@
/**
*
* Copyright (C) 2010 Cloud Conscious, LLC. <info@cloudconscious.com>
*
* ====================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* ====================================================================
*/
package org.jclouds.cloudstack.predicates;
import static com.google.common.base.Preconditions.checkNotNull;
import javax.annotation.Resource;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.jclouds.cloudstack.CloudStackClient;
import org.jclouds.cloudstack.domain.LoadBalancerRule;
import org.jclouds.cloudstack.domain.LoadBalancerRule.State;
import org.jclouds.logging.Logger;
import com.google.common.base.Predicate;
/**
*
* Tests to see if a LoadBalancerRule is active
*
* @author Adrian Cole
*/
@Singleton
public class LoadBalancerRuleActive implements Predicate<LoadBalancerRule> {
private final CloudStackClient client;
@Resource
protected Logger logger = Logger.NULL;
@Inject
public LoadBalancerRuleActive(CloudStackClient client) {
this.client = client;
}
public boolean apply(LoadBalancerRule rule) {
logger.trace("looking for state on rule %s", checkNotNull(rule, "rule"));
rule = refresh(rule);
if (rule == null)
return false;
logger.trace("%s: looking for rule state %s: currently: %s", rule.getId(), State.ACTIVE, rule.getState());
return rule.getState() == State.ACTIVE;
}
private LoadBalancerRule refresh(LoadBalancerRule rule) {
return client.getLoadBalancerClient().getLoadBalancerRule(rule.getId());
}
}

47
sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/features/LoadBalancerClientLiveTest.java
View File

@ -24,11 +24,16 @@ import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.jclouds.cloudstack.domain.LoadBalancerRule;
import org.jclouds.cloudstack.domain.PublicIPAddress;
import org.jclouds.cloudstack.domain.VirtualMachine;
import org.jclouds.cloudstack.domain.LoadBalancerRule.Algorithm;
import org.jclouds.cloudstack.domain.LoadBalancerRule.State;
import org.jclouds.cloudstack.predicates.LoadBalancerRuleActive;
import org.jclouds.net.IPSocket;
import org.jclouds.predicates.RetryablePredicate;
import org.testng.annotations.AfterGroups;
import org.testng.annotations.BeforeGroups;
import org.testng.annotations.Test;
@ -45,10 +50,13 @@ public class LoadBalancerClientLiveTest extends BaseCloudStackClientLiveTest {
private PublicIPAddress ip = null;
private VirtualMachine vm;
private LoadBalancerRule rule;
private RetryablePredicate<LoadBalancerRule> loadBalancerRuleActive;
@BeforeGroups(groups = "live")
public void setupClient() {
super.setupClient();
loadBalancerRuleActive = new RetryablePredicate<LoadBalancerRule>(new LoadBalancerRuleActive(client), 600, 5,
TimeUnit.SECONDS);
prefix += "rule";
ip = AddressClientLiveTest.createPublicIPAddress(client, jobComplete);
vm = VirtualMachineClientLiveTest.createVirtualMachine(client, jobComplete, virtualMachineRunning);
@ -62,19 +70,30 @@ public class LoadBalancerClientLiveTest extends BaseCloudStackClientLiveTest {
assertEquals(rule.getPrivatePort(), 22);
assertEquals(rule.getAlgorithm(), Algorithm.LEASTCONN);
assertEquals(rule.getName(), prefix);
assertEquals(rule.getState(), State.ADD);
assertEquals(client.getLoadBalancerClient().listVirtualMachinesAssignedToLoadBalancerRule(rule.getId()).size(), 0);
checkRule(rule);
// IPSocket socket = new IPSocket(ip.getIPAddress(), 22);
// socketTester.apply(socket);
// SshClient client = sshFactory.create(socket, new Credentials("root", "password"));
// try {
// client.connect();
// ExecResponse exec = client.exec("echo hello");
// assertEquals(exec.getOutput().trim(), "hello");
// } finally {
// if (client != null)
// client.disconnect();
// }
}
@Test(dependsOnMethods = "testCreateLoadBalancerRule")
public void testAssignToLoadBalancerRule() throws Exception {
assert jobComplete.apply(client.getLoadBalancerClient().assignVirtualMachinesToLoadBalancerRule(rule.getId(),
vm.getId()));
assertEquals(client.getLoadBalancerClient().listVirtualMachinesAssignedToLoadBalancerRule(rule.getId()).size(), 1);
assert loadBalancerRuleActive.apply(rule) : rule;
IPSocket socket = new IPSocket(ip.getIPAddress(), 22);
assert socketTester.apply(socket) : vm;
}
@Test(dependsOnMethods = "testAssignToLoadBalancerRule")
public void testRemoveFromLoadBalancerRule() throws Exception {
assert jobComplete.apply(client.getLoadBalancerClient().removeVirtualMachinesFromLoadBalancerRule(rule.getId(),
vm.getId()));
assertEquals(client.getLoadBalancerClient().listVirtualMachinesAssignedToLoadBalancerRule(rule.getId()).size(), 0);
assertEquals(rule.getState(), State.ADD);
IPSocket socket = new IPSocket(ip.getIPAddress(), 22);
assert !socketTester.apply(socket);
}
@AfterGroups(groups = "live")
@ -82,12 +101,12 @@ public class LoadBalancerClientLiveTest extends BaseCloudStackClientLiveTest {
if (rule != null) {
assert jobComplete.apply(client.getLoadBalancerClient().deleteLoadBalancerRule(rule.getId()));
}
if (ip != null) {
client.getAddressClient().disassociateIPAddress(ip.getId());
}
if (vm != null) {
assert jobComplete.apply(client.getVirtualMachineClient().destroyVirtualMachine(vm.getId()));
}
if (ip != null) {
client.getAddressClient().disassociateIPAddress(ip.getId());
}
super.tearDown();
}