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.getTenantID())) &&
 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         final 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         deleteUuid(RESOURCE_NAME, loadBalancerPoolUUID,
 327                    new Remover() {
 328                        public boolean remove(String uuid) {
 329                            return loadBalancerPoolInterface.removeNeutronLoadBalancerPool(uuid);
 330                        }
 331                    });
 332         if (instances != null) {
 333             for (Object instance : instances) {
 334                 INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
 335                 service.neutronLoadBalancerPoolDeleted(singleton);
 336             }
 337         }
 338         return Response.status(HttpURLConnection.HTTP_NO_CONTENT).build();
 339     }
 340
 341     private NeutronLoadBalancerPoolMember extractFields(NeutronLoadBalancerPoolMember o, List<String> fields) {
 342         return o.extractFields(fields);
 343     }
 344
 345     /**
 346      * Returns a list of all LoadBalancerPoolMembers in specified pool
 347      */
 348     @Path("{loadBalancerPoolUUID}/members")
 349     @GET
 350     @Produces({MediaType.APPLICATION_JSON})
 351     @StatusCodes({
 352             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 353             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 354             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 355     public Response listMembers(
 356             //Path param
 357             @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 358
 359             // return fields
 360             @QueryParam("fields") List<String> fields,
 361
 362             // OpenStack LoadBalancerPool attributes
 363             @QueryParam("id") String queryLoadBalancerPoolMemberID,
 364             @QueryParam("tenant_id") String queryLoadBalancerPoolMemberTenantID,
 365             @QueryParam("address") String queryLoadBalancerPoolMemberAddress,
 366             @QueryParam("protocol_port") String queryLoadBalancerPoolMemberProtoPort,
 367             @QueryParam("admin_state_up") String queryLoadBalancerPoolMemberAdminStateUp,
 368             @QueryParam("weight") String queryLoadBalancerPoolMemberWeight,
 369             @QueryParam("subnet_id") String queryLoadBalancerPoolMemberSubnetID,
 370
 371             // pagination
 372             @QueryParam("limit") String limit,
 373             @QueryParam("marker") String marker,
 374             @QueryParam("page_reverse") String pageReverse
 375             // sorting not supported
 376     ) {
 377         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 378         if (!loadBalancerPoolInterface.neutronLoadBalancerPoolExists(loadBalancerPoolUUID)) {
 379             throw new ResourceNotFoundException(uuidNoExist(RESOURCE_NAME));
 380         }
 381         List<NeutronLoadBalancerPoolMember> members =
 382                     loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID).getLoadBalancerPoolMembers();
 383         List<NeutronLoadBalancerPoolMember> ans = new ArrayList<NeutronLoadBalancerPoolMember>();
 384         Iterator<NeutronLoadBalancerPoolMember> i = members.iterator();
 385         while (i.hasNext()) {
 386             NeutronLoadBalancerPoolMember nsg = i.next();
 387             if ((queryLoadBalancerPoolMemberID == null ||
 388                 queryLoadBalancerPoolMemberID.equals(nsg.getID())) &&
 389                 loadBalancerPoolUUID.equals(nsg.getPoolID()) &&
 390                 (queryLoadBalancerPoolMemberTenantID == null ||
 391                         queryLoadBalancerPoolMemberTenantID.equals(nsg.getTenantID())) &&
 392                 (queryLoadBalancerPoolMemberAddress == null ||
 393                         queryLoadBalancerPoolMemberAddress.equals(nsg.getPoolMemberAddress())) &&
 394                 (queryLoadBalancerPoolMemberAdminStateUp == null ||
 395                         queryLoadBalancerPoolMemberAdminStateUp.equals(nsg.getPoolMemberAdminStateIsUp())) &&
 396                 (queryLoadBalancerPoolMemberWeight == null ||
 397                         queryLoadBalancerPoolMemberWeight.equals(nsg.getPoolMemberWeight())) &&
 398                 (queryLoadBalancerPoolMemberSubnetID == null ||
 399                         queryLoadBalancerPoolMemberSubnetID.equals(nsg.getPoolMemberSubnetID()))) {
 400                 if (fields.size() > 0) {
 401                     ans.add(extractFields(nsg, fields));
 402                 } else {
 403                     ans.add(nsg);
 404                 }
 405             }
 406         }
 407         return Response.status(HttpURLConnection.HTTP_OK).entity(
 408                 new NeutronLoadBalancerPoolMemberRequest(ans)).build();
 409     }
 410
 411     /**
 412      * Returns a specific LoadBalancerPoolMember
 413      */
 414     @Path("{loadBalancerPoolUUID}/members/{loadBalancerPoolMemberUUID}")
 415     @GET
 416     @Produces({ MediaType.APPLICATION_JSON })
 417     //@TypeHint(OpenStackLoadBalancerPoolMembers.class)
 418     @StatusCodes({
 419         @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 420         @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 421         @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 422         @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 423     public Response showLoadBalancerPoolMember(
 424             @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 425             @PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID,
 426             // return fields
 427             @QueryParam("fields") List<String> fields ) {
 428
 429         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 430         if (!loadBalancerPoolInterface.neutronLoadBalancerPoolExists(loadBalancerPoolUUID)) {
 431             throw new ResourceNotFoundException(uuidNoExist(RESOURCE_NAME));
 432         }
 433         List<NeutronLoadBalancerPoolMember> members =
 434                     loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID).getLoadBalancerPoolMembers();
 435         for (NeutronLoadBalancerPoolMember ans: members) {
 436             if (!ans.getID().equals(loadBalancerPoolMemberUUID)) {
 437                 continue;
 438             }
 439
 440             if (fields.size() > 0) {
 441                 return Response.status(HttpURLConnection.HTTP_OK).entity(
 442                     new NeutronLoadBalancerPoolMemberRequest(extractFields(ans, fields))).build();
 443             } else {
 444                 return Response.status(HttpURLConnection.HTTP_OK).entity(
 445                     new NeutronLoadBalancerPoolMemberRequest(ans)).build();
 446             }
 447         }
 448         throw new ResourceNotFoundException(uuidNoExist(RESOURCE_NAME));
 449     }
 450
 451     /**
 452      * Adds a Member to an LBaaS Pool member
 453      */
 454     @Path("{loadBalancerPoolUUID}/members")
 455     @POST
 456     @Produces({MediaType.APPLICATION_JSON})
 457     @Consumes({MediaType.APPLICATION_JSON})
 458     @StatusCodes({
 459             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 460             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 461     public Response createLoadBalancerPoolMember(
 462             @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 463             final NeutronLoadBalancerPoolMemberRequest input) {
 464
 465         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 466         NeutronLoadBalancerPool singletonPool = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID);
 467
 468         if (input.isSingleton()) {
 469             NeutronLoadBalancerPoolMember singleton = input.getSingleton();
 470             singleton.setPoolID(loadBalancerPoolUUID);
 471
 472             Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolMemberAware.class, this);
 473             if (instances != null) {
 474                 if (instances.length > 0) {
 475                     for (Object instance : instances) {
 476                         INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 477                         int status = service.canCreateNeutronLoadBalancerPoolMember(singleton);
 478                         if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 479                             return Response.status(status).build();
 480                         }
 481                     }
 482                 } else {
 483                     throw new ServiceUnavailableException(NO_PROVIDERS);
 484                 }
 485             } else {
 486                 throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 487             }
 488
 489             if (instances != null) {
 490                 for (Object instance : instances) {
 491                     INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 492                     service.neutronLoadBalancerPoolMemberCreated(singleton);
 493                 }
 494             }
 495
 496             /**
 497              * Add the member from the neutron load balancer pool as well
 498              */
 499
 500             loadBalancerPoolInterface.addNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, singleton);
 501         } else {
 502             Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolMemberAware.class, this);
 503             for (NeutronLoadBalancerPoolMember test : input.getBulk()) {
 504
 505                 if (instances != null) {
 506                     if (instances.length > 0) {
 507                         for (Object instance : instances) {
 508                             INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 509                             int status = service.canCreateNeutronLoadBalancerPoolMember(test);
 510                             if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 511                                 return Response.status(status).build();
 512                             }
 513                         }
 514                     } else {
 515                         throw new ServiceUnavailableException(NO_PROVIDERS);
 516                     }
 517                 } else {
 518                     throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 519                 }
 520             }
 521             /*
 522              * now, each element of the bulk request can be added to the cache
 523              */
 524             for (NeutronLoadBalancerPoolMember test : input.getBulk()) {
 525                 if (instances != null) {
 526                     for (Object instance : instances) {
 527                         INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 528                         service.neutronLoadBalancerPoolMemberCreated(test);
 529                     }
 530                 }
 531                 loadBalancerPoolInterface.addNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, test);
 532             }
 533         }
 534         return Response.status(HttpURLConnection.HTTP_CREATED).entity(input).build();
 535     }
 536
 537     /**
 538      * Updates a LB member pool
 539      */
 540
 541     @Path("{loadBalancerPoolUUID}/members/{loadBalancerPoolMemberUUID}")
 542     @PUT
 543     @Produces({ MediaType.APPLICATION_JSON })
 544     @Consumes({ MediaType.APPLICATION_JSON })
 545     @StatusCodes({
 546             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful") })
 547     public Response updateLoadBalancerPoolMember(
 548             @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 549             @PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID,
 550             final NeutronLoadBalancerPoolMemberRequest input) {
 551         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 552         NeutronLoadBalancerPool singletonPool = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID);
 553         NeutronLoadBalancerPoolMember singleton = input.getSingleton();
 554         singleton.setPoolID(loadBalancerPoolUUID);
 555
 556         if (singletonPool == null) {
 557             throw new ResourceNotFoundException("Pool doesn't Exist");
 558         }
 559         NeutronLoadBalancerPoolMember original = singletonPool.getNeutronLoadBalancerPoolMember(loadBalancerPoolMemberUUID);
 560
 561         Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolMemberAware.class, this);
 562         if (instances != null) {
 563             if (instances.length > 0) {
 564                 for (Object instance : instances) {
 565                     INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 566                     int status = service.canUpdateNeutronLoadBalancerPoolMember(singleton, original);
 567                     if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 568                         return Response.status(status).build();
 569                     }
 570                 }
 571             } else {
 572                 throw new ServiceUnavailableException(NO_PROVIDERS);
 573             }
 574         } else {
 575             throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 576         }
 577
 578         loadBalancerPoolInterface.updateNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, loadBalancerPoolMemberUUID, singleton);
 579
 580         if (instances != null) {
 581             for (Object instance : instances) {
 582                 INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 583                 service.neutronLoadBalancerPoolMemberUpdated(singleton);
 584             }
 585         }
 586         return Response.status(HttpURLConnection.HTTP_OK).entity(input).build();
 587     }
 588
 589     /**
 590      * Deletes a LoadBalancerPoolMember
 591      */
 592
 593     @Path("{loadBalancerPoolUUID}/members/{loadBalancerPoolMemberUUID}")
 594     @DELETE
 595     @StatusCodes({
 596         @ResponseCode(code = HttpURLConnection.HTTP_NO_CONTENT, condition = "No Content"),
 597         @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 598     public Response deleteLoadBalancerPoolMember(
 599             @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 600             @PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID) {
 601         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 602
 603         //Verify that the LB pool member exists
 604         NeutronLoadBalancerPoolMember singleton = null;
 605         List<NeutronLoadBalancerPoolMember> members =
 606                 loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID).getLoadBalancerPoolMembers();
 607         for (NeutronLoadBalancerPoolMember member: members) {
 608             if (member.getID().equals(loadBalancerPoolMemberUUID)) {
 609                 singleton = member;
 610                 break;
 611             }
 612         }
 613         if (singleton == null) {
 614             throw new BadRequestException("LoadBalancerPoolMember UUID does not exist.");
 615         }
 616
 617         Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolMemberAware.class, this);
 618         if (instances != null) {
 619             if (instances.length > 0) {
 620                 for (Object instance : instances) {
 621                     INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 622                     int status = service.canDeleteNeutronLoadBalancerPoolMember(singleton);
 623                     if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 624                         return Response.status(status).build();
 625                     }
 626                 }
 627             } else {
 628                 throw new ServiceUnavailableException(NO_PROVIDERS);
 629             }
 630         } else {
 631             throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 632         }
 633
 634         if (instances != null) {
 635             for (Object instance : instances) {
 636                 INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 637                 service.neutronLoadBalancerPoolMemberDeleted(singleton);
 638             }
 639         }
 640
 641         /**
 642          * Remove the member from the neutron load balancer pool
 643          */
 644         loadBalancerPoolInterface.removeNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, loadBalancerPoolMemberUUID);
 645
 646         return Response.status(HttpURLConnection.HTTP_NO_CONTENT).build();
 647     }
 648 }