northbound-api/src/main/java/org/opendaylight/neutron/northbound/api/NeutronLoadBalancerPoolNorthbound.java

   1 /*
   2  * Copyright (c) 2014, 2015 SDN Hub, LLC. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.neutron.northbound.api;
  10
  11 import java.net.HttpURLConnection;
  12
  13 import java.util.ArrayList;
  14 import java.util.Iterator;
  15 import java.util.List;
  16
  17 import javax.ws.rs.Consumes;
  18 import javax.ws.rs.DELETE;
  19 import javax.ws.rs.GET;
  20 import javax.ws.rs.POST;
  21 import javax.ws.rs.PUT;
  22 import javax.ws.rs.Path;
  23 import javax.ws.rs.PathParam;
  24 import javax.ws.rs.Produces;
  25 import javax.ws.rs.QueryParam;
  26 import javax.ws.rs.core.MediaType;
  27 import javax.ws.rs.core.Response;
  28
  29 import org.codehaus.enunciate.jaxrs.ResponseCode;
  30 import org.codehaus.enunciate.jaxrs.StatusCodes;
  31 import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolAware;
  32 import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolCRUD;
  33 import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolMemberAware;
  34 import org.opendaylight.neutron.spi.NeutronCRUDInterfaces;
  35 import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
  36 import org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember;
  37
  38 /**
  39  * Neutron Northbound REST APIs for LoadBalancerPool Policies.<br>
  40  * This class provides REST APIs for managing neutron LoadBalancerPool Policies
  41  *
  42  * <br>
  43  * <br>
  44  * Authentication scheme : <b>HTTP Basic</b><br>
  45  * Authentication realm : <b>opendaylight</b><br>
  46  * Transport : <b>HTTP and HTTPS</b><br>
  47  * <br>
  48  * HTTPS Authentication is disabled by default. Administrator can enable it in
  49  * tomcat-server.xml after adding a proper keystore / SSL certificate from a
  50  * trusted authority.<br>
  51  * More info :
  52  * http://tomcat.apache.org/tomcat-7.0-doc/ssl-howto.html#Configuration
  53  *
  54  */
  55
  56 /**
  57  * For now, the LB pool member data is maintained with the INeutronLoadBalancerPoolCRUD,
  58  * and not duplicated within the INeutronLoadBalancerPoolMemberCRUD's cache.
  59  */
  60
  61 @Path("/lbaas/pools")
  62 public class NeutronLoadBalancerPoolNorthbound extends AbstractNeutronNorthbound {
  63
  64     private static final String RESOURCE_NAME = "LoadBalancerPool";
  65
  66     private NeutronLoadBalancerPool extractFields(NeutronLoadBalancerPool o, List<String> fields) {
  67         return o.extractFields(fields);
  68     }
  69
  70     private NeutronCRUDInterfaces getNeutronInterfaces() {
  71         NeutronCRUDInterfaces answer = new NeutronCRUDInterfaces().
  72             fetchINeutronLoadBalancerPoolCRUD(this);
  73         if (answer.getLoadBalancerPoolInterface() == null) {
  74             throw new ServiceUnavailableException(serviceUnavailable(RESOURCE_NAME));
  75         }
  76         return answer;
  77     }
  78
  79
  80     /**
  81      * Returns a list of all LoadBalancerPool
  82      * */
  83     @GET
  84     @Produces({ MediaType.APPLICATION_JSON })
  85     @StatusCodes({
  86             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
  87             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
  88             @ResponseCode(code = HttpURLConnection.HTTP_NOT_IMPLEMENTED, condition = "Not Implemented"),
  89             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
  90
  91     public Response listGroups(
  92             // return fields
  93             @QueryParam("fields") List<String> fields,
  94             // OpenStack LoadBalancerPool attributes
  95             @QueryParam("id") String queryLoadBalancerPoolID,
  96             @QueryParam("tenant_id") String queryLoadBalancerPoolTenantID,
  97             @QueryParam("name") String queryLoadBalancerPoolName,
  98             @QueryParam("description") String queryLoadBalancerDescription,
  99             @QueryParam("protocol") String queryLoadBalancerProtocol,
 100             @QueryParam("lb_algorithm") String queryLoadBalancerPoolLbAlgorithm,
 101             @QueryParam("healthmonitor_id") String queryLoadBalancerPoolHealthMonitorID,
 102             @QueryParam("admin_state_up") String queryLoadBalancerIsAdminStateUp,
 103             @QueryParam("members") List<NeutronLoadBalancerPoolMember> queryLoadBalancerPoolMembers,
 104             // pagination
 105             @QueryParam("limit") String limit,
 106             @QueryParam("marker") String marker,
 107             @QueryParam("page_reverse") String pageReverse
 108             // sorting not supported
 109     ) {
 110         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 111         List<NeutronLoadBalancerPool> allLoadBalancerPools = loadBalancerPoolInterface.getAllNeutronLoadBalancerPools();
 112         List<NeutronLoadBalancerPool> ans = new ArrayList<NeutronLoadBalancerPool>();
 113         Iterator<NeutronLoadBalancerPool> i = allLoadBalancerPools.iterator();
 114         while (i.hasNext()) {
 115             NeutronLoadBalancerPool nsg = i.next();
 116             if ((queryLoadBalancerPoolID == null ||
 117                     queryLoadBalancerPoolID.equals(nsg.getID())) &&
 118                     (queryLoadBalancerPoolTenantID == null ||
 119                             queryLoadBalancerPoolTenantID.equals(nsg.getLoadBalancerPoolTenantID())) &&
 120                     (queryLoadBalancerPoolName == null ||
 121                             queryLoadBalancerPoolName.equals(nsg.getLoadBalancerPoolName())) &&
 122                     (queryLoadBalancerDescription == null ||
 123                             queryLoadBalancerDescription.equals(nsg.getLoadBalancerPoolDescription())) &&
 124                     (queryLoadBalancerPoolLbAlgorithm == null ||
 125                             queryLoadBalancerPoolLbAlgorithm.equals(nsg.getLoadBalancerPoolLbAlgorithm())) &&
 126                     (queryLoadBalancerPoolHealthMonitorID == null ||
 127                             queryLoadBalancerPoolHealthMonitorID.equals(nsg.getNeutronLoadBalancerPoolHealthMonitorID())) &&
 128                     (queryLoadBalancerIsAdminStateUp == null ||
 129                             queryLoadBalancerIsAdminStateUp.equals(nsg.getLoadBalancerPoolAdminIsStateIsUp())) &&
 130                     (queryLoadBalancerPoolMembers.size() == 0 ||
 131                             queryLoadBalancerPoolMembers.equals(nsg.getLoadBalancerPoolMembers()))) {
 132                 if (fields.size() > 0) {
 133                     ans.add(extractFields(nsg,fields));
 134                 } else {
 135                     ans.add(nsg);
 136                 }
 137             }
 138         }
 139         return Response.status(HttpURLConnection.HTTP_OK).entity(
 140                 new NeutronLoadBalancerPoolRequest(ans)).build();
 141     }
 142
 143     /**
 144      * Returns a specific LoadBalancerPool */
 145
 146     @Path("{loadBalancerPoolID}")
 147     @GET
 148     @Produces({ MediaType.APPLICATION_JSON })
 149     @StatusCodes({
 150             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 151             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 152             @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 153             @ResponseCode(code = HttpURLConnection.HTTP_NOT_IMPLEMENTED, condition = "Not Implemented"),
 154             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 155     public Response showLoadBalancerPool(@PathParam("loadBalancerPoolID") String loadBalancerPoolID,
 156             // return fields
 157             @QueryParam("fields") List<String> fields) {
 158         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 159         if (!loadBalancerPoolInterface.neutronLoadBalancerPoolExists(loadBalancerPoolID)) {
 160             throw new ResourceNotFoundException(uuidNoExist(RESOURCE_NAME));
 161         }
 162         if (fields.size() > 0) {
 163             NeutronLoadBalancerPool ans = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolID);
 164             return Response.status(HttpURLConnection.HTTP_OK).entity(
 165                     new NeutronLoadBalancerPoolRequest(extractFields(ans, fields))).build();
 166         } else {
 167             return Response.status(HttpURLConnection.HTTP_OK).entity(new NeutronLoadBalancerPoolRequest(loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolID))).build();
 168         }
 169     }
 170
 171     /**
 172      * Creates new LoadBalancerPool */
 173
 174     @POST
 175     @Produces({ MediaType.APPLICATION_JSON })
 176     @Consumes({ MediaType.APPLICATION_JSON })
 177     @StatusCodes({
 178             @ResponseCode(code = HttpURLConnection.HTTP_CREATED, condition = "Created"),
 179             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 180     public Response createLoadBalancerPools(final NeutronLoadBalancerPoolRequest input) {
 181         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 182         if (input.isSingleton()) {
 183             NeutronLoadBalancerPool singleton = input.getSingleton();
 184
 185             Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolAware.class, this);
 186             if (instances != null) {
 187                 if (instances.length > 0) {
 188                     for (Object instance : instances) {
 189                         INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
 190                         int status = service.canCreateNeutronLoadBalancerPool(singleton);
 191                         if (status < HttpURLConnection.HTTP_OK || status > HTTP_OK_TOP) {
 192                             return Response.status(status).build();
 193                         }
 194                     }
 195                 } else {
 196                     throw new ServiceUnavailableException(NO_PROVIDERS);
 197                 }
 198             } else {
 199                 throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 200             }
 201             loadBalancerPoolInterface.addNeutronLoadBalancerPool(singleton);
 202             if (instances != null) {
 203                 for (Object instance : instances) {
 204                     INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
 205                     service.neutronLoadBalancerPoolCreated(singleton);
 206                 }
 207             }
 208         } else {
 209             Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolAware.class, this);
 210             for (NeutronLoadBalancerPool test : input.getBulk()) {
 211
 212                 if (instances != null) {
 213                     if (instances.length > 0) {
 214                         for (Object instance : instances) {
 215                             INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
 216                             int status = service.canCreateNeutronLoadBalancerPool(test);
 217                             if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 218                                 return Response.status(status).build();
 219                             }
 220                         }
 221                     } else {
 222                         throw new ServiceUnavailableException(NO_PROVIDERS);
 223                     }
 224                 } else {
 225                     throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 226                 }
 227             }
 228             /*
 229              * now, each element of the bulk request can be added to the cache
 230              */
 231             for (NeutronLoadBalancerPool test : input.getBulk()) {
 232                 loadBalancerPoolInterface.addNeutronLoadBalancerPool(test);
 233                 if (instances != null) {
 234                     for (Object instance : instances) {
 235                         INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
 236                         service.neutronLoadBalancerPoolCreated(test);
 237                     }
 238                 }
 239             }
 240         }
 241         return Response.status(HttpURLConnection.HTTP_CREATED).entity(input).build();
 242     }
 243
 244     /**
 245      * Updates a LoadBalancerPool Policy
 246      */
 247     @Path("{loadBalancerPoolID}")
 248     @PUT
 249     @Produces({ MediaType.APPLICATION_JSON })
 250     @Consumes({ MediaType.APPLICATION_JSON })
 251     @StatusCodes({
 252             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 253             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 254     public Response updateLoadBalancerPool(
 255             @PathParam("loadBalancerPoolID") String loadBalancerPoolID, final NeutronLoadBalancerPoolRequest input) {
 256         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 257
 258         NeutronLoadBalancerPool delta = input.getSingleton();
 259         NeutronLoadBalancerPool original = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolID);
 260
 261         Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolAware.class, this);
 262         if (instances != null) {
 263             if (instances.length > 0) {
 264                 for (Object instance : instances) {
 265                     INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
 266                     int status = service.canUpdateNeutronLoadBalancerPool(delta, original);
 267                     if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 268                         return Response.status(status).build();
 269                     }
 270                 }
 271             } else {
 272                 throw new ServiceUnavailableException(NO_PROVIDERS);
 273             }
 274         } else {
 275             throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 276         }
 277
 278         /*
 279          * update the object and return it
 280          */
 281         loadBalancerPoolInterface.updateNeutronLoadBalancerPool(loadBalancerPoolID, delta);
 282         NeutronLoadBalancerPool updatedLoadBalancerPool = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolID);
 283         if (instances != null) {
 284             for (Object instance : instances) {
 285                 INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
 286                 service.neutronLoadBalancerPoolUpdated(updatedLoadBalancerPool);
 287             }
 288         }
 289         return Response.status(HttpURLConnection.HTTP_OK).entity(new NeutronLoadBalancerPoolRequest(loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolID))).build();
 290     }
 291
 292     /**
 293      * Deletes a LoadBalancerPool
 294      */
 295
 296     @Path("{loadBalancerPoolUUID}")
 297     @DELETE
 298     @StatusCodes({
 299             @ResponseCode(code = HttpURLConnection.HTTP_NO_CONTENT, condition = "No Content"),
 300             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 301     public Response deleteLoadBalancerPool(
 302             @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID) {
 303         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 304
 305         NeutronLoadBalancerPool singleton = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID);
 306         Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolAware.class, this);
 307         if (instances != null) {
 308             if (instances.length > 0) {
 309                 for (Object instance : instances) {
 310                     INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
 311                     int status = service.canDeleteNeutronLoadBalancerPool(singleton);
 312                     if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 313                         return Response.status(status).build();
 314                     }
 315                 }
 316             } else {
 317                 throw new ServiceUnavailableException(NO_PROVIDERS);
 318             }
 319         } else {
 320             throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 321         }
 322
 323         /*
 324          * remove it and return 204 status
 325          */
 326         loadBalancerPoolInterface.removeNeutronLoadBalancerPool(loadBalancerPoolUUID);
 327         if (instances != null) {
 328             for (Object instance : instances) {
 329                 INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
 330                 service.neutronLoadBalancerPoolDeleted(singleton);
 331             }
 332         }
 333         return Response.status(HttpURLConnection.HTTP_NO_CONTENT).build();
 334     }
 335
 336     private NeutronLoadBalancerPoolMember extractFields(NeutronLoadBalancerPoolMember o, List<String> fields) {
 337         return o.extractFields(fields);
 338     }
 339
 340     /**
 341      * Returns a list of all LoadBalancerPoolMembers in specified pool
 342      */
 343     @Path("{loadBalancerPoolUUID}/members")
 344     @GET
 345     @Produces({MediaType.APPLICATION_JSON})
 346     @StatusCodes({
 347             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 348             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 349             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 350     public Response listMembers(
 351             //Path param
 352             @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 353
 354             // return fields
 355             @QueryParam("fields") List<String> fields,
 356
 357             // OpenStack LoadBalancerPool attributes
 358             @QueryParam("id") String queryLoadBalancerPoolMemberID,
 359             @QueryParam("tenant_id") String queryLoadBalancerPoolMemberTenantID,
 360             @QueryParam("address") String queryLoadBalancerPoolMemberAddress,
 361             @QueryParam("protocol_port") String queryLoadBalancerPoolMemberProtoPort,
 362             @QueryParam("admin_state_up") String queryLoadBalancerPoolMemberAdminStateUp,
 363             @QueryParam("weight") String queryLoadBalancerPoolMemberWeight,
 364             @QueryParam("subnet_id") String queryLoadBalancerPoolMemberSubnetID,
 365
 366             // pagination
 367             @QueryParam("limit") String limit,
 368             @QueryParam("marker") String marker,
 369             @QueryParam("page_reverse") String pageReverse
 370             // sorting not supported
 371     ) {
 372         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 373         if (!loadBalancerPoolInterface.neutronLoadBalancerPoolExists(loadBalancerPoolUUID)) {
 374             throw new ResourceNotFoundException(uuidNoExist(RESOURCE_NAME));
 375         }
 376         List<NeutronLoadBalancerPoolMember> members =
 377                     loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID).getLoadBalancerPoolMembers();
 378         List<NeutronLoadBalancerPoolMember> ans = new ArrayList<NeutronLoadBalancerPoolMember>();
 379         Iterator<NeutronLoadBalancerPoolMember> i = members.iterator();
 380         while (i.hasNext()) {
 381             NeutronLoadBalancerPoolMember nsg = i.next();
 382             if ((queryLoadBalancerPoolMemberID == null ||
 383                 queryLoadBalancerPoolMemberID.equals(nsg.getID())) &&
 384                 loadBalancerPoolUUID.equals(nsg.getPoolID()) &&
 385                 (queryLoadBalancerPoolMemberTenantID == null ||
 386                         queryLoadBalancerPoolMemberTenantID.equals(nsg.getPoolMemberTenantID())) &&
 387                 (queryLoadBalancerPoolMemberAddress == null ||
 388                         queryLoadBalancerPoolMemberAddress.equals(nsg.getPoolMemberAddress())) &&
 389                 (queryLoadBalancerPoolMemberAdminStateUp == null ||
 390                         queryLoadBalancerPoolMemberAdminStateUp.equals(nsg.getPoolMemberAdminStateIsUp())) &&
 391                 (queryLoadBalancerPoolMemberWeight == null ||
 392                         queryLoadBalancerPoolMemberWeight.equals(nsg.getPoolMemberWeight())) &&
 393                 (queryLoadBalancerPoolMemberSubnetID == null ||
 394                         queryLoadBalancerPoolMemberSubnetID.equals(nsg.getPoolMemberSubnetID()))) {
 395                 if (fields.size() > 0) {
 396                     ans.add(extractFields(nsg, fields));
 397                 } else {
 398                     ans.add(nsg);
 399                 }
 400             }
 401         }
 402         return Response.status(HttpURLConnection.HTTP_OK).entity(
 403                 new NeutronLoadBalancerPoolMemberRequest(ans)).build();
 404     }
 405
 406     /**
 407      * Returns a specific LoadBalancerPoolMember
 408      */
 409     @Path("{loadBalancerPoolUUID}/members/{loadBalancerPoolMemberUUID}")
 410     @GET
 411     @Produces({ MediaType.APPLICATION_JSON })
 412     //@TypeHint(OpenStackLoadBalancerPoolMembers.class)
 413     @StatusCodes({
 414         @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 415         @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 416         @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 417         @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 418     public Response showLoadBalancerPoolMember(
 419             @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 420             @PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID,
 421             // return fields
 422             @QueryParam("fields") List<String> fields ) {
 423
 424         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 425         if (!loadBalancerPoolInterface.neutronLoadBalancerPoolExists(loadBalancerPoolUUID)) {
 426             throw new ResourceNotFoundException(uuidNoExist(RESOURCE_NAME));
 427         }
 428         List<NeutronLoadBalancerPoolMember> members =
 429                     loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID).getLoadBalancerPoolMembers();
 430         for (NeutronLoadBalancerPoolMember ans: members) {
 431             if (!ans.getID().equals(loadBalancerPoolMemberUUID)) {
 432                 continue;
 433             }
 434
 435             if (fields.size() > 0) {
 436                 return Response.status(HttpURLConnection.HTTP_OK).entity(
 437                     new NeutronLoadBalancerPoolMemberRequest(extractFields(ans, fields))).build();
 438             } else {
 439                 return Response.status(HttpURLConnection.HTTP_OK).entity(
 440                     new NeutronLoadBalancerPoolMemberRequest(ans)).build();
 441             }
 442         }
 443         throw new ResourceNotFoundException(uuidNoExist(RESOURCE_NAME));
 444     }
 445
 446     /**
 447      * Adds a Member to an LBaaS Pool member
 448      */
 449     @Path("{loadBalancerPoolUUID}/members")
 450     @POST
 451     @Produces({MediaType.APPLICATION_JSON})
 452     @Consumes({MediaType.APPLICATION_JSON})
 453     @StatusCodes({
 454             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 455             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 456     public Response createLoadBalancerPoolMember(
 457             @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 458             final NeutronLoadBalancerPoolMemberRequest input) {
 459
 460         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 461         NeutronLoadBalancerPool singletonPool = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID);
 462
 463         if (input.isSingleton()) {
 464             NeutronLoadBalancerPoolMember singleton = input.getSingleton();
 465             singleton.setPoolID(loadBalancerPoolUUID);
 466
 467             Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolMemberAware.class, this);
 468             if (instances != null) {
 469                 if (instances.length > 0) {
 470                     for (Object instance : instances) {
 471                         INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 472                         int status = service.canCreateNeutronLoadBalancerPoolMember(singleton);
 473                         if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 474                             return Response.status(status).build();
 475                         }
 476                     }
 477                 } else {
 478                     throw new ServiceUnavailableException(NO_PROVIDERS);
 479                 }
 480             } else {
 481                 throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 482             }
 483
 484             if (instances != null) {
 485                 for (Object instance : instances) {
 486                     INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 487                     service.neutronLoadBalancerPoolMemberCreated(singleton);
 488                 }
 489             }
 490
 491             /**
 492              * Add the member from the neutron load balancer pool as well
 493              */
 494
 495             loadBalancerPoolInterface.addNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, singleton);
 496         } else {
 497             Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolMemberAware.class, this);
 498             for (NeutronLoadBalancerPoolMember test : input.getBulk()) {
 499
 500                 if (instances != null) {
 501                     if (instances.length > 0) {
 502                         for (Object instance : instances) {
 503                             INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 504                             int status = service.canCreateNeutronLoadBalancerPoolMember(test);
 505                             if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 506                                 return Response.status(status).build();
 507                             }
 508                         }
 509                     } else {
 510                         throw new ServiceUnavailableException(NO_PROVIDERS);
 511                     }
 512                 } else {
 513                     throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 514                 }
 515             }
 516             /*
 517              * now, each element of the bulk request can be added to the cache
 518              */
 519             for (NeutronLoadBalancerPoolMember test : input.getBulk()) {
 520                 if (instances != null) {
 521                     for (Object instance : instances) {
 522                         INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 523                         service.neutronLoadBalancerPoolMemberCreated(test);
 524                     }
 525                 }
 526                 loadBalancerPoolInterface.addNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, test);
 527             }
 528         }
 529         return Response.status(HttpURLConnection.HTTP_CREATED).entity(input).build();
 530     }
 531
 532     /**
 533      * Updates a LB member pool
 534      */
 535
 536     @Path("{loadBalancerPoolUUID}/members/{loadBalancerPoolMemberUUID}")
 537     @PUT
 538     @Produces({ MediaType.APPLICATION_JSON })
 539     @Consumes({ MediaType.APPLICATION_JSON })
 540     @StatusCodes({
 541             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful") })
 542     public Response updateLoadBalancerPoolMember(
 543             @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 544             @PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID,
 545             final NeutronLoadBalancerPoolMemberRequest input) {
 546         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 547         NeutronLoadBalancerPool singletonPool = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID);
 548         NeutronLoadBalancerPoolMember singleton = input.getSingleton();
 549         singleton.setPoolID(loadBalancerPoolUUID);
 550
 551         if (singletonPool == null) {
 552             throw new ResourceNotFoundException("Pool doesn't Exist");
 553         }
 554         NeutronLoadBalancerPoolMember original = singletonPool.getNeutronLoadBalancerPoolMember(loadBalancerPoolMemberUUID);
 555
 556         Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolMemberAware.class, this);
 557         if (instances != null) {
 558             if (instances.length > 0) {
 559                 for (Object instance : instances) {
 560                     INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 561                     int status = service.canUpdateNeutronLoadBalancerPoolMember(singleton, original);
 562                     if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 563                         return Response.status(status).build();
 564                     }
 565                 }
 566             } else {
 567                 throw new ServiceUnavailableException(NO_PROVIDERS);
 568             }
 569         } else {
 570             throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 571         }
 572
 573         loadBalancerPoolInterface.updateNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, loadBalancerPoolMemberUUID, singleton);
 574
 575         if (instances != null) {
 576             for (Object instance : instances) {
 577                 INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 578                 service.neutronLoadBalancerPoolMemberUpdated(singleton);
 579             }
 580         }
 581         return Response.status(HttpURLConnection.HTTP_OK).entity(input).build();
 582     }
 583
 584     /**
 585      * Deletes a LoadBalancerPoolMember
 586      */
 587
 588     @Path("{loadBalancerPoolUUID}/members/{loadBalancerPoolMemberUUID}")
 589     @DELETE
 590     @StatusCodes({
 591         @ResponseCode(code = HttpURLConnection.HTTP_NO_CONTENT, condition = "No Content"),
 592         @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 593     public Response deleteLoadBalancerPoolMember(
 594             @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 595             @PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID) {
 596         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 597
 598         //Verify that the LB pool member exists
 599         NeutronLoadBalancerPoolMember singleton = null;
 600         List<NeutronLoadBalancerPoolMember> members =
 601                 loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID).getLoadBalancerPoolMembers();
 602         for (NeutronLoadBalancerPoolMember member: members) {
 603             if (member.getID().equals(loadBalancerPoolMemberUUID)) {
 604                 singleton = member;
 605                 break;
 606             }
 607         }
 608         if (singleton == null) {
 609             throw new BadRequestException("LoadBalancerPoolMember UUID does not exist.");
 610         }
 611
 612         Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolMemberAware.class, this);
 613         if (instances != null) {
 614             if (instances.length > 0) {
 615                 for (Object instance : instances) {
 616                     INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 617                     int status = service.canDeleteNeutronLoadBalancerPoolMember(singleton);
 618                     if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 619                         return Response.status(status).build();
 620                     }
 621                 }
 622             } else {
 623                 throw new ServiceUnavailableException(NO_PROVIDERS);
 624             }
 625         } else {
 626             throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 627         }
 628
 629         if (instances != null) {
 630             for (Object instance : instances) {
 631                 INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 632                 service.neutronLoadBalancerPoolMemberDeleted(singleton);
 633             }
 634         }
 635
 636         /**
 637          * Remove the member from the neutron load balancer pool
 638          */
 639         loadBalancerPoolInterface.removeNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, loadBalancerPoolMemberUUID);
 640
 641         return Response.status(HttpURLConnection.HTTP_NO_CONTENT).build();
 642     }
 643 }