X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fnorthbound%2Fnetworkconfiguration%2Fneutron%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fnetworkconfig%2Fneutron%2Fnorthbound%2FNeutronLoadBalancerPoolMembersNorthbound.java;h=f8f3cd8c5311f685699257c6a665ef44f6ad5d5a;hb=4019c9fd2ad99628dd790acc1ad4c104f48b6428;hp=ff56fa0a9d3786eaf17cc1848d7212c8054dab58;hpb=c911a187bdcd6160c1929e53466cd9de681c2098;p=controller.git diff --git a/opendaylight/northbound/networkconfiguration/neutron/src/main/java/org/opendaylight/controller/networkconfig/neutron/northbound/NeutronLoadBalancerPoolMembersNorthbound.java b/opendaylight/northbound/networkconfiguration/neutron/src/main/java/org/opendaylight/controller/networkconfig/neutron/northbound/NeutronLoadBalancerPoolMembersNorthbound.java index ff56fa0a9d..f8f3cd8c53 100644 --- a/opendaylight/northbound/networkconfiguration/neutron/src/main/java/org/opendaylight/controller/networkconfig/neutron/northbound/NeutronLoadBalancerPoolMembersNorthbound.java +++ b/opendaylight/northbound/networkconfiguration/neutron/src/main/java/org/opendaylight/controller/networkconfig/neutron/northbound/NeutronLoadBalancerPoolMembersNorthbound.java @@ -1,46 +1,51 @@ /* - * Copyright (C) 2014 Red Hat, Inc. + * Copyright (C) 2014 SDN Hub, LLC. * * This program and the accompanying materials are made available under the * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html + * + * Authors : Srini Seetharaman */ package org.opendaylight.controller.networkconfig.neutron.northbound; import org.codehaus.enunciate.jaxrs.ResponseCode; import org.codehaus.enunciate.jaxrs.StatusCodes; +import org.opendaylight.controller.networkconfig.neutron.INeutronLoadBalancerPoolCRUD; import org.opendaylight.controller.networkconfig.neutron.INeutronLoadBalancerPoolMemberAware; -import org.opendaylight.controller.networkconfig.neutron.INeutronLoadBalancerPoolMemberCRUD; import org.opendaylight.controller.networkconfig.neutron.NeutronCRUDInterfaces; +import org.opendaylight.controller.networkconfig.neutron.NeutronLoadBalancerPool; import org.opendaylight.controller.networkconfig.neutron.NeutronLoadBalancerPoolMember; import org.opendaylight.controller.northbound.commons.RestMessages; import org.opendaylight.controller.northbound.commons.exception.BadRequestException; +import org.opendaylight.controller.northbound.commons.exception.ResourceNotFoundException; import org.opendaylight.controller.northbound.commons.exception.ServiceUnavailableException; import org.opendaylight.controller.sal.utils.ServiceHelper; import javax.ws.rs.Consumes; +import javax.ws.rs.DELETE; import javax.ws.rs.GET; import javax.ws.rs.PUT; import javax.ws.rs.Path; +import javax.ws.rs.PathParam; import javax.ws.rs.Produces; import javax.ws.rs.QueryParam; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.Response; + import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.List; - -@Path("/pools/{loadBalancerPoolID}/members") +@Path("/pools/{loadBalancerPoolUUID}/members") public class NeutronLoadBalancerPoolMembersNorthbound { - private NeutronLoadBalancerPoolMember extractFields(NeutronLoadBalancerPoolMember o, List fields) { return o.extractFields(fields); } /** - * Returns a list of all LoadBalancerPool + * Returns a list of all LoadBalancerPoolMembers in specified pool */ @GET @Produces({MediaType.APPLICATION_JSON}) @@ -50,8 +55,12 @@ public class NeutronLoadBalancerPoolMembersNorthbound { @ResponseCode(code = 501, condition = "Not Implemented")}) public Response listMembers( + //Path param + @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID, + // return fields @QueryParam("fields") List fields, + // OpenStack LoadBalancerPool attributes @QueryParam("id") String queryLoadBalancerPoolMemberID, @QueryParam("tenant_id") String queryLoadBalancerPoolMemberTenantID, @@ -68,20 +77,24 @@ public Response listMembers( @QueryParam("page_reverse") String pageReverse // sorting not supported ) { - INeutronLoadBalancerPoolMemberCRUD loadBalancerPoolMemberInterface = NeutronCRUDInterfaces - .getINeutronLoadBalancerPoolMemberCRUD(this); - if (loadBalancerPoolMemberInterface == null) { + INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = NeutronCRUDInterfaces + .getINeutronLoadBalancerPoolCRUD(this); + if (loadBalancerPoolInterface == null) { throw new ServiceUnavailableException("LoadBalancerPool CRUD Interface " + RestMessages.SERVICEUNAVAILABLE.toString()); } - List allLoadBalancerPoolMembers = loadBalancerPoolMemberInterface - .getAllNeutronLoadBalancerPoolMembers(); + if (!loadBalancerPoolInterface.neutronLoadBalancerPoolExists(loadBalancerPoolUUID)) { + throw new ResourceNotFoundException("loadBalancerPool UUID does not exist."); + } + List members = + loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID).getLoadBalancerPoolMembers(); List ans = new ArrayList(); - Iterator i = allLoadBalancerPoolMembers.iterator(); + Iterator i = members.iterator(); while (i.hasNext()) { NeutronLoadBalancerPoolMember nsg = i.next(); if ((queryLoadBalancerPoolMemberID == null || queryLoadBalancerPoolMemberID.equals(nsg.getPoolMemberID())) && + loadBalancerPoolUUID.equals(nsg.getPoolID()) && (queryLoadBalancerPoolMemberTenantID == null || queryLoadBalancerPoolMemberTenantID.equals(nsg.getPoolMemberTenantID())) && (queryLoadBalancerPoolMemberAddress == null || @@ -102,13 +115,57 @@ public Response listMembers( } } return Response.status(200).entity( - new INeutronLoadBalancerPoolMemberRequest(ans)).build(); + new NeutronLoadBalancerPoolMemberRequest(ans)).build(); +} + +/** + * Returns a specific LoadBalancerPoolMember + */ + +@Path("{loadBalancerPoolMemberUUID}") +@GET +@Produces({ MediaType.APPLICATION_JSON }) +//@TypeHint(OpenStackLoadBalancerPoolMembers.class) +@StatusCodes({ + @ResponseCode(code = 200, condition = "Operation successful"), + @ResponseCode(code = 401, condition = "Unauthorized"), + @ResponseCode(code = 404, condition = "Not Found"), + @ResponseCode(code = 501, condition = "Not Implemented") }) +public Response showLoadBalancerPoolMember( + @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID, + @PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID, + // return fields + @QueryParam("fields") List fields ) { + + INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = NeutronCRUDInterfaces + .getINeutronLoadBalancerPoolCRUD(this); + if (loadBalancerPoolInterface == null) { + throw new ServiceUnavailableException("LoadBalancerPool CRUD Interface " + + RestMessages.SERVICEUNAVAILABLE.toString()); + } + if (!loadBalancerPoolInterface.neutronLoadBalancerPoolExists(loadBalancerPoolUUID)) { + throw new ResourceNotFoundException("loadBalancerPool UUID does not exist."); + } + List members = + loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID).getLoadBalancerPoolMembers(); + for (NeutronLoadBalancerPoolMember ans: members) { + if (!ans.getPoolMemberID().equals(loadBalancerPoolMemberUUID)) + continue; + + if (fields.size() > 0) { + return Response.status(200).entity( + new NeutronLoadBalancerPoolMemberRequest(extractFields(ans, fields))).build(); + } else { + return Response.status(200).entity( + new NeutronLoadBalancerPoolMemberRequest(ans)).build(); + } + } + return Response.status(204).build(); } /** * Adds a Member to an LBaaS Pool member */ -@Path("/pools/{loadBalancerPoolID}/members") @PUT @Produces({MediaType.APPLICATION_JSON}) @Consumes({MediaType.APPLICATION_JSON}) @@ -117,25 +174,34 @@ public Response listMembers( @ResponseCode(code = 401, condition = "Unauthorized"), @ResponseCode(code = 404, condition = "Not Found"), @ResponseCode(code = 501, condition = "Not Implemented")}) -public Response createLoadBalancerPoolMember( INeutronLoadBalancerPoolMemberRequest input) { +public Response createLoadBalancerPoolMember( + @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID, + final NeutronLoadBalancerPoolMemberRequest input) { - INeutronLoadBalancerPoolMemberCRUD loadBalancerPoolMemberInterface = NeutronCRUDInterfaces.getINeutronLoadBalancerPoolMemberCRUD( - this); - if (loadBalancerPoolMemberInterface == null) { - throw new ServiceUnavailableException("LoadBalancerPoolMember CRUD Interface " + INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = NeutronCRUDInterfaces.getINeutronLoadBalancerPoolCRUD(this); + if (loadBalancerPoolInterface == null) { + throw new ServiceUnavailableException("LoadBalancerPool CRUD Interface " + RestMessages.SERVICEUNAVAILABLE.toString()); } + // Verify that the loadBalancerPool exists, for the member to be added to its cache + if (!loadBalancerPoolInterface.neutronLoadBalancerPoolExists(loadBalancerPoolUUID)) { + throw new ResourceNotFoundException("loadBalancerPool UUID does not exist."); + } + NeutronLoadBalancerPool singletonPool = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID); + if (input.isSingleton()) { NeutronLoadBalancerPoolMember singleton = input.getSingleton(); + singleton.setPoolID(loadBalancerPoolUUID); + String loadBalancerPoolMemberUUID = singleton.getPoolMemberID(); /* * Verify that the LoadBalancerPoolMember doesn't already exist. */ - if (loadBalancerPoolMemberInterface.neutronLoadBalancerPoolMemberExists( - singleton.getPoolMemberID())) { - throw new BadRequestException("LoadBalancerPoolMember UUID already exists"); + List members = singletonPool.getLoadBalancerPoolMembers(); + for (NeutronLoadBalancerPoolMember member: members) { + if (member.getPoolMemberID().equals(loadBalancerPoolMemberUUID)) + throw new BadRequestException("LoadBalancerPoolMember UUID already exists"); } - loadBalancerPoolMemberInterface.addNeutronLoadBalancerPoolMember(singleton); Object[] instances = ServiceHelper.getGlobalInstances(INeutronLoadBalancerPoolMemberAware.class, this, null); if (instances != null) { @@ -147,13 +213,18 @@ public Response createLoadBalancerPoolMember( INeutronLoadBalancerPoolMemberReq } } } - loadBalancerPoolMemberInterface.addNeutronLoadBalancerPoolMember(singleton); if (instances != null) { for (Object instance : instances) { INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance; service.neutronLoadBalancerPoolMemberCreated(singleton); } } + + /** + * Add the member from the neutron load balancer pool as well + */ + singletonPool.addLoadBalancerPoolMember(singleton); + } else { List bulk = input.getBulk(); Iterator i = bulk.iterator(); @@ -161,15 +232,17 @@ public Response createLoadBalancerPoolMember( INeutronLoadBalancerPoolMemberReq Object[] instances = ServiceHelper.getGlobalInstances(INeutronLoadBalancerPoolMemberAware.class, this, null); while (i.hasNext()) { NeutronLoadBalancerPoolMember test = i.next(); + String loadBalancerPoolMemberUUID = test.getPoolMemberID(); /* - * Verify that the firewall doesn't already exist + * Verify that the LoadBalancerPoolMember doesn't already exist. */ - - if (loadBalancerPoolMemberInterface.neutronLoadBalancerPoolMemberExists( - test.getPoolMemberID())) { - throw new BadRequestException("Load Balancer PoolMember UUID already is already created"); + List members = singletonPool.getLoadBalancerPoolMembers(); + for (NeutronLoadBalancerPoolMember member: members) { + if (member.getPoolMemberID().equals(loadBalancerPoolMemberUUID)) + throw new BadRequestException("LoadBalancerPoolMember UUID already exists"); } + if (testMap.containsKey(test.getPoolMemberID())) { throw new BadRequestException("Load Balancer PoolMember UUID already exists"); } @@ -189,15 +262,105 @@ public Response createLoadBalancerPoolMember( INeutronLoadBalancerPoolMemberReq i = bulk.iterator(); while (i.hasNext()) { NeutronLoadBalancerPoolMember test = i.next(); - loadBalancerPoolMemberInterface.addNeutronLoadBalancerPoolMember(test); if (instances != null) { for (Object instance : instances) { INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance; service.neutronLoadBalancerPoolMemberCreated(test); } } + singletonPool.addLoadBalancerPoolMember(test); } } return Response.status(201).entity(input).build(); } + +/** + * Updates a LB member pool + */ + +@Path("{loadBalancerPoolMemberUUID}") +@PUT +@Produces({ MediaType.APPLICATION_JSON }) +@Consumes({ MediaType.APPLICATION_JSON }) +@StatusCodes({ + @ResponseCode(code = 200, condition = "Operation successful"), + @ResponseCode(code = 400, condition = "Bad Request"), + @ResponseCode(code = 401, condition = "Unauthorized"), + @ResponseCode(code = 403, condition = "Forbidden"), + @ResponseCode(code = 404, condition = "Not Found"), + @ResponseCode(code = 501, condition = "Not Implemented") }) +public Response updateLoadBalancerPoolMember( + @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID, + @PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID, + final NeutronLoadBalancerPoolMemberRequest input) { + + //TODO: Implement update LB member pool + return Response.status(501).entity(input).build(); +} + +/** + * Deletes a LoadBalancerPoolMember + */ + +@Path("{loadBalancerPoolMemberUUID}") +@DELETE +@StatusCodes({ + @ResponseCode(code = 204, condition = "No Content"), + @ResponseCode(code = 401, condition = "Unauthorized"), + @ResponseCode(code = 403, condition = "Forbidden"), + @ResponseCode(code = 404, condition = "Not Found"), + @ResponseCode(code = 501, condition = "Not Implemented") }) +public Response deleteLoadBalancerPoolMember( + @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID, + @PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID) { + INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = NeutronCRUDInterfaces.getINeutronLoadBalancerPoolCRUD(this); + if (loadBalancerPoolInterface == null) { + throw new ServiceUnavailableException("LoadBalancerPool CRUD Interface " + + RestMessages.SERVICEUNAVAILABLE.toString()); + } + + // Verify that the loadBalancerPool exists, for the member to be removed from its cache + if (!loadBalancerPoolInterface.neutronLoadBalancerPoolExists(loadBalancerPoolUUID)) { + throw new ResourceNotFoundException("loadBalancerPool UUID does not exist."); + } + + //Verify that the LB pool member exists + NeutronLoadBalancerPoolMember singleton = null; + List members = + loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID).getLoadBalancerPoolMembers(); + for (NeutronLoadBalancerPoolMember member: members) { + if (member.getPoolMemberID().equals(loadBalancerPoolMemberUUID)) { + singleton = member; + break; + } + } + if (singleton == null) + throw new BadRequestException("LoadBalancerPoolMember UUID does not exist."); + + Object[] instances = ServiceHelper.getGlobalInstances(INeutronLoadBalancerPoolMemberAware.class, this, null); + if (instances != null) { + for (Object instance : instances) { + INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance; + int status = service.canDeleteNeutronLoadBalancerPoolMember(singleton); + if (status < 200 || status > 299) { + return Response.status(status).build(); + } + } + } + + if (instances != null) { + for (Object instance : instances) { + INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance; + service.neutronLoadBalancerPoolMemberDeleted(singleton); + } + } + + /** + * Remove the member from the neutron load balancer pool + */ + NeutronLoadBalancerPool singletonPool = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID); + singletonPool.removeLoadBalancerPoolMember(singleton); + + return Response.status(204).build(); +} }