<parent>
<groupId>org.opendaylight.controller</groupId>
<artifactId>commons.opendaylight</artifactId>
- <version>1.4.2-SNAPSHOT</version>
+ <version>1.5.0-SNAPSHOT</version>
</parent>
<groupId>org.opendaylight.plugin2oc</groupId>
<artifactId>commons.plugin2oc</artifactId>
- <version>0.1-SNAPSHOT</version>
+ <version>0.2.0-SNAPSHOT</version>
<packaging>pom</packaging>
<properties>
<parent>\r
<artifactId>commons.plugin2oc</artifactId>\r
<groupId>org.opendaylight.plugin2oc</groupId>\r
- <version>0.1-SNAPSHOT</version>\r
+ <version>0.2.0-SNAPSHOT</version>\r
<relativePath>../commons/parent</relativePath>\r
</parent>\r
<artifactId>distribution-karaf</artifactId>\r
<maven>3.0</maven>\r
</prerequisites>\r
<properties>\r
- <branding.version>1.0.0-SNAPSHOT</branding.version>\r
- <karaf.resources.version>1.4.2-SNAPSHOT</karaf.resources.version>\r
+ <branding.version>1.1.0-SNAPSHOT</branding.version>\r
+ <karaf.resources.version>1.5.0-SNAPSHOT</karaf.resources.version>\r
<karaf.version>3.0.1</karaf.version>\r
</properties>\r
<dependencies>\r
<dependency>\r
<groupId>org.opendaylight.controller</groupId>\r
<artifactId>features-adsal</artifactId>\r
- <version>0.8.1-SNAPSHOT</version>\r
+ <version>0.9.0-SNAPSHOT</version>\r
<classifier>features</classifier>\r
<type>xml</type>\r
<scope>runtime</scope>\r
<dependency>\r
<groupId>org.opendaylight.controller</groupId>\r
<artifactId>features-base</artifactId>\r
- <version>1.4.2-SNAPSHOT</version>\r
+ <version>1.5.0-SNAPSHOT</version>\r
<classifier>features</classifier>\r
<type>xml</type>\r
<scope>runtime</scope>\r
<dependency>\r
<groupId>org.opendaylight.controller</groupId>\r
<artifactId>features-nsf</artifactId>\r
- <version>0.4.2-SNAPSHOT</version>\r
+ <version>0.5.0-SNAPSHOT</version>\r
<classifier>features</classifier>\r
<type>xml</type>\r
<scope>runtime</scope>\r
<dependency>\r
<groupId>org.opendaylight.plugin2oc</groupId>\r
<artifactId>features-plugin2oc</artifactId>\r
- <version>0.1-SNAPSHOT</version>\r
+ <version>0.2.0-SNAPSHOT</version>\r
<classifier>features</classifier>\r
<type>xml</type>\r
<scope>runtime</scope>\r
<dependency>\r
<groupId>org.opendaylight.yangtools</groupId>\r
<artifactId>features-yangtools</artifactId>\r
- <version>0.6.2-SNAPSHOT</version>\r
+ <version>0.7.0-SNAPSHOT</version>\r
<classifier>features</classifier>\r
<type>xml</type>\r
<scope>runtime</scope>\r
<dependency>\r
<groupId>org.opendaylight.controller</groupId>\r
<artifactId>features-mdsal</artifactId>\r
- <version>1.1-SNAPSHOT</version>\r
+ <version>1.2.0-SNAPSHOT</version>\r
<classifier>features</classifier>\r
<type>xml</type>\r
<scope>runtime</scope>\r
<parent>\r
<artifactId>plugin2oc.project</artifactId>\r
<groupId>org.opendaylight.plugin2oc</groupId>\r
- <version>0.1-SNAPSHOT</version>\r
+ <version>0.2.0-SNAPSHOT</version>\r
</parent>\r
<artifactId>features-plugin2oc</artifactId>\r
<groupId>org.opendaylight.plugin2oc</groupId>\r
<packaging>jar</packaging>\r
<properties>\r
<features.file>features.xml</features.file>\r
- <branding.version>1.0.0-SNAPSHOT</branding.version>\r
- <karaf.resources.version>1.4.2-SNAPSHOT</karaf.resources.version>\r
+ <branding.version>1.1.0-SNAPSHOT</branding.version>\r
+ <karaf.resources.version>1.5.0-SNAPSHOT</karaf.resources.version>\r
<karaf.version>3.0.1</karaf.version>\r
- <feature.test.version>0.6.2-SNAPSHOT</feature.test.version>\r
- <karaf.empty.version>1.4.2-SNAPSHOT</karaf.empty.version>\r
+ <feature.test.version>0.7.0-SNAPSHOT</feature.test.version>\r
+ <karaf.empty.version>1.5.0-SNAPSHOT</karaf.empty.version>\r
<surefire.version>2.17</surefire.version>\r
- <yangtools.version>0.6.2-SNAPSHOT</yangtools.version>\r
+ <yangtools.version>0.7.0-SNAPSHOT</yangtools.version>\r
</properties>\r
\r
<dependencies>\r
<dependency>\r
<groupId>org.opendaylight.yangtools</groupId>\r
<artifactId>features-yangtools</artifactId>\r
- <version>0.6.2-SNAPSHOT</version>\r
+ <version>0.7.0-SNAPSHOT</version>\r
<classifier>features</classifier>\r
<type>xml</type>\r
</dependency>\r
<dependency>\r
<groupId>org.opendaylight.controller</groupId>\r
<artifactId>features-nsf</artifactId>\r
- <version>0.4.2-SNAPSHOT</version>\r
+ <version>0.5.0-SNAPSHOT</version>\r
<classifier>features</classifier>\r
<type>xml</type>\r
</dependency>\r
<dependency>\r
<groupId>org.opendaylight.controller</groupId>\r
<artifactId>features-adsal</artifactId>\r
- <version>0.8.1-SNAPSHOT</version>\r
+ <version>0.9.0-SNAPSHOT</version>\r
<classifier>features</classifier>\r
<type>xml</type>\r
</dependency>\r
<dependency>\r
<groupId>org.opendaylight.controller</groupId>\r
<artifactId>features-base</artifactId>\r
- <version>1.4.2-SNAPSHOT</version>\r
+ <version>1.5.0-SNAPSHOT</version>\r
<classifier>features</classifier>\r
<type>xml</type>\r
</dependency>\r
<dependency>\r
<groupId>org.opendaylight.controller</groupId>\r
<artifactId>features-mdsal</artifactId>\r
- <version>1.1-SNAPSHOT</version>\r
+ <version>1.2.0-SNAPSHOT</version>\r
<classifier>features</classifier>\r
<type>xml</type>\r
</dependency>\r
<dependency>\r
<groupId>org.opendaylight.controller</groupId>\r
<artifactId>sal</artifactId>\r
- <version>0.8.1-SNAPSHOT</version>\r
+ <version>0.9.0-SNAPSHOT</version>\r
</dependency>\r
<dependency>\r
<groupId>org.opendaylight.controller</groupId>\r
<artifactId>sal-binding-api</artifactId>\r
- <version>1.1-SNAPSHOT</version>\r
+ <version>1.2.0-SNAPSHOT</version>\r
</dependency>\r
<dependency>\r
<groupId>org.opendaylight.controller</groupId>\r
- <version>0.4.2-SNAPSHOT</version>\r
+ <version>0.5.0-SNAPSHOT</version>\r
<artifactId>networkconfig.neutron</artifactId>\r
</dependency>\r
<dependency>\r
<groupId>org.opendaylight.plugin2oc</groupId>\r
- <version>0.1-SNAPSHOT</version>\r
+ <version>0.2.0-SNAPSHOT</version>\r
<artifactId>plugin2oc.neutron</artifactId>\r
</dependency>\r
<!-- test the features.xml -->\r
<dependency>\r
<groupId>org.opendaylight.yangtools</groupId>\r
<artifactId>features-test</artifactId>\r
- <version>0.6.2-SNAPSHOT</version>\r
+ <version>0.7.0-SNAPSHOT</version>\r
<scope>test</scope>\r
</dependency>\r
\r
<dependency>\r
<groupId>org.opendaylight.controller</groupId>\r
<artifactId>opendaylight-karaf-empty</artifactId>\r
- <version>1.4.2-SNAPSHOT</version>\r
+ <version>1.5.0-SNAPSHOT</version>\r
<type>zip</type>\r
</dependency>\r
</dependencies>\r
<features name="odl-plugin2oc-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
- <repository>mvn:org.opendaylight.yangtools/features-yangtools/0.6.2-SNAPSHOT/xml/features</repository>
- <repository>mvn:org.opendaylight.controller/features-nsf/0.4.2-SNAPSHOT/xml/features</repository>
- <repository>mvn:org.opendaylight.controller/features-adsal/0.8.1-SNAPSHOT/xml/features</repository>
- <repository>mvn:org.opendaylight.controller/features-base/1.4.2-SNAPSHOT/xml/features</repository>
- <repository>mvn:org.opendaylight.controller/features-mdsal/1.1-SNAPSHOT/xml/features</repository>
+ <repository>mvn:org.opendaylight.yangtools/features-yangtools/0.7.0-SNAPSHOT/xml/features</repository>
+ <repository>mvn:org.opendaylight.controller/features-nsf/0.5.0-SNAPSHOT/xml/features</repository>
+ <repository>mvn:org.opendaylight.controller/features-adsal/0.9.0-SNAPSHOT/xml/features</repository>
+ <repository>mvn:org.opendaylight.controller/features-base/1.5.0-SNAPSHOT/xml/features</repository>
+ <repository>mvn:org.opendaylight.controller/features-mdsal/1.2.0-SNAPSHOT/xml/features</repository>
<feature name='odl-plugin2oc' description="OpenDaylight :: plugin2oc :: Plugin" version='${project.version}'>
<feature>odl-nsf-all</feature>
<feature>odl-adsal-all</feature>
<feature>odl-mdsal-broker</feature>
<feature>odl-yangtools-models</feature>
<feature>odl-yangtools-binding</feature>
- <bundle>mvn:org.opendaylight.controller/networkconfig.neutron/0.4.2-SNAPSHOT</bundle>
- <bundle>mvn:org.opendaylight.controller/sal/0.8.1-SNAPSHOT</bundle>
- <bundle>mvn:org.opendaylight.controller/sal-binding-api/1.1-SNAPSHOT</bundle>
- <bundle>mvn:org.opendaylight.plugin2oc/plugin2oc.neutron/0.1-SNAPSHOT</bundle>
+ <bundle>mvn:org.opendaylight.controller/networkconfig.neutron/0.5.0-SNAPSHOT</bundle>
+ <bundle>mvn:org.opendaylight.controller/sal/0.9.0-SNAPSHOT</bundle>
+ <bundle>mvn:org.opendaylight.controller/sal-binding-api/1.2.0-SNAPSHOT</bundle>
+ <bundle>mvn:org.opendaylight.plugin2oc/plugin2oc.neutron/0.2.0-SNAPSHOT</bundle>
</feature>
</features>
<parent>\r
<groupId>org.opendaylight.plugin2oc</groupId>\r
<artifactId>commons.plugin2oc</artifactId>\r
- <version>0.1-SNAPSHOT</version>\r
+ <version>0.2.0-SNAPSHOT</version>\r
<relativePath>../commons/parent</relativePath>\r
</parent>\r
<artifactId>plugin2oc.neutron</artifactId>\r
- <version>0.1-SNAPSHOT</version>\r
+ <version>0.2.0-SNAPSHOT</version>\r
<packaging>bundle</packaging>\r
<repositories>\r
<repository>\r
</dependency>\r
<dependency>\r
<groupId>org.opendaylight.controller</groupId>\r
- <version>0.4.2-SNAPSHOT</version>\r
+ <version>0.5.0-SNAPSHOT</version>\r
<artifactId>networkconfig.neutron</artifactId>\r
</dependency>\r
<dependency>\r
<dependency>\r
<groupId>org.opendaylight.controller</groupId>\r
<artifactId>sal</artifactId>\r
- <version>0.8.1-SNAPSHOT</version>\r
+ <version>0.9.0-SNAPSHOT</version>\r
</dependency>\r
<dependency>\r
<groupId>org.opendaylight.controller</groupId>\r
<artifactId>sal-binding-api</artifactId>\r
- <version>1.1-SNAPSHOT</version>\r
+ <version>1.2.0-SNAPSHOT</version>\r
</dependency>\r
<dependency>\r
<groupId>org.mockito</groupId>\r
*/
@Override
public Object[] getImplementations() {
- Object[] res = { NetworkHandler.class, SubnetHandler.class, PortHandler.class, RouterHandler.class, FloatingIpHandler.class, SecurityGroupHandler.class, SecurityGroupRulesHandler.class };
+ Object[] res = { NetworkHandler.class, SubnetHandler.class, PortHandler.class, RouterHandler.class,
+ FloatingIpHandler.class, SecurityGroupHandler.class, SecurityGroupRulesHandler.class,
+ LoadBalancerHandler.class, LoadBalancerHealthMonitorHandler.class, LoadBalancerListenerHandler.class,
+ LoadBalancerPoolHandler.class, LoadBalancerPoolMemberHandler.class, };
return res;
}
* Function that is called when configuration of the dependencies is
* required.
*
- * @param c
+ *@param c
* dependency manager Component object, used for configuring the
* dependencies exported and imported
- * @param imp
+ *@param imp
* Implementation class that is being configured, needed as long
* as the same routine can configure multiple implementations
* @param containerName
if (imp.equals(SecurityGroupRulesHandler.class)) {
c.setInterface(INeutronSecurityRuleAware.class.getName(), null);
}
+ if (imp.equals(LoadBalancerHandler.class)) {
+ c.setInterface(INeutronSecurityRuleAware.class.getName(), null);
+ }
+ if (imp.equals(LoadBalancerHealthMonitorHandler.class)) {
+ c.setInterface(INeutronSecurityRuleAware.class.getName(), null);
+ }
+ if (imp.equals(LoadBalancerListenerHandler.class)) {
+ c.setInterface(INeutronSecurityRuleAware.class.getName(), null);
+ }
+ if (imp.equals(LoadBalancerPoolHandler.class)) {
+ c.setInterface(INeutronSecurityRuleAware.class.getName(), null);
+ }
+ if (imp.equals(LoadBalancerPoolMemberHandler.class)) {
+ c.setInterface(INeutronSecurityRuleAware.class.getName(), null);
+ }
// Create service dependencies.
c.add(createServiceDependency().setService(BindingAwareBroker.class).setCallbacks("setBindingAwareBroker", "unsetBindingAwareBroker")
.setRequired(true));
--- /dev/null
+package org.opendaylight.plugin2oc.neutron;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.util.List;
+import java.util.UUID;
+
+import net.juniper.contrail.api.ApiConnector;
+import net.juniper.contrail.api.ObjectReference;
+import net.juniper.contrail.api.types.InstanceIp;
+import net.juniper.contrail.api.types.Project;
+import net.juniper.contrail.api.types.VirtualMachineInterface;
+import net.juniper.contrail.api.types.VirtualNetwork;
+import net.juniper.contrail.api.types.VnSubnetsType;
+
+import org.opendaylight.controller.networkconfig.neutron.INeutronLoadBalancerAware;
+import org.opendaylight.controller.networkconfig.neutron.INeutronSubnetCRUD;
+import org.opendaylight.controller.networkconfig.neutron.NeutronCRUDInterfaces;
+import org.opendaylight.controller.networkconfig.neutron.NeutronLoadBalancer;
+import org.opendaylight.controller.networkconfig.neutron.NeutronSubnet;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Handle requests for Neutron LoadBalancer.
+ */
+public class LoadBalancerHandler implements INeutronLoadBalancerAware {
+ /**
+ * Logger instance.
+ */
+ static final Logger LOGGER = LoggerFactory.getLogger(LoadBalancerHandler.class);
+ static ApiConnector apiConnector;
+
+ /**
+ * Invoked when a LoadBalancer creation is requested to check if the specified
+ * LoadBalancer can be created and then creates the LoadBalancer
+ *
+ * @param loadBalancer
+ * An instance of proposed new Neutron LoadBalancer object.
+ *
+ * @return A HTTP status code to the creation request.
+ */
+ @Override
+ public int canCreateNeutronLoadBalancer(NeutronLoadBalancer loadBalancer) {
+ if (loadBalancer == null) {
+ LOGGER.error("LoadBalancer object can't be null..");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ apiConnector = Activator.apiConnector;
+ if (loadBalancer.getLoadBalancerTenantID() == null || loadBalancer.getLoadBalancerVipSubnetID() == null) {
+ LOGGER.error("LoadBalancer TenanID/SubnetID can not be null");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ try {
+ String loadBalancerID = loadBalancer.getLoadBalancerID();
+ String loadBalancerVipSubnetID = loadBalancer.getLoadBalancerVipSubnetID();
+ String projectUUID = loadBalancer.getLoadBalancerTenantID();
+ try {
+ if (!(loadBalancerID.contains("-"))) {
+ loadBalancerID = Utils.uuidFormater(loadBalancerID);
+ }
+ if (!(projectUUID.contains("-"))) {
+ projectUUID = Utils.uuidFormater(projectUUID);
+ }
+ if (!(loadBalancerVipSubnetID.contains("-"))) {
+ loadBalancerVipSubnetID = Utils.uuidFormater(loadBalancerVipSubnetID);
+ }
+ boolean isValidLoadBalancerID = Utils.isValidHexNumber(loadBalancerID);
+ boolean isValidprojectUUID = Utils.isValidHexNumber(projectUUID);
+ boolean isValidVipSubnetID = Utils.isValidHexNumber(loadBalancerVipSubnetID);
+ if (!isValidLoadBalancerID || !isValidprojectUUID || !isValidVipSubnetID) {
+ LOGGER.info("Badly formed Hexadecimal UUID...");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ projectUUID = UUID.fromString(projectUUID).toString();
+ loadBalancerID = UUID.fromString(loadBalancerID).toString();
+ loadBalancerVipSubnetID = UUID.fromString(loadBalancerVipSubnetID).toString();
+ } catch (Exception ex) {
+ LOGGER.error("UUID input incorrect", ex);
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ Project project = (Project) apiConnector.findById(Project.class, projectUUID);
+ if (project == null) {
+ try {
+ Thread.currentThread();
+ Thread.sleep(3000);
+ } catch (InterruptedException e) {
+ LOGGER.error("InterruptedException : ", e);
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ project = (Project) apiConnector.findById(Project.class, projectUUID);
+ if (project == null) {
+ LOGGER.error("Could not find projectUUID...");
+ return HttpURLConnection.HTTP_NOT_FOUND;
+ }
+ }
+ /* TODO: support for LoadBalancer is not provided in OpenContrail */
+ // LoadBalancer loadBalancer = (LoadBalancer)
+ // apiConnector.findById(LoadBalancer.class, loadBalancerID);
+ // if (loadBalancer != null) {
+ // LOGGER.warn("Loadbalancer already exists with UUID" +
+ // loadBalancerID);
+ // return HttpURLConnection.HTTP_FORBIDDEN;
+ // }
+
+ /* to check if provided subnet ID already exists in contrail */
+
+ INeutronSubnetCRUD subnetInterface = NeutronCRUDInterfaces.getINeutronSubnetCRUD(this);
+ if (subnetInterface == null) {
+ LOGGER.error("The subnet does not exists in ODL itself..");
+ return HttpURLConnection.HTTP_FORBIDDEN;
+ }
+ NeutronSubnet subnet = subnetInterface.getSubnet(loadBalancerVipSubnetID);
+ if (subnet == null) {
+ LOGGER.error("Subnet does not exists...");
+ return HttpURLConnection.HTTP_FORBIDDEN;
+ }
+ String networkUUID = subnet.getNetworkUUID();
+ VirtualNetwork virtualnetwork = (VirtualNetwork) apiConnector.findById(VirtualNetwork.class, networkUUID);
+ if (virtualnetwork == null) {
+ LOGGER.error("No network exists for the specified subnet...");
+ return HttpURLConnection.HTTP_FORBIDDEN;
+ } else {
+ try {
+ boolean ifSubnetExist = subnetExists(virtualnetwork.getNetworkIpam(), subnet);
+ if (!ifSubnetExist) {
+ LOGGER.error("The subnet does not exists..");
+ return HttpURLConnection.HTTP_FORBIDDEN;
+ }
+ } catch (Exception e) {
+ LOGGER.error("Exception: " + e);
+ return HttpURLConnection.HTTP_INTERNAL_ERROR;
+ }
+ }
+ return HttpURLConnection.HTTP_OK;
+ } catch (IOException ie) {
+ LOGGER.error("IOException : " + ie);
+ System.out.println("exception 1");
+ return HttpURLConnection.HTTP_INTERNAL_ERROR;
+ } catch (Exception e) {
+ LOGGER.error("Exception : " + e);
+ System.out.println("exception 2");
+ return HttpURLConnection.HTTP_INTERNAL_ERROR;
+ }
+
+ }
+
+ /**
+ * Invoked to take action after a loadBalancer has been created.
+ *
+ * @param loadBalancer
+ * An instance of new Neutron loadBalancer object.
+ */
+ @Override
+ public void neutronLoadBalancerCreated(NeutronLoadBalancer loadBalancer) {
+ try {
+ createLoadBalancer(loadBalancer);
+ } catch (IOException ex) {
+ LOGGER.warn("Exception : " + ex);
+ }
+// LoadBalancer loadBalancer = null;
+ try {
+ String loadBalanceUUID = loadBalancer.getLoadBalancerID();
+ if (!(loadBalanceUUID.contains("-"))) {
+ loadBalanceUUID = Utils.uuidFormater(loadBalanceUUID);
+ }
+ loadBalanceUUID = UUID.fromString(loadBalanceUUID).toString();
+ /* TODO: support for LoadBalancer is not provided in OpenContrail */
+ // loadBalancer = (LoadBalancer)
+ // apiConnector.findById(LoadBalancer.class, loadBalancerID);
+ // if (loadBalancer != null) {
+ // LOGGER.warn("Loadbalancer creation verified...." +
+ // loadBalancerID);
+ // return HttpURLConnection.HTTP_FORBIDDEN;
+ // }
+ } catch (Exception e) {
+ LOGGER.error("Exception : " + e);
+ }
+ }
+
+ /**
+ * Invoked to create the specified Neutron LoadBalancer.
+ *
+ * @param loadBalancer
+ * An instance of new Neutron LoadBalancer object.
+ */
+ private void createLoadBalancer(NeutronLoadBalancer loadBalancer) throws IOException {
+// LoadBalancer virtualLoadBalancer = new LoadBalancer();
+// virtualLoadBalancer = mapLoadBalancerProperties(loadBalancer, virtualLoadBalancer);
+ Project project = (Project) apiConnector.findById(Project.class, loadBalancer.getLoadBalancerTenantID());
+ INeutronSubnetCRUD subnetInterface = NeutronCRUDInterfaces.getINeutronSubnetCRUD(this);
+ NeutronSubnet subnet = subnetInterface.getSubnet(loadBalancer.getLoadBalancerVipSubnetID());
+ String networkUUID = subnet.getNetworkUUID();
+ VirtualNetwork virtualnetwork = (VirtualNetwork) apiConnector.findById(VirtualNetwork.class, networkUUID);
+ VirtualMachineInterface vmi = new VirtualMachineInterface();
+ vmi.setName(UUID.randomUUID().toString());
+ vmi.setUuid(UUID.randomUUID().toString());
+ vmi.setParent(project);
+ vmi.setVirtualNetwork(virtualnetwork);
+ boolean virtualMachineInterfaceCreated = apiConnector.create(vmi);
+ if (!virtualMachineInterfaceCreated) {
+ LOGGER.warn("actual virtualMachineInterface creation failed..");
+ }
+// /* setting vmi in LoadBalancer in OpenContrail */
+// virtualLoadBalancer.setVirtualMachineInterface(vmi);
+ String ips = loadBalancer.getLoadBalancerVipAddress();
+ InstanceIp instanceIp = new InstanceIp();
+ String instaneIpUuid = UUID.randomUUID().toString();
+ instanceIp.setAddress(ips);
+ instanceIp.setName(instaneIpUuid);
+ instanceIp.setUuid(instaneIpUuid);
+ instanceIp.setParent(vmi);
+ instanceIp.setVirtualMachineInterface(vmi);
+ instanceIp.setVirtualNetwork(virtualnetwork);
+ boolean instanceIpCreated = apiConnector.create(instanceIp);
+ if (!instanceIpCreated) {
+ LOGGER.warn("instanceIp addition failed..");
+ }
+ LOGGER.info("Instance IP " + instanceIp.getAddress() +
+ " added sucessfully...");
+// boolean loadBalancerCreated;
+ try {
+// loadBalancerCreated = apiConnector.create(virtualLoadBalancer);
+// LOGGER.debug("loadBalancer: " + loadBalancerCreated);
+// if (!loadBalancerCreated) {
+// LOGGER.info("loadBalancer creation failed..");
+// }
+ } catch (Exception Ex) {
+ LOGGER.error("Exception : " + Ex);
+ }
+ }
+
+ @Override
+ public int canUpdateNeutronLoadBalancer(NeutronLoadBalancer delta, NeutronLoadBalancer original) {
+ // TODO Auto-generated method stub
+ return 0;
+ }
+
+ @Override
+ public void neutronLoadBalancerUpdated(NeutronLoadBalancer loadBalancer) {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public int canDeleteNeutronLoadBalancer(NeutronLoadBalancer loadBalancer) {
+ // TODO Auto-generated method stub
+ return 0;
+ }
+
+ @Override
+ public void neutronLoadBalancerDeleted(NeutronLoadBalancer loadBalancer) {
+ // TODO Auto-generated method stub
+
+ }
+ /**
+ * Invoked to map the NeutronLoadBalancer object properties to the LoadBalancer
+ * object.
+ *
+ * @param loadBalancer
+ * An instance of new NeutronLoadBalancer object.
+ * @param virtualLoadBalancer
+ * An instance of new LoadBalancer object.
+ * @return {@link LoadBalancer}
+ */
+// private LoadBalancer mapLoadBalancerProperties(NeutronLoadBalancer loadBalancer, LoadBalancer virtualLoadBalancer) {
+// String loadBalancerID = loadBalancer.getLoadBalancerID();
+// String loadBalancerName = loadBalancer.getLoadBalancerName();
+// String projectUUID = loadBalancer.getLoadBalancerTenantID();
+// try {
+// if (!(loadBalancerID.contains("-"))) {
+// loadBalancerID = Utils.uuidFormater(loadBalancerID);
+// }
+// loadBalancerID = UUID.fromString(loadBalancerID).toString();
+// if (!(projectUUID.contains("-"))) {
+// projectUUID = Utils.uuidFormater(projectUUID);
+// }
+// projectUUID = UUID.fromString(projectUUID).toString();
+// Project project = (Project) apiConnector.findById(Project.class, projectUUID);
+// virtualLoadBalancer.setParent(project);
+// } catch (Exception ex) {
+// LOGGER.error("UUID input incorrect", ex);
+// }
+// LoadBalancerType loadBalancerType = new LoadBalancerType();
+// loadBalancerType.setAddress(loadBalancer.getLoadBalancerVipAddress());
+// loadBalancerType.setAdminState(true);
+// loadBalancerType.setSubnetId(loadBalancer.getLoadBalancerVipSubnetID());
+// virtualLoadBalancer.setDisplayName(loadBalancerName);
+// virtualLoadBalancer.setUuid(loadBalancerID);
+// return virtualLoadBalancer;
+// }
+
+ /**
+ * Invoked to check if subnet exists from the Neutron Subnet object.
+ *
+ * @param ipamRefs
+ * An list of new ObjectReference<VnSubnetsType> objects.
+ *
+ * @param subnet
+ * An instance of new Neutron Subnet object.
+ *
+ * @return boolean
+ */
+ private boolean subnetExists(List<ObjectReference<VnSubnetsType>> ipamRefs, NeutronSubnet subnet) {
+ if (ipamRefs != null) {
+ for (ObjectReference<VnSubnetsType> ref : ipamRefs) {
+ VnSubnetsType vnSubnetsType = ref.getAttr();
+ if (vnSubnetsType != null) {
+ List<VnSubnetsType.IpamSubnetType> subnets = vnSubnetsType.getIpamSubnets();
+ if (subnets != null) {
+ for (VnSubnetsType.IpamSubnetType subnetValue : subnets) {
+ String[] ipPrefix = getIpPrefix(subnet);
+ Boolean doesSubnetExist = subnetValue.getSubnet().getIpPrefix().matches(ipPrefix[0]);
+ if (doesSubnetExist) {
+ return doesSubnetExist;
+ }
+ }
+ }
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Invoked to get the IP Prefix from the Neutron Subnet object.
+ *
+ * @param subnet
+ * An instance of new Neutron Subnet object.
+ *
+ * @return IP Prefix
+ * @throws Exception
+ */
+ String[] getIpPrefix(NeutronSubnet subnet) {
+ String[] ipPrefix = null;
+ String cidr = subnet.getCidr();
+ if (cidr.contains("/")) {
+ ipPrefix = cidr.split("/");
+ } else {
+ throw new IllegalArgumentException("String " + cidr + " not in correct format..");
+ }
+ return ipPrefix;
+ }
+}
--- /dev/null
+package org.opendaylight.plugin2oc.neutron;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.util.UUID;
+
+import net.juniper.contrail.api.ApiConnector;
+import net.juniper.contrail.api.types.LoadbalancerHealthmonitor;
+import net.juniper.contrail.api.types.LoadbalancerHealthmonitorType;
+import net.juniper.contrail.api.types.Project;
+
+import org.opendaylight.controller.networkconfig.neutron.INeutronLoadBalancerHealthMonitorAware;
+import org.opendaylight.controller.networkconfig.neutron.NeutronLoadBalancerHealthMonitor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Handle requests for Neutron LoadBalancerHealthMonitor.
+ */
+public class LoadBalancerHealthMonitorHandler implements INeutronLoadBalancerHealthMonitorAware {
+
+ /**
+ * Logger instance.
+ */
+ static final Logger LOGGER = LoggerFactory.getLogger(LoadBalancerHealthMonitorHandler.class);
+ static ApiConnector apiConnector;
+
+ /**
+ * Invoked when a health monitor creation is requested to check if the specified
+ * health monitor can be created and then creates the health monitor
+ *
+ * @param loadBalancerHealthMonitor
+ * An instance of proposed new NeutronLoadBalancerHealthMonitor object.
+ *
+ * @return A HTTP status code to the creation request.
+ */
+ @Override
+ public int canCreateNeutronLoadBalancerHealthMonitor(NeutronLoadBalancerHealthMonitor loadBalancerHealthMonitor) {
+ if (loadBalancerHealthMonitor == null) {
+ LOGGER.error("LoadBalancerHealthMonitor object can't be null..");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ apiConnector = Activator.apiConnector;
+ if (loadBalancerHealthMonitor.getLoadBalancerHealthMonitorTenantID() == null) {
+ LOGGER.error("LoadBalancerHealthMonitor tenant Id can not be null");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ try {
+ String loadBalancerHealthMonitorUUID = loadBalancerHealthMonitor.getLoadBalancerHealthMonitorID();
+ String projectUUID = loadBalancerHealthMonitor.getLoadBalancerHealthMonitorTenantID();
+ try {
+ if (!(loadBalancerHealthMonitorUUID.contains("-"))) {
+ loadBalancerHealthMonitorUUID = Utils.uuidFormater(loadBalancerHealthMonitorUUID);
+ }
+ if (!(projectUUID.contains("-"))) {
+ projectUUID = Utils.uuidFormater(projectUUID);
+ }
+ boolean isValidLoadBalancerHealthMonitorUUID = Utils.isValidHexNumber(loadBalancerHealthMonitorUUID);
+ boolean isValidprojectUUID = Utils.isValidHexNumber(projectUUID);
+ if (!isValidLoadBalancerHealthMonitorUUID || !isValidprojectUUID) {
+ LOGGER.info("Badly formed Hexadecimal UUID...");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ projectUUID = UUID.fromString(projectUUID).toString();
+ loadBalancerHealthMonitorUUID = UUID.fromString(loadBalancerHealthMonitorUUID).toString();
+ } catch (Exception ex) {
+ LOGGER.error("UUID input incorrect", ex);
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ Project project = (Project) apiConnector.findById(Project.class, projectUUID);
+ if (project == null) {
+ try {
+ Thread.currentThread();
+ Thread.sleep(3000);
+ } catch (InterruptedException e) {
+ LOGGER.error("InterruptedException : ", e);
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ project = (Project) apiConnector.findById(Project.class, projectUUID);
+ if (project == null) {
+ LOGGER.error("Could not find projectUUID...");
+ return HttpURLConnection.HTTP_NOT_FOUND;
+ }
+ }
+ LoadbalancerHealthmonitor virtualHealthMonitorByID = (LoadbalancerHealthmonitor) apiConnector.findById(
+ LoadbalancerHealthmonitor.class, loadBalancerHealthMonitorUUID);
+ if (virtualHealthMonitorByID != null) {
+ LOGGER.warn("LoadBalancerHealthMonitor already exists with UUID" + virtualHealthMonitorByID);
+ return HttpURLConnection.HTTP_FORBIDDEN;
+ }
+ return HttpURLConnection.HTTP_OK;
+ } catch (IOException ie) {
+ LOGGER.error("IOException : " + ie);
+ return HttpURLConnection.HTTP_INTERNAL_ERROR;
+ } catch (Exception e) {
+ LOGGER.error("Exception : " + e);
+ return HttpURLConnection.HTTP_INTERNAL_ERROR;
+ }
+ }
+
+ /**
+ * Invoked to take action after a health monitor has been created.
+ *
+ * @param loadBalancerHealthMonitor
+ * An instance of new NeutronLoadBalancerHealthMonitor object.
+ */
+ @Override
+ public void neutronLoadBalancerHealthMonitorCreated(NeutronLoadBalancerHealthMonitor loadBalancerHealthMonitor) {
+ try {
+ createHealthMonitor(loadBalancerHealthMonitor);
+ } catch (IOException ex) {
+ LOGGER.warn("Exception : " + ex);
+ }
+ LoadbalancerHealthmonitor virtuaLoadbalancerHealthMonitor = null;
+ try {
+ String loadBalancerHealthMonitorUUID = loadBalancerHealthMonitor.getLoadBalancerHealthMonitorID();
+ if (!(loadBalancerHealthMonitorUUID.contains("-"))) {
+ loadBalancerHealthMonitorUUID = Utils.uuidFormater(loadBalancerHealthMonitorUUID);
+ }
+ loadBalancerHealthMonitorUUID = UUID.fromString(loadBalancerHealthMonitorUUID).toString();
+ virtuaLoadbalancerHealthMonitor = (LoadbalancerHealthmonitor) apiConnector.findById(
+ LoadbalancerHealthmonitor.class, loadBalancerHealthMonitorUUID);
+ if (virtuaLoadbalancerHealthMonitor != null) {
+ LOGGER.info("LoadBalancerHealthMonitor creation verified....");
+ } else {
+ LOGGER.info("LoadBalancerHealthMonitor creation failed...");
+ }
+ } catch (Exception e) {
+ LOGGER.error("Exception : " + e);
+ }
+ }
+
+ /**
+ * Invoked to create the specified NeutronLoadBalancerHealthMonitor.
+ *
+ * @param loadBalancerHealthMonitor
+ * An instance of new NeutronLoadBalancerHealthMonitor object.
+ */
+ private void createHealthMonitor(NeutronLoadBalancerHealthMonitor loadBalancerHealthMonitor) throws IOException {
+ LoadbalancerHealthmonitor virtualLoadBalancerHealthMonitor = new LoadbalancerHealthmonitor();
+ virtualLoadBalancerHealthMonitor = mapLoadBalancerHealthMonitorProperties(loadBalancerHealthMonitor,
+ virtualLoadBalancerHealthMonitor);
+ boolean loadBalancerHealthMonitorCreated;
+ try {
+ loadBalancerHealthMonitorCreated = apiConnector.create(virtualLoadBalancerHealthMonitor);
+ LOGGER.debug("loadBalancerHealthMonitor: " + loadBalancerHealthMonitorCreated);
+ if (!loadBalancerHealthMonitorCreated) {
+ LOGGER.info("loadBalancerHealthMonitor creation failed..");
+ }
+ } catch (Exception Ex) {
+ LOGGER.error("Exception : " + Ex);
+ }
+ LOGGER.info("loadBalancerHealthMonitor:" + loadBalancerHealthMonitor.getLoadBalancerHealthMonitorID()
+ + "succesfully created.");
+ }
+
+ @Override
+ public int canUpdateNeutronLoadBalancerHealthMonitor(NeutronLoadBalancerHealthMonitor delta,
+ NeutronLoadBalancerHealthMonitor original) {
+ // TODO Auto-generated method stub
+ return 0;
+ }
+
+ @Override
+ public void neutronLoadBalancerHealthMonitorUpdated(NeutronLoadBalancerHealthMonitor loadBalancerHealthMonitor) {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public int canDeleteNeutronLoadBalancerHealthMonitor(NeutronLoadBalancerHealthMonitor loadBalancerHealthMonitor) {
+ // TODO Auto-generated method stub
+ return 0;
+ }
+
+ @Override
+ public void neutronLoadBalancerHealthMonitorDeleted(NeutronLoadBalancerHealthMonitor loadBalancerHealthMonitor) {
+ // TODO Auto-generated method stub
+
+ }
+
+ /**
+ * Invoked to map the NeutronLoadBalancerHealthMonitor object properties to the LoadbalancerHealthmonitor
+ * object.
+ *
+ * @param loadBalancerHealthMonitor
+ * An instance of new NeutronLoadBalancerHealthMonitor object.
+ * @param virtualLoadBalancerHealthMonitor
+ * An instance of new LoadbalancerHealthmonitor object.
+ * @return {@link LoadbalancerHealthmonitor}
+ */
+ private LoadbalancerHealthmonitor mapLoadBalancerHealthMonitorProperties(
+ NeutronLoadBalancerHealthMonitor loadBalancerHealthMonitor,
+ LoadbalancerHealthmonitor virtualLoadBalancerHealthMonitor) {
+ String loadBalancerHealthMonitorUUID = loadBalancerHealthMonitor.getLoadBalancerHealthMonitorID();
+ String projectUUID = loadBalancerHealthMonitor.getLoadBalancerHealthMonitorTenantID();
+ try {
+ if (!(loadBalancerHealthMonitorUUID.contains("-"))) {
+ loadBalancerHealthMonitorUUID = Utils.uuidFormater(loadBalancerHealthMonitorUUID);
+ }
+ if (!(projectUUID.contains("-"))) {
+ projectUUID = Utils.uuidFormater(projectUUID);
+ }
+ projectUUID = UUID.fromString(projectUUID).toString();
+ loadBalancerHealthMonitorUUID = UUID.fromString(loadBalancerHealthMonitorUUID).toString();
+ Project project = (Project) apiConnector.findById(Project.class, projectUUID);
+ virtualLoadBalancerHealthMonitor.setParent(project);
+ } catch (Exception ex) {
+ LOGGER.error("UUID input incorrect", ex);
+ }
+ virtualLoadBalancerHealthMonitor.setDisplayName(loadBalancerHealthMonitorUUID);
+ virtualLoadBalancerHealthMonitor.setName(loadBalancerHealthMonitorUUID);
+ virtualLoadBalancerHealthMonitor.setUuid(loadBalancerHealthMonitorUUID);
+ LoadbalancerHealthmonitorType loadbalancer_healthmonitor_properties = new LoadbalancerHealthmonitorType();
+ if (loadBalancerHealthMonitor.getLoadBalancerHealthMonitorAdminStateIsUp() != null) {
+ loadbalancer_healthmonitor_properties.setAdminState(loadBalancerHealthMonitor
+ .getLoadBalancerHealthMonitorAdminStateIsUp());
+ } else {
+ loadbalancer_healthmonitor_properties.setAdminState(true);
+ }
+ if (loadBalancerHealthMonitor.getLoadBalancerHealthMonitorDelay() != null) {
+ loadbalancer_healthmonitor_properties.setDelay(loadBalancerHealthMonitor
+ .getLoadBalancerHealthMonitorDelay());
+ }
+ if (loadBalancerHealthMonitor.getLoadBalancerHealthMonitorExpectedCodes() != null) {
+ loadbalancer_healthmonitor_properties.setExpectedCodes(loadBalancerHealthMonitor
+ .getLoadBalancerHealthMonitorExpectedCodes());
+ }
+ if (loadBalancerHealthMonitor.getLoadBalancerHealthMonitorHttpMethod() != null) {
+ loadbalancer_healthmonitor_properties.setHttpMethod(loadBalancerHealthMonitor
+ .getLoadBalancerHealthMonitorHttpMethod());
+ }
+ if (loadBalancerHealthMonitor.getLoadBalancerHealthMonitorMaxRetries() != null) {
+ loadbalancer_healthmonitor_properties.setMaxRetries(loadBalancerHealthMonitor
+ .getLoadBalancerHealthMonitorMaxRetries());
+ }
+ if (loadBalancerHealthMonitor.getLoadBalancerHealthMonitorTimeout() != null) {
+ loadbalancer_healthmonitor_properties.setTimeout(loadBalancerHealthMonitor
+ .getLoadBalancerHealthMonitorTimeout());
+ }
+ if (loadBalancerHealthMonitor.getLoadBalancerHealthMonitorType() != null) {
+ loadbalancer_healthmonitor_properties.setType(loadBalancerHealthMonitor.getLoadBalancerHealthMonitorType());
+ }
+ if (loadBalancerHealthMonitor.getLoadBalancerHealthMonitorUrlPath() != null) {
+ loadbalancer_healthmonitor_properties.setUrlPath(loadBalancerHealthMonitor
+ .getLoadBalancerHealthMonitorUrlPath());
+ }
+ virtualLoadBalancerHealthMonitor.setProperties(loadbalancer_healthmonitor_properties);
+ return virtualLoadBalancerHealthMonitor;
+ }
+}
--- /dev/null
+package org.opendaylight.plugin2oc.neutron;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.util.UUID;
+
+import net.juniper.contrail.api.ApiConnector;
+import net.juniper.contrail.api.types.LoadbalancerPool;
+import net.juniper.contrail.api.types.Project;
+
+import org.opendaylight.controller.networkconfig.neutron.INeutronLoadBalancerListenerAware;
+import org.opendaylight.controller.networkconfig.neutron.NeutronLoadBalancerListener;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Handle requests for Neutron LoadBalancerListener.
+ */
+public class LoadBalancerListenerHandler implements INeutronLoadBalancerListenerAware {
+ /**
+ * Logger instance.
+ */
+ static final Logger LOGGER = LoggerFactory.getLogger(LoadBalancerListenerHandler.class);
+ static ApiConnector apiConnector;
+
+ /**
+ * Invoked when a listener creation is requested to check if the specified
+ * listener can be created and then creates the listener
+ *
+ * @param loadBalancerListener
+ * An instance of proposed new NeutronLoadBalancerListener
+ * object.
+ *
+ * @return A HTTP status code to the creation request.
+ */
+ @Override
+ public int canCreateNeutronLoadBalancerListener(NeutronLoadBalancerListener loadBalancerListener) {
+ if (loadBalancerListener == null) {
+ LOGGER.error("loadBalancerListener object can't be null..");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ apiConnector = Activator.apiConnector;
+ if (loadBalancerListener.getLoadBalancerListenerTenantID() == null) {
+ LOGGER.error("LoadBalancerListener tenant Id can not be null");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ if (loadBalancerListener.getNeutronLoadBalancerListenerDefaultPoolID() == null) {
+ LOGGER.error("LoadBalancerListener DefaultPoolID can not be null");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ if (loadBalancerListener.getNeutronLoadBalancerListenerLoadBalancerID() == null) {
+ LOGGER.error("LoadBalancerListener ID can not be null");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ if (loadBalancerListener.getNeutronLoadBalancerListenerProtocol() == null) {
+ LOGGER.error("LoadBalancerListener protocol can not be null");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ if (!(loadBalancerListener.getNeutronLoadBalancerListenerProtocol().equals("TCP")
+ || loadBalancerListener.getNeutronLoadBalancerListenerProtocol().equals("HTTP") || loadBalancerListener
+ .getNeutronLoadBalancerListenerProtocol().equals("HTTPS"))) {
+ LOGGER.error("LoadBalancerListener Protocol can not be other than TCP/HTTP/HTTPS");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ try {
+ String loadBalancerListenerUUID = loadBalancerListener.getLoadBalancerListenerID();
+ String loadBalancerDefaultPoolID = loadBalancerListener.getNeutronLoadBalancerListenerDefaultPoolID();
+ String loadBalancerUUID = loadBalancerListener.getNeutronLoadBalancerListenerLoadBalancerID();
+ String projectUUID = loadBalancerListener.getLoadBalancerListenerTenantID();
+ try {
+ if (!(loadBalancerListenerUUID.contains("-"))) {
+ loadBalancerListenerUUID = Utils.uuidFormater(loadBalancerListenerUUID);
+ }
+ if (!(loadBalancerDefaultPoolID.contains("-"))) {
+ loadBalancerDefaultPoolID = Utils.uuidFormater(loadBalancerDefaultPoolID);
+ }
+ if (!(loadBalancerUUID.contains("-"))) {
+ loadBalancerUUID = Utils.uuidFormater(loadBalancerUUID);
+ }
+ if (!(projectUUID.contains("-"))) {
+ projectUUID = Utils.uuidFormater(projectUUID);
+ }
+ boolean isValidLoadBalancerListenerUUID = Utils.isValidHexNumber(loadBalancerListenerUUID);
+ boolean isValidLoadBalancerDefaultPoolID = Utils.isValidHexNumber(loadBalancerDefaultPoolID);
+ boolean isValidLoadBalancerUUID = Utils.isValidHexNumber(loadBalancerUUID);
+ boolean isValidprojectUUID = Utils.isValidHexNumber(projectUUID);
+ if (!isValidLoadBalancerListenerUUID || !isValidLoadBalancerDefaultPoolID || !isValidLoadBalancerUUID
+ || !isValidprojectUUID) {
+ LOGGER.info("Badly formed Hexadecimal UUID...");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ loadBalancerListenerUUID = UUID.fromString(loadBalancerListenerUUID).toString();
+ loadBalancerDefaultPoolID = UUID.fromString(loadBalancerDefaultPoolID).toString();
+ loadBalancerUUID = UUID.fromString(loadBalancerUUID).toString();
+ projectUUID = UUID.fromString(projectUUID).toString();
+ } catch (Exception ex) {
+ LOGGER.error("UUID input incorrect", ex);
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ Project project = (Project) apiConnector.findById(Project.class, projectUUID);
+ if (project == null) {
+ try {
+ Thread.currentThread();
+ Thread.sleep(3000);
+ } catch (InterruptedException e) {
+ LOGGER.error("InterruptedException : ", e);
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ project = (Project) apiConnector.findById(Project.class, projectUUID);
+ if (project == null) {
+ LOGGER.error("Could not find projectUUID...");
+ return HttpURLConnection.HTTP_NOT_FOUND;
+ }
+ }
+ // String virtualLoadbalancerListenerByName =
+ // apiConnector.findByName(LoadbalancerListener.class, project,
+ // loadBalancerListener.getLoadBalancerListenerName());
+ // if (virtualLoadbalancerListenerByName != null) {
+ // LOGGER.warn("Lsitener already exists with name : " +
+ // virtualLoadbalancerListenerByName);
+ // return HttpURLConnection.HTTP_FORBIDDEN;
+ // }
+ // LoadBalancerListener virtualLoadbalancerListenerById =
+ // (LoadBalancerListener) apiConnector.findById(
+ // LoadBalancerListener.class, loadBalancerListenerUUID);
+ // if (virtualLoadbalancerListenerById != null) {
+ // LOGGER.warn("LoadbalancerListener already exists with UUID" +
+ // loadBalancerListenerUUID);
+ // return HttpURLConnection.HTTP_FORBIDDEN;
+ // }
+ LoadbalancerPool virtualLoadBalancerDefaultPoolID = (LoadbalancerPool) apiConnector.findById(
+ LoadbalancerPool.class, loadBalancerDefaultPoolID);
+ if (virtualLoadBalancerDefaultPoolID == null) {
+ LOGGER.warn("Default LoadbalancerPool does not exists with UUID");
+ return HttpURLConnection.HTTP_FORBIDDEN;
+ }
+ // LoadBalancer virtualLoadBalancerListenerID = (LoadBalancer)
+ // apiConnector.findById(
+ // LoadBalancer.class, loadBalancerUUID);
+ // if (virtualLoadBalancerListenerID== null) {
+ // LOGGER.warn("Listener does not exists");
+ // return HttpURLConnection.HTTP_FORBIDDEN;
+ // }
+ return HttpURLConnection.HTTP_OK;
+ } catch (IOException ie) {
+ LOGGER.error("IOException : " + ie);
+ return HttpURLConnection.HTTP_INTERNAL_ERROR;
+ } catch (Exception e) {
+ LOGGER.error("Exception : " + e);
+ return HttpURLConnection.HTTP_INTERNAL_ERROR;
+ }
+ }
+
+ /**
+ * Invoked to take action after a listener has been created.
+ *
+ * @param loadBalancerListener
+ * An instance of new NeutronLoadBalancerListener object.
+ */
+ @Override
+ public void neutronLoadBalancerListenerCreated(NeutronLoadBalancerListener loadBalancerListener) {
+ try {
+ createLoadBalancerListener(loadBalancerListener);
+ } catch (IOException ex) {
+ LOGGER.warn("Exception : " + ex);
+ }
+ // LoadBalancerListener LoadBalancerListener = null;
+ try {
+ String loadBalancerListenerUUID = loadBalancerListener.getLoadBalancerListenerID();
+ if (!(loadBalancerListenerUUID.contains("-"))) {
+ loadBalancerListenerUUID = Utils.uuidFormater(loadBalancerListenerUUID);
+ }
+ loadBalancerListenerUUID = UUID.fromString(loadBalancerListenerUUID).toString();
+ // LoadBalancerListener loadbalancerListener= (LoadbalancerListener)
+ // apiConnector.findById(LoadbalancerListener.class,
+ // loadBalancerListenerUUID);
+ // if (loadbalancerListener != null) {
+ // LOGGER.info("LoadbalancerListener creation verified....");
+ // } else {
+ // LOGGER.info("LoadbalancerListener creation failed...");
+ // }
+ } catch (Exception e) {
+ LOGGER.error("Exception : " + e);
+ }
+
+ }
+
+ /**
+ * Invoked to create the specified NeutronLoadBalancerListener.
+ *
+ * @param loadBalancerListener
+ * An instance of new NeutronLoadBalancerListener object.
+ */
+ private void createLoadBalancerListener(NeutronLoadBalancerListener loadBalancerListener) throws IOException {
+ // TODO: write code once v2 support is available with opencontrail
+ }
+
+ @Override
+ public int canUpdateNeutronLoadBalancerListener(NeutronLoadBalancerListener delta,
+ NeutronLoadBalancerListener original) {
+ // TODO Auto-generated method stub
+ return 0;
+ }
+
+ @Override
+ public void neutronLoadBalancerListenerUpdated(NeutronLoadBalancerListener loadBalancerListener) {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public int canDeleteNeutronLoadBalancerListener(NeutronLoadBalancerListener loadBalancerListener) {
+ // TODO Auto-generated method stub
+ return 0;
+ }
+
+ @Override
+ public void neutronLoadBalancerListenerDeleted(NeutronLoadBalancerListener loadBalancerListener) {
+ // TODO Auto-generated method stub
+
+ }
+ /**
+ * Invoked to map the NeutronLoadBalancerListener object properties to the
+ * LoadBalancerListener object.
+ *
+ * @param loadBalancerListener
+ * An instance of new NeutronLoadBalancerListener object.
+ * @param virtualLoadBalancerListener
+ * An instance of new LoadBalancerListener object.
+ * @return {@link LoadBalancerListener}
+ */
+ // private LoadBalancerListener
+ // mapLoadBalancerListenerProperties(NeutronLoadBalancerListener
+ // loadBalancerListener,
+ // LoadBalancerListener virtualLoadBalancerListener) {
+ // TODO: map properties between ODL-Neutron-Listener object and Opencontrail
+ // Listener object
+ // return virtualLoadBalancerListener;
+ // }
+}
--- /dev/null
+package org.opendaylight.plugin2oc.neutron;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.util.List;
+import java.util.UUID;
+
+import net.juniper.contrail.api.ApiConnector;
+import net.juniper.contrail.api.types.LoadbalancerMember;
+import net.juniper.contrail.api.types.LoadbalancerPool;
+import net.juniper.contrail.api.types.LoadbalancerPoolType;
+import net.juniper.contrail.api.types.Project;
+
+import org.opendaylight.controller.networkconfig.neutron.INeutronLoadBalancerPoolAware;
+import org.opendaylight.controller.networkconfig.neutron.NeutronLoadBalancerPool;
+import org.opendaylight.controller.networkconfig.neutron.NeutronLoadBalancerPoolMember;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Handle requests for Neutron LoadbalancerPool.
+ */
+
+public class LoadBalancerPoolHandler implements INeutronLoadBalancerPoolAware {
+ /**
+ * Logger instance.
+ */
+ static final Logger LOGGER = LoggerFactory.getLogger(LoadBalancerPoolHandler.class);
+ static ApiConnector apiConnector;
+
+ /**
+ * Invoked when a pool creation is requested to check if the specified
+ * pool can be created and then creates the pool
+ *
+ * @param loadBalancerPool
+ * An instance of proposed new Neutron Pool object.
+ *
+ * @return A HTTP status code to the creation request.
+ */
+ @Override
+ public int canCreateNeutronLoadBalancerPool(NeutronLoadBalancerPool loadBalancerPool) {
+ if (loadBalancerPool == null) {
+ LOGGER.error("LoadBalancerPool object can't be null..");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ apiConnector = Activator.apiConnector;
+ if (loadBalancerPool.getLoadBalancerPoolTenantID() == null) {
+ LOGGER.error("LoadBalancerPool tenant Id can not be null");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ if (loadBalancerPool.getLoadBalancerPoolLbAlgorithm() == null) {
+ LOGGER.error("LoadBalancerPool Algorithm can not be null");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ if (!(loadBalancerPool.getLoadBalancerPoolLbAlgorithm().equals("ROUND_ROBIN")
+ || loadBalancerPool.getLoadBalancerPoolLbAlgorithm().equals("LEAST_CONNECTIONS") || loadBalancerPool
+ .getLoadBalancerPoolLbAlgorithm().equals("Source IP"))) {
+ LOGGER.error("LoadBalancerPool Algorithm can not be anything other than ROUND_ROBIN and LEAST_CONNECTIONS and Source IP");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ if (loadBalancerPool.getLoadBalancerPoolProtocol() == null) {
+ LOGGER.error("LoadBalancerPool protocol can not be null");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ if (!(loadBalancerPool.getLoadBalancerPoolProtocol().equals("TCP")
+ || loadBalancerPool.getLoadBalancerPoolProtocol().equals("HTTP") || loadBalancerPool
+ .getLoadBalancerPoolProtocol().equals("HTTPS"))) {
+ LOGGER.error("LoadBalancerPool Protocol can not be other than TCP/HTTP/HTTPS");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ if (loadBalancerPool.getLoadBalancerPoolMembers() != null) {
+ List<NeutronLoadBalancerPoolMember> i = loadBalancerPool.getLoadBalancerPoolMembers();
+ for (NeutronLoadBalancerPoolMember ref : i) {
+ String poolmemberID = ref.getPoolMemberID();
+ String tenantID = ref.getPoolMemberTenantID();
+ if (!(tenantID.equals(loadBalancerPool.getLoadBalancerPoolTenantID()))) {
+ LOGGER.error("Member and pool does not belong to same tenant");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ try {
+ LoadbalancerMember lbpm = (LoadbalancerMember) apiConnector.findById(LoadbalancerMember.class,
+ poolmemberID);
+ if (lbpm != null) {
+ LOGGER.error("Member already exist with UUID: " + poolmemberID);
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ } catch (IOException e) {
+ LOGGER.error("IOException : " + e);
+ return HttpURLConnection.HTTP_INTERNAL_ERROR;
+ }
+ }
+ }
+ try {
+ String loadBalancerPoolUUID = loadBalancerPool.getLoadBalancerPoolID();
+ String projectUUID = loadBalancerPool.getLoadBalancerPoolTenantID();
+ try {
+ if (!(loadBalancerPoolUUID.contains("-"))) {
+ loadBalancerPoolUUID = Utils.uuidFormater(loadBalancerPoolUUID);
+ }
+ if (!(projectUUID.contains("-"))) {
+ projectUUID = Utils.uuidFormater(projectUUID);
+ }
+ boolean isValidLoadBalancerPoolUUID = Utils.isValidHexNumber(loadBalancerPoolUUID);
+ boolean isValidprojectUUID = Utils.isValidHexNumber(projectUUID);
+ if (!isValidLoadBalancerPoolUUID || !isValidprojectUUID) {
+ LOGGER.info("Badly formed Hexadecimal UUID...");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ projectUUID = UUID.fromString(projectUUID).toString();
+ loadBalancerPoolUUID = UUID.fromString(loadBalancerPoolUUID).toString();
+ } catch (Exception ex) {
+ LOGGER.error("UUID input incorrect", ex);
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ Project project = (Project) apiConnector.findById(Project.class, projectUUID);
+ if (project == null) {
+ try {
+ Thread.currentThread();
+ Thread.sleep(3000);
+ } catch (InterruptedException e) {
+ LOGGER.error("InterruptedException : ", e);
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ project = (Project) apiConnector.findById(Project.class, projectUUID);
+ if (project == null) {
+ LOGGER.error("Could not find projectUUID...");
+ return HttpURLConnection.HTTP_NOT_FOUND;
+ }
+ }
+ String virtualLoadbalancerPoolByName = apiConnector.findByName(LoadbalancerPool.class, project,
+ loadBalancerPool.getLoadBalancerPoolName());
+ if (virtualLoadbalancerPoolByName != null) {
+ LOGGER.warn("POOL already exists with name : " + virtualLoadbalancerPoolByName);
+ return HttpURLConnection.HTTP_FORBIDDEN;
+ }
+ LoadbalancerPool virtualLoadbalancerPoolById = (LoadbalancerPool) apiConnector.findById(
+ LoadbalancerPool.class, loadBalancerPoolUUID);
+ if (virtualLoadbalancerPoolById != null) {
+ LOGGER.warn("LoadbalancerPool already exists with UUID" + loadBalancerPoolUUID);
+ return HttpURLConnection.HTTP_FORBIDDEN;
+ }
+ return HttpURLConnection.HTTP_OK;
+ } catch (IOException ie) {
+ LOGGER.error("IOException : " + ie);
+ return HttpURLConnection.HTTP_INTERNAL_ERROR;
+ } catch (Exception e) {
+ LOGGER.error("Exception : " + e);
+ return HttpURLConnection.HTTP_INTERNAL_ERROR;
+ }
+ }
+
+ /**
+ * Invoked to take action after a pool has been created.
+ *
+ * @param loadBalancerPool
+ * An instance of new Neutron Pool object.
+ */
+ @Override
+ public void neutronLoadBalancerPoolCreated(NeutronLoadBalancerPool loadBalancerPool) {
+ try {
+ createLoadBalancerPool(loadBalancerPool);
+ } catch (IOException ex) {
+ LOGGER.warn("Exception : " + ex);
+ }
+ LoadbalancerPool virtualLoadBalancerPool = null;
+ try {
+ String loadBalancerPoolUUID = loadBalancerPool.getLoadBalancerPoolID();
+ if (!(loadBalancerPoolUUID.contains("-"))) {
+ loadBalancerPoolUUID = Utils.uuidFormater(loadBalancerPoolUUID);
+ }
+ loadBalancerPoolUUID = UUID.fromString(loadBalancerPoolUUID).toString();
+ virtualLoadBalancerPool = (LoadbalancerPool) apiConnector.findById(LoadbalancerPool.class,
+ loadBalancerPoolUUID);
+ if (virtualLoadBalancerPool != null) {
+ LOGGER.info("LoadbalancerPool creation verified....");
+ } else {
+ LOGGER.info("LoadbalancerPool creation failed...");
+ }
+ } catch (Exception e) {
+ LOGGER.error("Exception : " + e);
+ }
+ }
+
+ /**
+ * Invoked to create the specified Neutron Pool.
+ *
+ * @param loadBalancerPool
+ * An instance of new Neutron Pool object.
+ */
+ private void createLoadBalancerPool(NeutronLoadBalancerPool loadBalancerPool) throws IOException {
+ LoadbalancerPool virtualLoadBalancerPool = new LoadbalancerPool();
+ virtualLoadBalancerPool = mapLoadBalancerPoolProperties(loadBalancerPool, virtualLoadBalancerPool);
+ boolean loadBalancerPoolCreated;
+ try {
+ loadBalancerPoolCreated = apiConnector.create(virtualLoadBalancerPool);
+ LOGGER.debug("loadBalancerPool: " + loadBalancerPoolCreated);
+ if (!loadBalancerPoolCreated) {
+ LOGGER.info("loadBalancerPool creation failed..");
+ }
+ } catch (Exception Ex) {
+ LOGGER.error("Exception : " + Ex);
+ }
+ LOGGER.info("loadBalancerPool:" + loadBalancerPool.getLoadBalancerPoolName() + "having ID"
+ + loadBalancerPool.getLoadBalancerPoolID() + "succesfully created.");
+ if (loadBalancerPool.getLoadBalancerPoolMembers() != null) {
+ List<NeutronLoadBalancerPoolMember> i = loadBalancerPool.getLoadBalancerPoolMembers();
+ for (NeutronLoadBalancerPoolMember ref : i) {
+ LoadBalancerPoolMemberHandler lbmh = new LoadBalancerPoolMemberHandler();
+ int value = lbmh.canCreateNeutronLoadBalancerPoolMember(ref);
+ if (value == 200) {
+ lbmh.neutronLoadBalancerPoolMemberCreated(ref);
+ } else {
+ LOGGER.error("NeutronLoadBalancerPool Member creation failed");
+ }
+ }
+ }
+ }
+
+ /**
+ * Invoked when a pool update is requested to indicate if the specified
+ * pool can be changed using the specified delta.
+ *
+ * @param delta
+ * Updates to the pool object using patch semantics.
+ * @param original
+ * An instance of the Neutron pool object to be updated.
+ * @return A HTTP status code to the update request.
+ */
+ @Override
+ public int canUpdateNeutronLoadBalancerPool(NeutronLoadBalancerPool delta, NeutronLoadBalancerPool original) {
+ apiConnector = Activator.apiConnector;
+ LoadbalancerPool virtualLoadBalancerPool;
+ if (delta == null || original == null) {
+ LOGGER.error("NeutronLoadBalancerPool objects cant be empty or null");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ String loadBalancerPoolUUID = original.getLoadBalancerPoolID();
+ try {
+ if (!(loadBalancerPoolUUID.contains("-"))) {
+ loadBalancerPoolUUID = Utils.uuidFormater(loadBalancerPoolUUID);
+ }
+ loadBalancerPoolUUID = UUID.fromString(loadBalancerPoolUUID).toString();
+ } catch (Exception ex) {
+ LOGGER.error("UUID input incorrect", ex);
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ try {
+ virtualLoadBalancerPool = (LoadbalancerPool) apiConnector.findById(LoadbalancerPool.class,
+ loadBalancerPoolUUID);
+ if (virtualLoadBalancerPool == null) {
+ LOGGER.error("No LoadbalancerPool exists for the specified ID...");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ } catch (IOException e) {
+ return HttpURLConnection.HTTP_INTERNAL_ERROR;
+ }
+
+ return HttpURLConnection.HTTP_OK;
+ }
+
+ @Override
+ public void neutronLoadBalancerPoolUpdated(NeutronLoadBalancerPool loadBalancerPool) {
+ // TODO Auto-generated method stub
+ }
+
+ /**
+ * Invoked when a pool deletion is requested to indicate if the specified
+ * pool can be deleted.
+ *
+ * @param loadBalancerPool
+ * An instance of the NeutronLoadBalancerPool object to be deleted.
+ * @return A HTTP status code to the deletion request.
+ */
+ @Override
+ public int canDeleteNeutronLoadBalancerPool(NeutronLoadBalancerPool loadBalancerPool) {
+ apiConnector = Activator.apiConnector;
+ LoadbalancerPool virtualLoadBalancerPool = null;
+ String loadBalancerPoolUUID = loadBalancerPool.getLoadBalancerPoolID();
+ try {
+ if (!(loadBalancerPoolUUID.contains("-"))) {
+ loadBalancerPoolUUID = Utils.uuidFormater(loadBalancerPoolUUID);
+ }
+ loadBalancerPoolUUID = UUID.fromString(loadBalancerPoolUUID).toString();
+ } catch (Exception ex) {
+ LOGGER.error("UUID input incorrect", ex);
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ try {
+ virtualLoadBalancerPool = (LoadbalancerPool) apiConnector.findById(LoadbalancerPool.class,
+ loadBalancerPoolUUID);
+ if (virtualLoadBalancerPool == null) {
+ LOGGER.info("No LoadbalancerPool exists with ID : " + loadBalancerPoolUUID);
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ return HttpURLConnection.HTTP_OK;
+ } catch (Exception e) {
+ LOGGER.error("Exception : " + e);
+ return HttpURLConnection.HTTP_INTERNAL_ERROR;
+ }
+ }
+
+ /**
+ * Invoked to take action after a pool has been deleted.
+ *
+ * @param loadBalancerPool
+ * An instance of deleted NeutronLoadBalancerPool object.
+ */
+ @Override
+ public void neutronLoadBalancerPoolDeleted(NeutronLoadBalancerPool loadBalancerPool) {
+ LoadbalancerPool virtualLoadBalancerPool = null;
+ try {
+ String loadBalancerPoolUUID = loadBalancerPool.getLoadBalancerPoolID();
+ if (!(loadBalancerPoolUUID.contains("-"))) {
+ loadBalancerPoolUUID = Utils.uuidFormater(loadBalancerPoolUUID);
+ }
+ loadBalancerPoolUUID = UUID.fromString(loadBalancerPoolUUID).toString();
+ virtualLoadBalancerPool = (LoadbalancerPool) apiConnector.findById(LoadbalancerPool.class,
+ loadBalancerPoolUUID);
+ apiConnector.delete(virtualLoadBalancerPool);
+ if (virtualLoadBalancerPool == null) {
+ LOGGER.info("LoadbalancerPool deletion verified....");
+ } else {
+ LOGGER.info("LoadbalancerPool with ID : " + loadBalancerPoolUUID + "deletion failed");
+ }
+ } catch (Exception ex) {
+ LOGGER.error("Exception : " + ex);
+ }
+ }
+
+ /**
+ * Invoked to map the NeutronLoadBalancerPool object properties to the LoadbalancerPool
+ * object.
+ *
+ * @param loadBalancerPool
+ * An instance of new NeutronLoadBalancerPool object.
+ * @param virtualLoadBalancerPool
+ * An instance of new LoadbalancerPool object.
+ * @return {@link LoadbalancerPool}
+ */
+ private LoadbalancerPool mapLoadBalancerPoolProperties(NeutronLoadBalancerPool loadBalancerPool,
+ LoadbalancerPool virtualLoadBalancerPool) {
+ String loadBalancerPoolUUID = loadBalancerPool.getLoadBalancerPoolID();
+ String loadBalancerPoolName = loadBalancerPool.getLoadBalancerPoolName();
+ String projectUUID = loadBalancerPool.getLoadBalancerPoolTenantID();
+ try {
+ if (!(loadBalancerPoolUUID.contains("-"))) {
+ loadBalancerPoolUUID = Utils.uuidFormater(loadBalancerPoolUUID);
+ }
+ loadBalancerPoolUUID = UUID.fromString(loadBalancerPoolUUID).toString();
+ if (!(projectUUID.contains("-"))) {
+ projectUUID = Utils.uuidFormater(projectUUID);
+ }
+ projectUUID = UUID.fromString(projectUUID).toString();
+ Project project = (Project) apiConnector.findById(Project.class, projectUUID);
+ virtualLoadBalancerPool.setParent(project);
+ } catch (Exception ex) {
+ LOGGER.error("UUID input incorrect", ex);
+ }
+ LoadbalancerPoolType loadbalancer_pool_properties = new LoadbalancerPoolType();
+ loadbalancer_pool_properties.setLoadbalancerMethod(loadBalancerPool.getLoadBalancerPoolLbAlgorithm());
+ loadbalancer_pool_properties.setProtocol(loadBalancerPool.getLoadBalancerPoolProtocol());
+ if (loadBalancerPool.getLoadBalancerPoolAdminIsStateIsUp() != null) {
+ loadbalancer_pool_properties.setAdminState(loadBalancerPool.getLoadBalancerPoolAdminIsStateIsUp());
+ } else {
+ loadbalancer_pool_properties.setAdminState(true);
+ }
+ if (loadBalancerPool.getLoadBalancerPoolStatus() != null) {
+ loadbalancer_pool_properties.setStatus(loadBalancerPool.getLoadBalancerPoolStatus());
+ }
+ if (loadBalancerPool.getLoadBalancerPoolDescription() != null) {
+ loadbalancer_pool_properties.setStatusDescription(loadBalancerPool.getLoadBalancerPoolDescription());
+ }
+ virtualLoadBalancerPool.setUuid(loadBalancerPoolUUID);
+ virtualLoadBalancerPool.setName(loadBalancerPoolName);
+ virtualLoadBalancerPool.setDisplayName(loadBalancerPoolName);
+ virtualLoadBalancerPool.setProperties(loadbalancer_pool_properties);
+ /* haproxy is the provider for loadbalancer pool in OpenContrail */
+ virtualLoadBalancerPool.setProvider("haproxy");
+ return virtualLoadBalancerPool;
+ }
+
+}
--- /dev/null
+package org.opendaylight.plugin2oc.neutron;
+
+import java.util.List;
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.util.UUID;
+
+import net.juniper.contrail.api.ApiConnector;
+import net.juniper.contrail.api.ApiPropertyBase;
+import net.juniper.contrail.api.ObjectReference;
+import net.juniper.contrail.api.types.InstanceIp;
+import net.juniper.contrail.api.types.LoadbalancerMember;
+import net.juniper.contrail.api.types.LoadbalancerMemberType;
+import net.juniper.contrail.api.types.LoadbalancerPool;
+import net.juniper.contrail.api.types.Project;
+import net.juniper.contrail.api.types.VirtualMachineInterface;
+
+import org.opendaylight.controller.networkconfig.neutron.INeutronLoadBalancerPoolMemberAware;
+import org.opendaylight.controller.networkconfig.neutron.NeutronLoadBalancerPoolMember;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Handle requests for Neutron LoadbalancerPoolMember.
+ */
+
+public class LoadBalancerPoolMemberHandler implements INeutronLoadBalancerPoolMemberAware {
+ /**
+ * Logger instance.
+ */
+ static final Logger LOGGER = LoggerFactory.getLogger(LoadBalancerPoolMemberHandler.class);
+ static ApiConnector apiConnector;
+
+ /**
+ * Invoked when a member creation is requested to check if the specified
+ * member can be created and then creates the member
+ *
+ * @param loadBalancerPoolMember
+ * An instance of proposed new NeutronLoadBalancerPoolMember object.
+ *
+ * @return A HTTP status code to the creation request.
+ */
+ @Override
+ public int canCreateNeutronLoadBalancerPoolMember(NeutronLoadBalancerPoolMember loadBalancerPoolMember) {
+ if (loadBalancerPoolMember == null) {
+ LOGGER.error("LoadBalancerPool Member object can't be null..");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ apiConnector = Activator.apiConnector;
+ if (loadBalancerPoolMember.getPoolMemberTenantID() == null
+ || loadBalancerPoolMember.getPoolMemberSubnetID() == null) {
+ LOGGER.error("LoadBalancerPool Member TenanID/SubnetID can not be null");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ try {
+ String loadBalancerPoolID = loadBalancerPoolMember.getPoolID();
+ String loadBalancerPoolMemberUUID = loadBalancerPoolMember.getPoolMemberID();
+ String projectUUID = loadBalancerPoolMember.getPoolMemberTenantID();
+ try {
+ if (!(loadBalancerPoolMemberUUID.contains("-"))) {
+ loadBalancerPoolMemberUUID = Utils.uuidFormater(loadBalancerPoolMemberUUID);
+ }
+ if (!(projectUUID.contains("-"))) {
+ projectUUID = Utils.uuidFormater(projectUUID);
+ }
+ boolean isValidLoadBalancerPoolMemberUUID = Utils.isValidHexNumber(loadBalancerPoolMemberUUID);
+ boolean isValidprojectUUID = Utils.isValidHexNumber(projectUUID);
+ if (!isValidLoadBalancerPoolMemberUUID || !isValidprojectUUID) {
+ LOGGER.info("Badly formed Hexadecimal UUID...");
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ projectUUID = UUID.fromString(projectUUID).toString();
+ loadBalancerPoolMemberUUID = UUID.fromString(loadBalancerPoolMemberUUID).toString();
+ if (!(loadBalancerPoolID.contains("-"))) {
+ loadBalancerPoolID = Utils.uuidFormater(loadBalancerPoolID);
+ }
+ loadBalancerPoolID = UUID.fromString(loadBalancerPoolID).toString();
+ } catch (Exception ex) {
+ LOGGER.error("UUID input incorrect", ex);
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ Project project = (Project) apiConnector.findById(Project.class, projectUUID);
+ if (project == null) {
+ try {
+ Thread.currentThread();
+ Thread.sleep(3000);
+ } catch (InterruptedException e) {
+ LOGGER.error("InterruptedException : ", e);
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ project = (Project) apiConnector.findById(Project.class, projectUUID);
+ if (project == null) {
+ LOGGER.error("Could not find projectUUID...");
+ return HttpURLConnection.HTTP_NOT_FOUND;
+ }
+ }
+ if (project.getVirtualMachineInterfaces() != null) {
+ List<ObjectReference<ApiPropertyBase>> vmiList = project.getVirtualMachineInterfaces();
+ for (ObjectReference<ApiPropertyBase> ref : vmiList) {
+ String vmiUUID = ref.getUuid();
+ VirtualMachineInterface vmi = (VirtualMachineInterface) apiConnector.findById(
+ VirtualMachineInterface.class, vmiUUID);
+ List<ObjectReference<ApiPropertyBase>> iip = vmi.getInstanceIpBackRefs();
+ for (ObjectReference<ApiPropertyBase> iipRef : iip) {
+ String iipUUID = iipRef.getUuid();
+ InstanceIp instanceIP = (InstanceIp) apiConnector.findById(InstanceIp.class, iipUUID);
+ if (!(loadBalancerPoolMember.getPoolMemberAddress().equals(instanceIP.getAddress()))) {
+ LOGGER.warn("LoadbalancerPool Member address does not exists...");
+ return HttpURLConnection.HTTP_FORBIDDEN;
+ }
+ }
+ }
+ } else {
+ LOGGER.warn("No Servers available to create a member...");
+ return HttpURLConnection.HTTP_FORBIDDEN;
+ }
+ LoadbalancerMember virtualLoadbalancerPoolMemberById = (LoadbalancerMember) apiConnector.findById(
+ LoadbalancerMember.class, loadBalancerPoolMemberUUID);
+ if (virtualLoadbalancerPoolMemberById != null) {
+ LOGGER.warn("LoadbalancerPool Member already exists with UUID" + loadBalancerPoolMemberUUID);
+ return HttpURLConnection.HTTP_FORBIDDEN;
+ }
+ LoadbalancerPool virtualLoadbalancerPool = (LoadbalancerPool) apiConnector.findById(LoadbalancerPool.class,
+ loadBalancerPoolID);
+ if (virtualLoadbalancerPool == null) {
+ LOGGER.warn("LoadbalancerPool does not exist" + loadBalancerPoolID);
+ return HttpURLConnection.HTTP_FORBIDDEN;
+ }
+ if (!(loadBalancerPoolMember.getPoolMemberTenantID().equals(virtualLoadbalancerPool.getParentUuid()))) {
+ LOGGER.warn("Member with UUID: " + loadBalancerPoolID + "and Pool with UUID: " + loadBalancerPoolID
+ + " does not belong to same tenant");
+ return HttpURLConnection.HTTP_FORBIDDEN;
+ }
+ return HttpURLConnection.HTTP_OK;
+ } catch (IOException ie) {
+ LOGGER.error("IOException : " + ie);
+ return HttpURLConnection.HTTP_INTERNAL_ERROR;
+ } catch (Exception e) {
+ LOGGER.error("Exception : " + e);
+ return HttpURLConnection.HTTP_INTERNAL_ERROR;
+ }
+
+ }
+
+ /**
+ * Invoked to take action after a member has been created.
+ *
+ * @param loadBalancerPoolMember
+ * An instance of new NeutronLoadBalancerPoolMember object.
+ */
+ @Override
+ public void neutronLoadBalancerPoolMemberCreated(NeutronLoadBalancerPoolMember loadBalancerPoolMember) {
+ try {
+ createLoadBalancerMember(loadBalancerPoolMember);
+ } catch (IOException ex) {
+ LOGGER.warn("Exception : " + ex);
+ }
+ LoadbalancerMember loadbalancerMember = null;
+ try {
+ String loadBalancerPoolMemberUUID = loadBalancerPoolMember.getPoolMemberID();
+ if (!(loadBalancerPoolMemberUUID.contains("-"))) {
+ loadBalancerPoolMemberUUID = Utils.uuidFormater(loadBalancerPoolMemberUUID);
+ }
+ loadBalancerPoolMemberUUID = UUID.fromString(loadBalancerPoolMemberUUID).toString();
+ loadbalancerMember = (LoadbalancerMember) apiConnector.findById(LoadbalancerMember.class,
+ loadBalancerPoolMemberUUID);
+ if (loadbalancerMember != null) {
+ LOGGER.info("LoadbalancerPool Member creation verified for Member with UUID--"
+ + loadBalancerPoolMemberUUID);
+ }
+ } catch (Exception e) {
+ LOGGER.error("Exception : " + e);
+ }
+
+ }
+
+ /**
+ * Invoked to create the specified Neutron Member.
+ *
+ * @param loadBalancerPoolMember
+ * An instance of new NeutronLoadBalancerPoolMember object.
+ */
+ private void createLoadBalancerMember(NeutronLoadBalancerPoolMember loadBalancerPoolMember) throws IOException {
+ LoadbalancerMember virtualLoadBalancerMember = new LoadbalancerMember();
+ virtualLoadBalancerMember = mapLoadBalancerMemberProperties(loadBalancerPoolMember, virtualLoadBalancerMember);
+ boolean loadBalancerMemberCreated;
+ try {
+ loadBalancerMemberCreated = apiConnector.create(virtualLoadBalancerMember);
+ LOGGER.debug("loadBalancerPool member: " + loadBalancerMemberCreated);
+ if (!loadBalancerMemberCreated) {
+ LOGGER.info("loadBalancerPool member creation failed..");
+ }
+ } catch (Exception Ex) {
+ LOGGER.error("Exception : " + Ex);
+ }
+ LOGGER.info("Member having UUID " + loadBalancerPoolMember.getPoolMemberID() + " sucessfully created");
+ }
+
+ @Override
+ public int canUpdateNeutronLoadBalancerPoolMember(NeutronLoadBalancerPoolMember delta,
+ NeutronLoadBalancerPoolMember original) {
+ // TODO Auto-generated method stub
+ return 0;
+ }
+
+ @Override
+ public void neutronLoadBalancerPoolMemberUpdated(NeutronLoadBalancerPoolMember loadBalancerPoolMember) {
+ // TODO Auto-generated method stub
+
+ }
+
+ /**
+ * Invoked when a member deletion is requested to indicate if the specified
+ * member can be deleted.
+ *
+ * @param loadBalancerPoolMember
+ * An instance of the NeutronLoadBalancerPoolMember object to be deleted.
+ * @return A HTTP status code to the deletion request.
+ */
+ @Override
+ public int canDeleteNeutronLoadBalancerPoolMember(NeutronLoadBalancerPoolMember loadBalancerPoolMember) {
+ apiConnector = Activator.apiConnector;
+ LoadbalancerMember virtualLoadBalancerMember = null;
+ String loadBalancerMemberUUID = loadBalancerPoolMember.getPoolMemberID();
+ try {
+ if (!(loadBalancerMemberUUID.contains("-"))) {
+ loadBalancerMemberUUID = Utils.uuidFormater(loadBalancerMemberUUID);
+ }
+ loadBalancerMemberUUID = UUID.fromString(loadBalancerMemberUUID).toString();
+ } catch (Exception ex) {
+ LOGGER.error("UUID input incorrect", ex);
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ try {
+ virtualLoadBalancerMember = (LoadbalancerMember) apiConnector.findById(LoadbalancerMember.class,
+ loadBalancerMemberUUID);
+ if (virtualLoadBalancerMember == null) {
+ LOGGER.info("No LoadbalancerPoolMember exists with ID : " + loadBalancerMemberUUID);
+ return HttpURLConnection.HTTP_BAD_REQUEST;
+ }
+ return HttpURLConnection.HTTP_OK;
+ } catch (Exception e) {
+ LOGGER.error("Exception : " + e);
+ return HttpURLConnection.HTTP_INTERNAL_ERROR;
+ }
+ }
+
+ /**
+ * Invoked to take action after a member has been deleted.
+ *
+ * @param loadBalancerPoolMember
+ * An instance of deleted NeutronLoadBalancerPoolMember object.
+ */
+ @Override
+ public void neutronLoadBalancerPoolMemberDeleted(NeutronLoadBalancerPoolMember loadBalancerPoolMember) {
+ LoadbalancerMember virtualLoadBalancerMember = null;
+ try {
+ String loadBalancerMemberUUID = loadBalancerPoolMember.getPoolMemberID();
+ if (!(loadBalancerMemberUUID.contains("-"))) {
+ loadBalancerMemberUUID = Utils.uuidFormater(loadBalancerMemberUUID);
+ }
+ loadBalancerMemberUUID = UUID.fromString(loadBalancerMemberUUID).toString();
+ virtualLoadBalancerMember = (LoadbalancerMember) apiConnector.findById(LoadbalancerMember.class,
+ loadBalancerMemberUUID);
+ apiConnector.delete(virtualLoadBalancerMember);
+ if (virtualLoadBalancerMember == null) {
+ LOGGER.info("LoadbalancerPoolMember deletion verified....");
+ } else {
+ LOGGER.info("LoadbalancerPoolMember with ID : " + loadBalancerMemberUUID + "deletion failed");
+ }
+ } catch (Exception ex) {
+ LOGGER.error("Exception : " + ex);
+ }
+ }
+
+ /**
+ * Invoked to map the NeutronLoadBalancerPoolMember object properties to the loadBalancerPoolMember
+ * object.
+ *
+ * @param loadBalancerPoolMember
+ * An instance of new NeutronLoadBalancerPoolMember object.
+ * @param virtualLoadBalancerMember
+ * An instance of new LoadbalancerMember object.
+ * @return {@link LoadbalancerMember}
+ */
+ private LoadbalancerMember mapLoadBalancerMemberProperties(NeutronLoadBalancerPoolMember loadBalancerPoolMember,
+ LoadbalancerMember virtualLoadBalancerMember) {
+ String loadBalancerMemberUUID = loadBalancerPoolMember.getPoolMemberID();
+ try {
+ if (!(loadBalancerMemberUUID.contains("-"))) {
+ loadBalancerMemberUUID = Utils.uuidFormater(loadBalancerMemberUUID);
+ }
+ loadBalancerMemberUUID = UUID.fromString(loadBalancerMemberUUID).toString();
+ LoadbalancerPool lbp = (LoadbalancerPool) apiConnector.findById(LoadbalancerPool.class,
+ loadBalancerPoolMember.getPoolID());
+ virtualLoadBalancerMember.setParent(lbp);
+ } catch (Exception ex) {
+ LOGGER.error("UUID input incorrect", ex);
+ }
+ LoadbalancerMemberType lbmType = new LoadbalancerMemberType();
+ lbmType.setAddress(loadBalancerPoolMember.getPoolMemberAddress());
+ lbmType.setProtocolPort(loadBalancerPoolMember.getPoolMemberProtoPort());
+ if (loadBalancerPoolMember.getPoolMemberStatus() != null) {
+ lbmType.setStatus(loadBalancerPoolMember.getPoolMemberStatus());
+ }
+ if (loadBalancerPoolMember.getPoolMemberWeight() != null) {
+ lbmType.setWeight(loadBalancerPoolMember.getPoolMemberWeight());
+ }
+ if (loadBalancerPoolMember.getPoolMemberAdminStateIsUp() != null) {
+ lbmType.setAdminState(loadBalancerPoolMember.getPoolMemberAdminStateIsUp());
+ } else {
+ lbmType.setAdminState(true);
+ }
+ virtualLoadBalancerMember.setProperties(lbmType);
+ virtualLoadBalancerMember.setUuid(loadBalancerMemberUUID);
+ virtualLoadBalancerMember.setName(loadBalancerMemberUUID);
+ virtualLoadBalancerMember.setDisplayName(loadBalancerMemberUUID);
+ return virtualLoadBalancerMember;
+ }
+
+}
--- /dev/null
+package org.opendaylight.plugin2oc.neutron;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+
+import net.juniper.contrail.api.ApiConnector;
+import net.juniper.contrail.api.types.Project;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.controller.networkconfig.neutron.NeutronLoadBalancer;
+
+/**
+ * Test Class for LoadBalancerHandler.
+ */
+public class LoadBalancerHandlerTest {
+
+ LoadBalancerHandler loadBalancerHandler;
+ LoadBalancerHandler mockLoadBalancerHandler = mock(LoadBalancerHandler.class);
+ ApiConnector mockApiConnector = mock(ApiConnector.class);
+ Project mockProject = mock(Project.class);
+ NeutronLoadBalancer mockNeutronLoadBalancer = mock(NeutronLoadBalancer.class);
+
+ @Before
+ public void beforeTest() {
+ loadBalancerHandler = new LoadBalancerHandler();
+ assertNotNull(mockLoadBalancerHandler);
+ assertNotNull(mockApiConnector);
+ assertNotNull(mockProject);
+ assertNotNull(mockNeutronLoadBalancer);
+ }
+
+ @After
+ public void AfterTest() {
+ loadBalancerHandler = null;
+ Activator.apiConnector = null;
+ }
+
+ /* Dummy parameters for Neutron LoadBalancer object */
+ public NeutronLoadBalancer defaultNeutronLoadBalancerObject() {
+ NeutronLoadBalancer neutronObject = new NeutronLoadBalancer();
+ neutronObject.setLoadBalancerDescription("loadBalancerDescription");
+ neutronObject.setLoadBalancerID("6b9570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setLoadBalancerName("loadBalancerName");
+ neutronObject.setLoadBalancerStatus(null);
+ neutronObject.setLoadBalancerTenantID("779570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setLoadBalancerVipAddress("10.10.10.10");
+ neutronObject.setLoadBalancerVipSubnetID("889570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ return neutronObject;
+ }
+
+ /* Dummy parameters for Neutron LoadBalancer update */
+ public NeutronLoadBalancer defaultUpdateNeutronLoadBalancerObject() {
+ NeutronLoadBalancer neutronUpdateObject = new NeutronLoadBalancer();
+ neutronUpdateObject.setLoadBalancerDescription("loadBalancerDescription");
+ neutronUpdateObject.setLoadBalancerID("6b9570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronUpdateObject.setLoadBalancerName("loadBalancerName");
+ neutronUpdateObject.setLoadBalancerStatus(null);
+ neutronUpdateObject.setLoadBalancerTenantID("779570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronUpdateObject.setLoadBalancerVipAddress("10.10.10.10");
+ neutronUpdateObject.setLoadBalancerVipSubnetID("889570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ return neutronUpdateObject;
+ }
+ /* Test method to check if neutron LoadBalancer is null */
+ @Test
+ public void testCanCreateNeutronLoadBalancerNull() {
+ Activator.apiConnector = mockApiConnector;
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST, loadBalancerHandler.canCreateNeutronLoadBalancer(null));
+ }
+
+ /* Test method to check if neutron LoadBalancer tenant ID is null */
+ @Test
+ public void testCanCreateNeutronLoadBalancerTenantIDNull() {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancer neutronObject = new NeutronLoadBalancer();
+ neutronObject.setLoadBalancerTenantID(null);
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerHandler.canCreateNeutronLoadBalancer(neutronObject));
+ }
+
+ /* Test method to check if neutron LoadBalancer project exist */
+ @Test
+ public void testCanCreateNeutronLoadBalancerPoolProjectNull() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancer neutronLoadBalancer = defaultNeutronLoadBalancerObject();
+ when(mockApiConnector.findById(Project.class, neutronLoadBalancer.getLoadBalancerTenantID()))
+ .thenReturn(null);
+ assertEquals(HttpURLConnection.HTTP_NOT_FOUND,
+ loadBalancerHandler.canCreateNeutronLoadBalancer(neutronLoadBalancer));
+ }
+
+}
--- /dev/null
+package org.opendaylight.plugin2oc.neutron;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+
+import net.juniper.contrail.api.ApiConnector;
+import net.juniper.contrail.api.types.LoadbalancerHealthmonitor;
+import net.juniper.contrail.api.types.Project;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.controller.networkconfig.neutron.NeutronLoadBalancerHealthMonitor;
+
+/**
+ * Test Class for LoadBalancerHealthMonitorHandler.
+ */
+public class LoadBalancerHealthMonitorHandlerTest {
+
+ LoadBalancerHealthMonitorHandler loadBalancerHealthMonitorHandler;
+ LoadBalancerHealthMonitorHandler mockLoadBalancerHealthMonitorHandler = mock(LoadBalancerHealthMonitorHandler.class);
+ NeutronLoadBalancerHealthMonitor mockNeutronLoadBalancerHealthMonitor = mock(NeutronLoadBalancerHealthMonitor.class);
+ LoadbalancerHealthmonitor mockLoadbalancerHealthmonitor = mock(LoadbalancerHealthmonitor.class);
+ ApiConnector mockApiConnector = mock(ApiConnector.class);
+ Project mockProject = mock(Project.class);
+
+ @Before
+ public void beforeTest() {
+ loadBalancerHealthMonitorHandler = new LoadBalancerHealthMonitorHandler();
+ assertNotNull(mockLoadBalancerHealthMonitorHandler);
+ assertNotNull(mockNeutronLoadBalancerHealthMonitor);
+ assertNotNull(mockApiConnector);
+ assertNotNull(mockProject);
+ assertNotNull(mockLoadbalancerHealthmonitor);
+ }
+
+ @After
+ public void AfterTest() {
+ loadBalancerHealthMonitorHandler = null;
+ Activator.apiConnector = null;
+ }
+
+ /* Dummy parameters for Neutron LoadBalancer HealthMonitor object */
+ public NeutronLoadBalancerHealthMonitor defaultNeutronLoadBalancerHealthMonitorObject() {
+ NeutronLoadBalancerHealthMonitor neutronObject = new NeutronLoadBalancerHealthMonitor();
+ neutronObject.setLoadBalancerHealthMonitorAdminStateIsUp(null);
+ neutronObject.setLoadBalancerHealthMonitorDelay(30);
+ neutronObject.setLoadBalancerHealthMonitorExpectedCodes("loadBalancerHealthMonitorExpectedCodes");
+ neutronObject.setLoadBalancerHealthMonitorHttpMethod("HTTP");
+ neutronObject.setLoadBalancerHealthMonitorID("6b9570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setLoadBalancerHealthMonitorMaxRetries(10);
+ neutronObject.setLoadBalancerHealthMonitorStatus("loadBalancerHealthMonitorStatus");
+ neutronObject.setLoadBalancerHealthMonitorTenantID("779570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setLoadBalancerHealthMonitorTimeout(5);
+ neutronObject.setLoadBalancerHealthMonitorType("loadBalancerHealthMonitorType");
+ neutronObject.setLoadBalancerHealthMonitorUrlPath("/check");
+ return neutronObject;
+ }
+
+ /* Dummy parameters for Neutron LoadBalancer update */
+ public NeutronLoadBalancerHealthMonitor defaultUpdateNeutronLoadBalancerHealthMonitorObject() {
+ NeutronLoadBalancerHealthMonitor neutronUpdateObject = new NeutronLoadBalancerHealthMonitor();
+ neutronUpdateObject.setLoadBalancerHealthMonitorAdminStateIsUp(null);
+ neutronUpdateObject.setLoadBalancerHealthMonitorDelay(30);
+ neutronUpdateObject.setLoadBalancerHealthMonitorExpectedCodes("loadBalancerHealthMonitorExpectedCodes");
+ neutronUpdateObject.setLoadBalancerHealthMonitorHttpMethod("HTTP");
+ neutronUpdateObject.setLoadBalancerHealthMonitorID("6b9570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronUpdateObject.setLoadBalancerHealthMonitorMaxRetries(10);
+ neutronUpdateObject.setLoadBalancerHealthMonitorStatus("loadBalancerHealthMonitorStatus");
+ neutronUpdateObject.setLoadBalancerHealthMonitorTenantID("779570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronUpdateObject.setLoadBalancerHealthMonitorTimeout(5);
+ neutronUpdateObject.setLoadBalancerHealthMonitorType("loadBalancerHealthMonitorType");
+ neutronUpdateObject.setLoadBalancerHealthMonitorUrlPath("/check");
+ return neutronUpdateObject;
+ }
+
+ /* Test method to check if neutron LoadBalancerHealthMonitor is null */
+ @Test
+ public void testCanCreateNeutronLoadBalancerNull() {
+ Activator.apiConnector = mockApiConnector;
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerHealthMonitorHandler.canCreateNeutronLoadBalancerHealthMonitor(null));
+ }
+
+ /*
+ * Test method to check if neutron LoadBalancer health monitor tenant ID is
+ * null
+ */
+ @Test
+ public void testCanCreateNeutronLoadBalancerHMTenantIDNull() {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerHealthMonitor neutronObject = new NeutronLoadBalancerHealthMonitor();
+ neutronObject.setLoadBalancerHealthMonitorTenantID(null);
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerHealthMonitorHandler.canCreateNeutronLoadBalancerHealthMonitor(neutronObject));
+ }
+
+ /* Test method to check if neutron LoadBalancer health monitor project exist */
+ @Test
+ public void testCanCreateNeutronLoadBalancerProjectNull() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerHealthMonitor neutronObject = defaultNeutronLoadBalancerHealthMonitorObject();
+ when(mockApiConnector.findById(Project.class, neutronObject.getLoadBalancerHealthMonitorTenantID()))
+ .thenReturn(null);
+ assertEquals(HttpURLConnection.HTTP_NOT_FOUND,
+ loadBalancerHealthMonitorHandler.canCreateNeutronLoadBalancerHealthMonitor(neutronObject));
+ }
+
+ /* Test method to check if neutron LoadBalancer health monitor exist */
+ @Test
+ public void testCanCreateNeutronLoadBalancerHMExist() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerHealthMonitor neutronObject = defaultNeutronLoadBalancerHealthMonitorObject();
+ when(mockApiConnector.findById(Project.class, neutronObject.getLoadBalancerHealthMonitorTenantID()))
+ .thenReturn(mockProject);
+ when(mockApiConnector.findById(LoadbalancerHealthmonitor.class, neutronObject.getLoadBalancerHealthMonitorID()))
+ .thenReturn(mockLoadbalancerHealthmonitor);
+ assertEquals(HttpURLConnection.HTTP_FORBIDDEN,
+ loadBalancerHealthMonitorHandler.canCreateNeutronLoadBalancerHealthMonitor(neutronObject));
+ }
+
+ /* Test method to check if neutron LoadBalancer health monitor returns Ok */
+ @Test
+ public void testCanCreateNeutronLoadBalancerHMOk() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerHealthMonitor neutronObject = defaultNeutronLoadBalancerHealthMonitorObject();
+ when(mockApiConnector.findById(Project.class, neutronObject.getLoadBalancerHealthMonitorTenantID()))
+ .thenReturn(mockProject);
+ when(mockApiConnector.findById(LoadbalancerHealthmonitor.class, neutronObject.getLoadBalancerHealthMonitorID()))
+ .thenReturn(null);
+ assertEquals(HttpURLConnection.HTTP_OK,
+ loadBalancerHealthMonitorHandler.canCreateNeutronLoadBalancerHealthMonitor(neutronObject));
+ }
+}
--- /dev/null
+package org.opendaylight.plugin2oc.neutron;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+
+import net.juniper.contrail.api.ApiConnector;
+import net.juniper.contrail.api.types.LoadbalancerPool;
+import net.juniper.contrail.api.types.Project;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.controller.networkconfig.neutron.NeutronLoadBalancerListener;
+
+/**
+ * Test Class for LoadBalancerListenerHandler.
+ */
+
+public class LoadBalancerListenerHandlerTest {
+
+ LoadBalancerListenerHandler loadBalancerListenerHandler;
+ LoadBalancerListenerHandler mockLoadBalancerListenerHandler = mock(LoadBalancerListenerHandler.class);
+ ApiConnector mockApiConnector = mock(ApiConnector.class);
+ Project mockProject = mock(Project.class);
+ NeutronLoadBalancerListener mockNeutronLoadBalancerListener = mock(NeutronLoadBalancerListener.class);
+ LoadbalancerPool mockLoadbalancerPool = mock(LoadbalancerPool.class);
+ // LoadbalancerListener mockLoadbalancerListener = mock(LoadbalancerPool.class);
+
+ @Before
+ public void beforeTest() {
+ loadBalancerListenerHandler = new LoadBalancerListenerHandler();
+ assertNotNull(mockLoadBalancerListenerHandler);
+ assertNotNull(mockApiConnector);
+ assertNotNull(mockProject);
+ assertNotNull(mockNeutronLoadBalancerListener);
+ // assertNotNull(mockLoadbalancerListener);
+ }
+
+ @After
+ public void AfterTest() {
+ loadBalancerListenerHandler = null;
+ Activator.apiConnector = null;
+ }
+
+ /* Dummy parameters for Neutron LoadBalancerListener */
+ public NeutronLoadBalancerListener defaultNeutronLoadBalancerListenerObject() {
+ NeutronLoadBalancerListener neutronObject = new NeutronLoadBalancerListener();
+ neutronObject.setLoadBalancerListenerAdminStateIsUp(true);
+ neutronObject.setLoadBalancerListenerDescription("loadBalancerListenerDescription");
+ neutronObject.setLoadBalancerListenerID("6b9570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setLoadBalancerListenerIsShared(true);
+ neutronObject.setLoadBalancerListenerName("loadBalancerListenerName");
+ neutronObject.setLoadBalancerListenerStatus("status");
+ neutronObject.setLoadBalancerListenerTenantID("000570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setNeutronLoadBalancerListenerDefaultPoolID("001570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setNeutronLoadBalancerListenerLoadBalancerID("002570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setNeutronLoadBalancerListenerProtocol("HTTP");
+ neutronObject.setNeutronLoadBalancerListenerProtocolPort("8282");
+ return neutronObject;
+ }
+
+ /* Dummy parameters for Neutron LoadBalancerListener update */
+ public NeutronLoadBalancerListener defaultNeutronLoadBalancerListenerUpdateObject() {
+ NeutronLoadBalancerListener neutronObject = new NeutronLoadBalancerListener();
+ neutronObject.setLoadBalancerListenerAdminStateIsUp(true);
+ neutronObject.setLoadBalancerListenerDescription("loadBalancerListenerDescription");
+ neutronObject.setLoadBalancerListenerID("6b9570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setLoadBalancerListenerIsShared(true);
+ neutronObject.setLoadBalancerListenerName("loadBalancerListenerName");
+ neutronObject.setLoadBalancerListenerStatus("status");
+ neutronObject.setLoadBalancerListenerTenantID("000570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setNeutronLoadBalancerListenerDefaultPoolID("001570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setNeutronLoadBalancerListenerLoadBalancerID("002570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setNeutronLoadBalancerListenerProtocol("HTTP");
+ neutronObject.setNeutronLoadBalancerListenerProtocolPort("8282");
+ return neutronObject;
+ }
+
+ /* Test method to check if neutron LoadBalancerListener is null */
+ @Test
+ public void testCanCreateNeutronLoadBalancerPoolNull() {
+ Activator.apiConnector = mockApiConnector;
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerListenerHandler.canCreateNeutronLoadBalancerListener(null));
+ }
+
+ /* Test method to check if neutron LoadBalancerListener tenant ID is null */
+ @Test
+ public void testCanCreateNeutronLoadBalancerPoolTenantIDNull() {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerListener neutronObject = defaultNeutronLoadBalancerListenerObject();
+ neutronObject.setLoadBalancerListenerTenantID(null);
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerListenerHandler.canCreateNeutronLoadBalancerListener(neutronObject));
+ }
+
+ /* Test method to check if neutron LoadBalancerListener pool ID is null */
+ @Test
+ public void testCanCreateNeutronLoadBalancerPoolIDNull() {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerListener neutronObject = defaultNeutronLoadBalancerListenerObject();
+ neutronObject.setNeutronLoadBalancerListenerDefaultPoolID(null);
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerListenerHandler.canCreateNeutronLoadBalancerListener(neutronObject));
+ }
+
+ /* Test method to check if neutron LoadBalance ID is null */
+ @Test
+ public void testCanCreateNeutronLoadBalancerListenerLBIDNull() {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerListener neutronObject = defaultNeutronLoadBalancerListenerObject();
+ neutronObject.setNeutronLoadBalancerListenerLoadBalancerID(null);
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerListenerHandler.canCreateNeutronLoadBalancerListener(neutronObject));
+ }
+
+ /* Test method to check if neutron LoadBalanceListener protocol is null */
+ @Test
+ public void testCanCreateNeutronLoadBalancerListenerProtocolNull() {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerListener neutronObject = defaultNeutronLoadBalancerListenerObject();
+ neutronObject.setNeutronLoadBalancerListenerProtocol(null);
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerListenerHandler.canCreateNeutronLoadBalancerListener(neutronObject));
+ }
+
+ /* Test method to check if neutron LoadBalancerPool protocol is invalid */
+ @Test
+ public void testCanCreateNeutronLoadBalancerListenerProtocolInvalid() {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerListener neutronObject = defaultNeutronLoadBalancerListenerObject();
+ neutronObject.setNeutronLoadBalancerListenerProtocol("xyz");
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerListenerHandler.canCreateNeutronLoadBalancerListener(neutronObject));
+ }
+
+ /* Test method to check if neutron LoadBalancerPool project exist */
+ @Test
+ public void testCanCreateNeutronLoadBalancerListenerProjectNull() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerListener neutronLoadBalancerListener = defaultNeutronLoadBalancerListenerObject();
+ when(mockApiConnector.findById(Project.class, neutronLoadBalancerListener.getLoadBalancerListenerTenantID()))
+ .thenReturn(null);
+ assertEquals(HttpURLConnection.HTTP_NOT_FOUND,
+ loadBalancerListenerHandler.canCreateNeutronLoadBalancerListener(neutronLoadBalancerListener));
+ }
+
+ /* Test method to check if neutron default Pool already exist */
+ @Test
+ public void testCanCreateNeutronLoadBalancerListenerDefaultPoolExists() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerListener neutronLoadBalancerListener = defaultNeutronLoadBalancerListenerObject();
+ when(mockApiConnector.findById(Project.class, neutronLoadBalancerListener.getLoadBalancerListenerTenantID()))
+ .thenReturn(mockProject);
+ when(
+ mockApiConnector.findById(LoadbalancerPool.class,
+ neutronLoadBalancerListener.getNeutronLoadBalancerListenerDefaultPoolID())).thenReturn(null);
+ assertEquals(HttpURLConnection.HTTP_FORBIDDEN,
+ loadBalancerListenerHandler.canCreateNeutronLoadBalancerListener(neutronLoadBalancerListener));
+ }
+
+}
--- /dev/null
+package org.opendaylight.plugin2oc.neutron;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.util.ArrayList;
+import java.util.List;
+
+import net.juniper.contrail.api.ApiConnector;
+import net.juniper.contrail.api.types.LoadbalancerMember;
+import net.juniper.contrail.api.types.LoadbalancerPool;
+import net.juniper.contrail.api.types.Project;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.controller.networkconfig.neutron.NeutronLoadBalancerPool;
+import org.opendaylight.controller.networkconfig.neutron.NeutronLoadBalancerPoolMember;
+
+/**
+ * Test Class for LoadBalancerPoolHandler.
+ */
+public class LoadBalancerPoolHandlerTest {
+
+ LoadBalancerPoolHandler loadBalancerPoolHandler;
+ LoadBalancerPoolHandler mockLoadBalancerPoolHandler = mock(LoadBalancerPoolHandler.class);
+ ApiConnector mockApiConnector = mock(ApiConnector.class);
+ Project mockProject = mock(Project.class);
+ NeutronLoadBalancerPool mockNeutronLoadBalancerPool = mock(NeutronLoadBalancerPool.class);
+ LoadbalancerPool mockLoadbalancerPool = mock(LoadbalancerPool.class);
+ LoadbalancerMember mockLoadbalancerMember = mock(LoadbalancerMember.class);
+
+ @Before
+ public void beforeTest() {
+ loadBalancerPoolHandler = new LoadBalancerPoolHandler();
+ assertNotNull(mockLoadBalancerPoolHandler);
+ assertNotNull(mockApiConnector);
+ assertNotNull(mockProject);
+ assertNotNull(mockNeutronLoadBalancerPool);
+ assertNotNull(mockLoadbalancerPool);
+ }
+
+ @After
+ public void AfterTest() {
+ loadBalancerPoolHandler = null;
+ Activator.apiConnector = null;
+ }
+
+ /* Dummy parameters for Neutron LoadBalancerPool */
+ public NeutronLoadBalancerPool defaultNeutronLoadBalancerPoolObject() {
+ NeutronLoadBalancerPool neutronObject = new NeutronLoadBalancerPool();
+ neutronObject.setLoadBalancerPoolAdminStateIsUp(false);
+ neutronObject.setLoadBalancerPoolDescription("loadBalancerPoolDescription");
+ neutronObject.setLoadBalancerPoolID("6b9570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setLoadBalancerPoolLbAlgorithm("ROUND_ROBIN");
+ neutronObject.setLoadBalancerPoolName("loadBalancerPoolName");
+ neutronObject.setLoadBalancerPoolProtocol("HTTP");
+ neutronObject.setLoadBalancerPoolStatus("PENDING_CREATE");
+ neutronObject.setLoadBalancerPoolTenantID("779570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ List<NeutronLoadBalancerPoolMember> loadBalancerPoolMembers = new ArrayList<NeutronLoadBalancerPoolMember>();
+ neutronObject.setLoadBalancerPoolMembers(loadBalancerPoolMembers);
+ neutronObject.setNeutronLoadBalancerPoolHealthMonitorID("889570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ return neutronObject;
+ }
+
+ /* Dummy parameters for Neutron LoadBalancerPool update */
+ public NeutronLoadBalancerPool defaultUpdateNeutronLoadBalancerPoolObject() {
+ NeutronLoadBalancerPool neutronUpdateObject = new NeutronLoadBalancerPool();
+ neutronUpdateObject.setLoadBalancerPoolAdminStateIsUp(false);
+ neutronUpdateObject.setLoadBalancerPoolDescription("loadBalancerPoolDescription");
+ neutronUpdateObject.setLoadBalancerPoolID("6b9570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronUpdateObject.setLoadBalancerPoolLbAlgorithm("ROUND_ROBIN");
+ neutronUpdateObject.setLoadBalancerPoolName("loadBalancerPoolName");
+ neutronUpdateObject.setLoadBalancerPoolProtocol("HTTP");
+ neutronUpdateObject.setLoadBalancerPoolStatus("PENDING_CREATE");
+ neutronUpdateObject.setLoadBalancerPoolTenantID("779570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronUpdateObject.setNeutronLoadBalancerPoolHealthMonitorID("889570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ return neutronUpdateObject;
+ }
+
+ /* Dummy parameters for Neutron LoadBalancerPoolMember */
+ public NeutronLoadBalancerPoolMember defaultNeutronLoadBalancerMemberObject() {
+ NeutronLoadBalancerPoolMember neutronObject = new NeutronLoadBalancerPoolMember();
+ neutronObject.setPoolID("6b9570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setPoolMemberAdminStateIsUp(true);
+ neutronObject.setPoolMemberID("779570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setPoolMemberProtoPort(80);
+ neutronObject.setPoolMemberStatus("poolMemberStatus");
+ neutronObject.setPoolMemberSubnetID("000570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setPoolMemberTenantID("779570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setPoolMemberWeight(20);
+ return neutronObject;
+ }
+
+ /* Test method to check if neutron LoadBalancerPool is null */
+ @Test
+ public void testCanCreateNeutronLoadBalancerPoolNull() {
+ Activator.apiConnector = mockApiConnector;
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST, loadBalancerPoolHandler.canCreateNeutronLoadBalancerPool(null));
+ }
+
+ /* Test method to check if neutron LoadBalancerPool tenant ID is null */
+ @Test
+ public void testCanCreateNeutronLoadBalancerPoolTenantIDNull() {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPool neutronObject = new NeutronLoadBalancerPool();
+ neutronObject.setLoadBalancerPoolTenantID(null);
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerPoolHandler.canCreateNeutronLoadBalancerPool(neutronObject));
+ }
+
+ /* Test method to check if neutron LoadBalancerPool alogorithm is null */
+ @Test
+ public void testCanCreateNeutronLoadBalancerPoolAlgorithmNull() {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPool neutronObject = defaultNeutronLoadBalancerPoolObject();
+ neutronObject.setLoadBalancerPoolLbAlgorithm(null);
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerPoolHandler.canCreateNeutronLoadBalancerPool(neutronObject));
+ }
+
+ /* Test method to check if neutron LoadBalancerPool algorithm is invalid */
+ @Test
+ public void testCanCreateNeutronLoadBalancerPoolAlgorithmInvalid() {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPool neutronObject = defaultNeutronLoadBalancerPoolObject();
+ neutronObject.setLoadBalancerPoolLbAlgorithm("xyz");
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerPoolHandler.canCreateNeutronLoadBalancerPool(neutronObject));
+ }
+
+ /* Test method to check if neutron LoadBalancerPool protocol is null */
+ @Test
+ public void testCanCreateNeutronLoadBalancerPoolProtocolNull() {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPool neutronObject = defaultNeutronLoadBalancerPoolObject();
+ neutronObject.setLoadBalancerPoolProtocol(null);
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerPoolHandler.canCreateNeutronLoadBalancerPool(neutronObject));
+ }
+
+ /* Test method to check if neutron LoadBalancerPool protocol is invalid */
+ @Test
+ public void testCanCreateNeutronLoadBalancerPoolProtocolInvalid() {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPool neutronObject = defaultNeutronLoadBalancerPoolObject();
+ neutronObject.setLoadBalancerPoolProtocol("xyz");
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerPoolHandler.canCreateNeutronLoadBalancerPool(neutronObject));
+ }
+
+ /*
+ * Test method to check if neutron LoadBalancerPool and Member belong to
+ * same tenant
+ */
+ @Test
+ public void testCanCreateNeutronLoadBalancerPoolMemberTenantIdCheck() {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPool neutronPoolObject = defaultNeutronLoadBalancerPoolObject();
+ NeutronLoadBalancerPoolMember neutronMemberObject = defaultNeutronLoadBalancerMemberObject();
+ neutronPoolObject.addLoadBalancerPoolMember(neutronMemberObject);
+ neutronPoolObject.setLoadBalancerPoolTenantID("779570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronMemberObject.setPoolMemberTenantID("009570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerPoolHandler.canCreateNeutronLoadBalancerPool(neutronPoolObject));
+ }
+
+ /*
+ * Test method to check if neutron LoadBalancerPool Member does not already
+ * exist
+ */
+ @Test
+ public void testCanCreateNeutronLoadBalancerPoolMemberExist() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPool neutronPoolObject = defaultNeutronLoadBalancerPoolObject();
+ NeutronLoadBalancerPoolMember neutronMemberObject = defaultNeutronLoadBalancerMemberObject();
+ neutronPoolObject.addLoadBalancerPoolMember(neutronMemberObject);
+ when(mockApiConnector.findById(LoadbalancerMember.class, neutronMemberObject.getPoolMemberID())).thenReturn(
+ mockLoadbalancerMember);
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerPoolHandler.canCreateNeutronLoadBalancerPool(neutronPoolObject));
+ }
+
+ /* Test method to check if neutron LoadBalancerPool project exist */
+ @Test
+ public void testCanCreateNeutronLoadBalancerPoolProjectNull() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPool neutronLoadBalancerPool = defaultNeutronLoadBalancerPoolObject();
+ when(mockApiConnector.findById(Project.class, neutronLoadBalancerPool.getLoadBalancerPoolTenantID()))
+ .thenReturn(null);
+ assertEquals(HttpURLConnection.HTTP_NOT_FOUND,
+ loadBalancerPoolHandler.canCreateNeutronLoadBalancerPool(neutronLoadBalancerPool));
+ }
+
+ /* Test method to check if neutron LoadBalancerPool already exist */
+ @Test
+ public void testCanCreateNeutronLoadBalancerPoolExistsByID() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPool neutronLoadBalancerPool = defaultNeutronLoadBalancerPoolObject();
+ when(mockApiConnector.findById(Project.class, neutronLoadBalancerPool.getLoadBalancerPoolTenantID()))
+ .thenReturn(mockProject);
+ when(mockApiConnector.findById(LoadbalancerPool.class, neutronLoadBalancerPool.getLoadBalancerPoolID()))
+ .thenReturn(mockLoadbalancerPool);
+ assertEquals(HttpURLConnection.HTTP_FORBIDDEN,
+ loadBalancerPoolHandler.canCreateNeutronLoadBalancerPool(neutronLoadBalancerPool));
+ }
+
+ /* Test method to check if neutron LoadBalancerPool already with same name */
+ @Test
+ public void testCanCreateNeutronLoadBalancerPoolExistsByName() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPool neutronLoadBalancerPool = defaultNeutronLoadBalancerPoolObject();
+ when(mockApiConnector.findById(Project.class, neutronLoadBalancerPool.getLoadBalancerPoolTenantID()))
+ .thenReturn(mockProject);
+ when(mockApiConnector.findById(LoadbalancerPool.class, neutronLoadBalancerPool.getLoadBalancerPoolID()))
+ .thenReturn(null);
+ when(
+ mockApiConnector.findByName(LoadbalancerPool.class, mockProject,
+ neutronLoadBalancerPool.getLoadBalancerPoolName())).thenReturn("name");
+ assertEquals(HttpURLConnection.HTTP_FORBIDDEN,
+ loadBalancerPoolHandler.canCreateNeutronLoadBalancerPool(neutronLoadBalancerPool));
+ }
+
+ /* Test method to check if neutron LoadBalancerPool returns status OK */
+ @Test
+ public void testCanCreateNeutronLoadBalancerPoolOK() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPool neutronLoadBalancerPool = defaultNeutronLoadBalancerPoolObject();
+ when(mockApiConnector.findById(Project.class, neutronLoadBalancerPool.getLoadBalancerPoolTenantID()))
+ .thenReturn(mockProject);
+ when(mockApiConnector.findById(LoadbalancerPool.class, neutronLoadBalancerPool.getLoadBalancerPoolID()))
+ .thenReturn(null);
+ assertEquals(HttpURLConnection.HTTP_OK,
+ loadBalancerPoolHandler.canCreateNeutronLoadBalancerPool(neutronLoadBalancerPool));
+ }
+
+ /* Test method to check if neutron LoadBalancerPool is null */
+ @Test
+ public void testCanUpdateNeutronLoadBalancerPoolNull() {
+ Activator.apiConnector = mockApiConnector;
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerPoolHandler.canUpdateNeutronLoadBalancerPool(null, null));
+ }
+
+ /* Test method to check if neutron LoadBalancerPool does not exist */
+ @Test
+ public void testCanUpdateNeutronLoadBalancerPoolNotFound() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPool neutronLoadBalancerPool = defaultNeutronLoadBalancerPoolObject();
+ NeutronLoadBalancerPool neutronUpdateLoadBalancerPool = defaultUpdateNeutronLoadBalancerPoolObject();
+ when(mockApiConnector.findById(LoadbalancerPool.class, neutronLoadBalancerPool.getLoadBalancerPoolID()))
+ .thenReturn(null);
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST, loadBalancerPoolHandler.canUpdateNeutronLoadBalancerPool(
+ neutronUpdateLoadBalancerPool, neutronLoadBalancerPool));
+ }
+
+ /* Test method to check if neutron LoadBalancerPool returns status ok */
+ @Test
+ public void testCanUpdateNeutronLoadBalancerPoolOK() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPool neutronLoadBalancerPool = defaultNeutronLoadBalancerPoolObject();
+ NeutronLoadBalancerPool neutronUpdateLoadBalancerPool = defaultUpdateNeutronLoadBalancerPoolObject();
+ when(mockApiConnector.findById(LoadbalancerPool.class, neutronLoadBalancerPool.getLoadBalancerPoolID()))
+ .thenReturn(mockLoadbalancerPool);
+ assertEquals(HttpURLConnection.HTTP_OK, loadBalancerPoolHandler.canUpdateNeutronLoadBalancerPool(
+ neutronUpdateLoadBalancerPool, neutronLoadBalancerPool));
+ }
+
+ /* Test method to check if neutron LoadBalancerPool does not exists */
+ @Test
+ public void testCanDeleteNeutronLoadBalancerPoolNotFound() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPool neutronLoadBalancerPool = defaultNeutronLoadBalancerPoolObject();
+ when(mockApiConnector.findById(LoadbalancerPool.class, neutronLoadBalancerPool.getLoadBalancerPoolID()))
+ .thenReturn(null);
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerPoolHandler.canDeleteNeutronLoadBalancerPool(neutronLoadBalancerPool));
+ }
+
+ /* Test method to check if neutron LoadBalancerPool returns status OK */
+ @Test
+ public void testCanDeleteNeutronLoadBalancerPoolOK() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPool neutronLoadBalancerPool = defaultNeutronLoadBalancerPoolObject();
+ when(mockApiConnector.findById(LoadbalancerPool.class, neutronLoadBalancerPool.getLoadBalancerPoolID()))
+ .thenReturn(mockLoadbalancerPool);
+ assertEquals(HttpURLConnection.HTTP_OK,
+ loadBalancerPoolHandler.canDeleteNeutronLoadBalancerPool(neutronLoadBalancerPool));
+ }
+}
--- /dev/null
+package org.opendaylight.plugin2oc.neutron;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.util.ArrayList;
+import java.util.List;
+
+import net.juniper.contrail.api.ApiConnector;
+import net.juniper.contrail.api.types.LoadbalancerMember;
+import net.juniper.contrail.api.types.LoadbalancerPool;
+import net.juniper.contrail.api.types.Project;
+import net.juniper.contrail.api.types.VirtualMachineInterface;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.controller.networkconfig.neutron.NeutronLoadBalancerPool;
+import org.opendaylight.controller.networkconfig.neutron.NeutronLoadBalancerPoolMember;
+import org.opendaylight.controller.networkconfig.neutron.NeutronPort;
+import org.opendaylight.controller.networkconfig.neutron.Neutron_IPs;
+
+/**
+ * Test Class for LoadBalancerPoolMember.
+ */
+public class LoadBalancerPoolMemberHandlerTest {
+
+ LoadBalancerPoolMemberHandler loadBalancerPoolMemberHandler;
+ LoadBalancerPoolMemberHandler mockLoadBalancerPoolMemberHandler = mock(LoadBalancerPoolMemberHandler.class);
+ ApiConnector mockApiConnector = mock(ApiConnector.class);
+ Project mockProject = mock(Project.class);
+ NeutronLoadBalancerPool mockNeutronLoadBalancerPool = mock(NeutronLoadBalancerPool.class);
+ NeutronLoadBalancerPoolMember mockNeutronLoadBalancerPoolMember = mock(NeutronLoadBalancerPoolMember.class);
+ LoadbalancerPool mockLoadbalancerPool = mock(LoadbalancerPool.class);
+ LoadbalancerMember mockLoadbalancerMember = mock(LoadbalancerMember.class);
+ VirtualMachineInterface mockedVirtualMachineInterface = mock(VirtualMachineInterface.class);
+ Neutron_IPs mockNeutron_IPs = mock(Neutron_IPs.class);
+
+ @Before
+ public void beforeTest() {
+ loadBalancerPoolMemberHandler = new LoadBalancerPoolMemberHandler();
+ assertNotNull(mockLoadBalancerPoolMemberHandler);
+ assertNotNull(mockNeutronLoadBalancerPool);
+ assertNotNull(mockNeutronLoadBalancerPoolMember);
+ assertNotNull(mockLoadbalancerPool);
+ assertNotNull(mockLoadbalancerMember);
+ assertNotNull(mockApiConnector);
+ assertNotNull(mockProject);
+ }
+
+ @After
+ public void AfterTest() {
+ loadBalancerPoolMemberHandler = null;
+ Activator.apiConnector = null;
+ }
+
+ /* Dummy parameters for Neutron LoadBalancerPoolMember */
+ public NeutronLoadBalancerPoolMember defaultNeutronLoadBalancerMemberObject() {
+ NeutronLoadBalancerPoolMember neutronObject = new NeutronLoadBalancerPoolMember();
+ neutronObject.setPoolID("6b9570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setPoolMemberAdminStateIsUp(true);
+ neutronObject.setPoolMemberID("779570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setPoolMemberProtoPort(80);
+ neutronObject.setPoolMemberStatus("poolMemberStatus");
+ neutronObject.setPoolMemberSubnetID("000570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setPoolMemberTenantID("001570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ neutronObject.setPoolMemberWeight(20);
+ return neutronObject;
+ }
+
+ /* dummy params for Neutron Port */
+ public NeutronPort defaultNeutronPortObject() {
+ NeutronPort neutronPort = new NeutronPort();
+ neutronPort.setPortUUID("64a271fe-0216-46bc-a3e6-1ff582fbd324");
+ neutronPort.setNetworkUUID("54a271fe-0216-46bc-a3e6-1ff582fbd324");
+ neutronPort.setMacAddress("02:70:72:93:4d:d6");
+ neutronPort.setName("port12");
+ neutronPort.setDeviceID("100071fe-0216-46bc-a3e6-1ff582fbd324");
+ neutronPort.setTenantID("001570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ List<Neutron_IPs> ips = new ArrayList<Neutron_IPs>();
+ ips.add(mockNeutron_IPs);
+ neutronPort.setFixedIPs(ips);
+ return neutronPort;
+ }
+
+ /* Test method to check if neutron LoadBalancerPoolMember is null */
+ @Test
+ public void testCanCreateNeutronLoadBalancerMemberNull() {
+ Activator.apiConnector = mockApiConnector;
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerPoolMemberHandler.canCreateNeutronLoadBalancerPoolMember(null));
+ }
+
+ /*
+ * Test method to check if neutron LoadBalancerPoolMember tenant ID/SUbnetID
+ * is null
+ */
+ @Test
+ public void testCanCreateNeutronLoadBalancerMemberTenantIDNull() {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPoolMember neutronObject = new NeutronLoadBalancerPoolMember();
+ neutronObject.setPoolMemberTenantID(null);
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerPoolMemberHandler.canCreateNeutronLoadBalancerPoolMember(neutronObject));
+ }
+
+ /* Test method to check if neutron LoadBalancerPoolMember project exist */
+ @Test
+ public void testCanCreateNeutronLoadBalancerMemberProjectNull() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPoolMember neutronLoadBalancerMember = defaultNeutronLoadBalancerMemberObject();
+ when(mockApiConnector.findById(Project.class, neutronLoadBalancerMember.getPoolMemberTenantID())).thenReturn(
+ null);
+ assertEquals(HttpURLConnection.HTTP_NOT_FOUND,
+ loadBalancerPoolMemberHandler.canCreateNeutronLoadBalancerPoolMember(neutronLoadBalancerMember));
+ }
+
+ /*
+ * Test method to check if neutron LoadBalancerPoolMember has no VM
+ * available
+ */
+ @Test
+ public void testCanCreateNeutronLoadBalancerMemberNoVMAvailable() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPoolMember neutronLoadBalancerMember = defaultNeutronLoadBalancerMemberObject();
+ when(mockApiConnector.findById(Project.class, neutronLoadBalancerMember.getPoolMemberTenantID())).thenReturn(
+ mockProject);
+ when(mockProject.getVirtualMachineInterfaces()).thenReturn(null);
+ assertEquals(HttpURLConnection.HTTP_FORBIDDEN,
+ loadBalancerPoolMemberHandler.canCreateNeutronLoadBalancerPoolMember(neutronLoadBalancerMember));
+ }
+
+ /* Test method to check if neutron LoadBalancerPool already exist */
+ @Test
+ public void testCanCreateNeutronLoadBalancerMemberExists() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPoolMember neutronLoadBalancerMember = defaultNeutronLoadBalancerMemberObject();
+ when(mockApiConnector.findById(Project.class, neutronLoadBalancerMember.getPoolMemberTenantID())).thenReturn(
+ mockProject);
+ when(mockApiConnector.findById(LoadbalancerMember.class, neutronLoadBalancerMember.getPoolMemberID()))
+ .thenReturn(mockLoadbalancerMember);
+ assertEquals(HttpURLConnection.HTTP_FORBIDDEN,
+ loadBalancerPoolMemberHandler.canCreateNeutronLoadBalancerPoolMember(neutronLoadBalancerMember));
+ }
+
+ /* Test method to check if neutron LoadBalancerPool already exist */
+ @Test
+ public void testCanCreateNeutronLoadBalancerPoolExists() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPoolMember neutronLoadBalancerMember = defaultNeutronLoadBalancerMemberObject();
+ when(mockApiConnector.findById(Project.class, neutronLoadBalancerMember.getPoolMemberTenantID())).thenReturn(
+ mockProject);
+ when(mockApiConnector.findById(LoadbalancerMember.class, neutronLoadBalancerMember.getPoolMemberID()))
+ .thenReturn(null);
+ when(mockApiConnector.findById(LoadbalancerPool.class, neutronLoadBalancerMember.getPoolID())).thenReturn(null);
+ assertEquals(HttpURLConnection.HTTP_FORBIDDEN,
+ loadBalancerPoolMemberHandler.canCreateNeutronLoadBalancerPoolMember(neutronLoadBalancerMember));
+ }
+
+ /* Test method to check if neutron Member and Pool have same TenantID */
+ @Test
+ public void testCanCreateNeutronLoadBalancerMemberTenantIDConflict() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPoolMember neutronLoadBalancerMember = defaultNeutronLoadBalancerMemberObject();
+ when(mockApiConnector.findById(Project.class, neutronLoadBalancerMember.getPoolMemberTenantID())).thenReturn(
+ mockProject);
+ when(mockApiConnector.findById(LoadbalancerMember.class, neutronLoadBalancerMember.getPoolMemberID()))
+ .thenReturn(null);
+ when(mockApiConnector.findById(LoadbalancerPool.class, neutronLoadBalancerMember.getPoolID())).thenReturn(
+ mockLoadbalancerPool);
+ when(mockLoadbalancerPool.getParentUuid()).thenReturn("111570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ assertEquals(HttpURLConnection.HTTP_FORBIDDEN,
+ loadBalancerPoolMemberHandler.canCreateNeutronLoadBalancerPoolMember(neutronLoadBalancerMember));
+ }
+
+ /* Test method to check if neutron Member and Pool have same TenantID */
+ @Test
+ public void testCanCreateNeutronLoadBalancerMemberOk() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPoolMember neutronLoadBalancerMember = defaultNeutronLoadBalancerMemberObject();
+ when(mockApiConnector.findById(Project.class, neutronLoadBalancerMember.getPoolMemberTenantID())).thenReturn(
+ mockProject);
+ when(mockApiConnector.findById(LoadbalancerMember.class, neutronLoadBalancerMember.getPoolMemberID()))
+ .thenReturn(null);
+ when(mockApiConnector.findById(LoadbalancerPool.class, neutronLoadBalancerMember.getPoolID())).thenReturn(
+ mockLoadbalancerPool);
+ when(mockLoadbalancerPool.getParentUuid()).thenReturn("001570f2-17b1-4fc3-99ec-1b7f7778a29a");
+ assertEquals(HttpURLConnection.HTTP_OK,
+ loadBalancerPoolMemberHandler.canCreateNeutronLoadBalancerPoolMember(neutronLoadBalancerMember));
+ }
+ /* Test method to check if neutron LoadBalancerPool member not found */
+ @Test
+ public void testCanDeleteNeutronLoadBalancerMemberNotFound() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPoolMember neutronLoadBalancerMember = defaultNeutronLoadBalancerMemberObject();
+ when(mockApiConnector.findById(LoadbalancerPool.class, neutronLoadBalancerMember.getPoolMemberID()))
+ .thenReturn(null);
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerPoolMemberHandler.canDeleteNeutronLoadBalancerPoolMember(neutronLoadBalancerMember));
+ }
+
+ /* Test method to check if neutron LoadBalancerPool returns status OK */
+ @Test
+ public void testCanDeleteNeutronLoadBalancerPoolOK() throws IOException {
+ Activator.apiConnector = mockApiConnector;
+ NeutronLoadBalancerPoolMember neutronLoadBalancerMember = defaultNeutronLoadBalancerMemberObject();
+ when(mockApiConnector.findById(LoadbalancerPool.class, neutronLoadBalancerMember.getPoolMemberID()))
+ .thenReturn(mockLoadbalancerPool);
+ assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,
+ loadBalancerPoolMemberHandler.canDeleteNeutronLoadBalancerPoolMember(neutronLoadBalancerMember));
+ }
+}
<parent>
<groupId>org.opendaylight.plugin2oc</groupId>
<artifactId>commons.plugin2oc</artifactId>
- <version>0.1-SNAPSHOT</version>
+ <version>0.2.0-SNAPSHOT</version>
<relativePath>commons/parent</relativePath>
</parent>
<groupId>org.opendaylight.plugin2oc</groupId>
<artifactId>plugin2oc.project</artifactId>
- <version>0.1-SNAPSHOT</version>
+ <version>0.2.0-SNAPSHOT</version>
<packaging>pom</packaging>
<properties>
<sonar.host.url> http://localhost:9000/ </sonar.host.url>
Code Review / plugin2oc.git / commitdiff