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

   1 /*
   2  * Copyright (C) 2014 SDN Hub, LLC.
   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  * Authors : Srini Seetharaman
   9  */
  10
  11 package org.opendaylight.neutron.northbound.api;
  12
  13 import java.util.ArrayList;
  14 import java.util.HashMap;
  15 import java.util.Iterator;
  16 import java.util.List;
  17
  18 import javax.ws.rs.Consumes;
  19 import javax.ws.rs.DELETE;
  20 import javax.ws.rs.GET;
  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.neutron.spi.INeutronLoadBalancerPoolCRUD;
  32 import org.opendaylight.neutron.neutron.spi.INeutronLoadBalancerPoolMemberAware;
  33 import org.opendaylight.neutron.neutron.spi.NeutronCRUDInterfaces;
  34 import org.opendaylight.neutron.neutron.spi.NeutronLoadBalancerPool;
  35 import org.opendaylight.neutron.neutron.spi.NeutronLoadBalancerPoolMember;
  36
  37 @Path("/pools/{loadBalancerPoolUUID}/members")
  38 public class NeutronLoadBalancerPoolMembersNorthbound {
  39     private NeutronLoadBalancerPoolMember extractFields(NeutronLoadBalancerPoolMember o, List<String> fields) {
  40         return o.extractFields(fields);
  41     }
  42 /**
  43  * Returns a list of all LoadBalancerPoolMembers in specified pool
  44  */
  45 @GET
  46 @Produces({MediaType.APPLICATION_JSON})
  47 @StatusCodes({
  48         @ResponseCode(code = 200, condition = "Operation successful"),
  49         @ResponseCode(code = 401, condition = "Unauthorized"),
  50         @ResponseCode(code = 501, condition = "Not Implemented"),
  51         @ResponseCode(code = 503, condition = "No providers available") })
  52
  53 public Response listMembers(
  54         //Path param
  55         @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
  56
  57         // return fields
  58         @QueryParam("fields") List<String> fields,
  59
  60         // OpenStack LoadBalancerPool attributes
  61         @QueryParam("id") String queryLoadBalancerPoolMemberID,
  62         @QueryParam("tenant_id") String queryLoadBalancerPoolMemberTenantID,
  63         @QueryParam("address") String queryLoadBalancerPoolMemberAddress,
  64         @QueryParam("protocol_port") String queryLoadBalancerPoolMemberProtoPort,
  65         @QueryParam("admin_state_up") String queryLoadBalancerPoolMemberAdminStateUp,
  66         @QueryParam("weight") String queryLoadBalancerPoolMemberWeight,
  67         @QueryParam("subnet_id") String queryLoadBalancerPoolMemberSubnetID,
  68         @QueryParam("status") String queryLoadBalancerPoolMemberStatus,
  69
  70         // pagination
  71         @QueryParam("limit") String limit,
  72         @QueryParam("marker") String marker,
  73         @QueryParam("page_reverse") String pageReverse
  74         // sorting not supported
  75 ) {
  76     INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = NeutronCRUDInterfaces
  77             .getINeutronLoadBalancerPoolCRUD(this);
  78     if (loadBalancerPoolInterface == null) {
  79         throw new ServiceUnavailableException("LoadBalancerPool CRUD Interface "
  80                 + RestMessages.SERVICEUNAVAILABLE.toString());
  81     }
  82     if (!loadBalancerPoolInterface.neutronLoadBalancerPoolExists(loadBalancerPoolUUID)) {
  83         throw new ResourceNotFoundException("loadBalancerPool UUID does not exist.");
  84     }
  85     List<NeutronLoadBalancerPoolMember> members =
  86                 loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID).getLoadBalancerPoolMembers();
  87     List<NeutronLoadBalancerPoolMember> ans = new ArrayList<NeutronLoadBalancerPoolMember>();
  88     Iterator<NeutronLoadBalancerPoolMember> i = members.iterator();
  89     while (i.hasNext()) {
  90         NeutronLoadBalancerPoolMember nsg = i.next();
  91         if ((queryLoadBalancerPoolMemberID == null ||
  92                 queryLoadBalancerPoolMemberID.equals(nsg.getPoolMemberID())) &&
  93                 loadBalancerPoolUUID.equals(nsg.getPoolID()) &&
  94                 (queryLoadBalancerPoolMemberTenantID == null ||
  95                         queryLoadBalancerPoolMemberTenantID.equals(nsg.getPoolMemberTenantID())) &&
  96                 (queryLoadBalancerPoolMemberAddress == null ||
  97                         queryLoadBalancerPoolMemberAddress.equals(nsg.getPoolMemberAddress())) &&
  98                 (queryLoadBalancerPoolMemberAdminStateUp == null ||
  99                         queryLoadBalancerPoolMemberAdminStateUp.equals(nsg.getPoolMemberAdminStateIsUp())) &&
 100                 (queryLoadBalancerPoolMemberWeight == null ||
 101                         queryLoadBalancerPoolMemberWeight.equals(nsg.getPoolMemberWeight())) &&
 102                 (queryLoadBalancerPoolMemberSubnetID == null ||
 103                         queryLoadBalancerPoolMemberSubnetID.equals(nsg.getPoolMemberSubnetID())) &&
 104                 (queryLoadBalancerPoolMemberStatus == null ||
 105                         queryLoadBalancerPoolMemberStatus.equals(nsg.getPoolMemberStatus()))) {
 106             if (fields.size() > 0) {
 107                 ans.add(extractFields(nsg, fields));
 108             } else {
 109                 ans.add(nsg);
 110             }
 111         }
 112     }
 113     return Response.status(200).entity(
 114             new NeutronLoadBalancerPoolMemberRequest(ans)).build();
 115 }
 116
 117 /**
 118  * Returns a specific LoadBalancerPoolMember
 119  */
 120
 121 @Path("{loadBalancerPoolMemberUUID}")
 122 @GET
 123 @Produces({ MediaType.APPLICATION_JSON })
 124 //@TypeHint(OpenStackLoadBalancerPoolMembers.class)
 125 @StatusCodes({
 126     @ResponseCode(code = 200, condition = "Operation successful"),
 127     @ResponseCode(code = 401, condition = "Unauthorized"),
 128     @ResponseCode(code = 404, condition = "Not Found"),
 129     @ResponseCode(code = 501, condition = "Not Implemented"),
 130     @ResponseCode(code = 503, condition = "No providers available") })
 131 public Response showLoadBalancerPoolMember(
 132         @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 133         @PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID,
 134         // return fields
 135         @QueryParam("fields") List<String> fields ) {
 136
 137     INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = NeutronCRUDInterfaces
 138             .getINeutronLoadBalancerPoolCRUD(this);
 139     if (loadBalancerPoolInterface == null) {
 140         throw new ServiceUnavailableException("LoadBalancerPool CRUD Interface "
 141                 + RestMessages.SERVICEUNAVAILABLE.toString());
 142     }
 143     if (!loadBalancerPoolInterface.neutronLoadBalancerPoolExists(loadBalancerPoolUUID)) {
 144         throw new ResourceNotFoundException("loadBalancerPool UUID does not exist.");
 145     }
 146     List<NeutronLoadBalancerPoolMember> members =
 147                 loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID).getLoadBalancerPoolMembers();
 148     for (NeutronLoadBalancerPoolMember ans: members) {
 149         if (!ans.getPoolMemberID().equals(loadBalancerPoolMemberUUID))
 150             continue;
 151
 152         if (fields.size() > 0) {
 153             return Response.status(200).entity(
 154                 new NeutronLoadBalancerPoolMemberRequest(extractFields(ans, fields))).build();
 155         } else {
 156             return Response.status(200).entity(
 157                 new NeutronLoadBalancerPoolMemberRequest(ans)).build();
 158         }
 159     }
 160     return Response.status(204).build();
 161 }
 162
 163 /**
 164  * Adds a Member to an LBaaS Pool member
 165  */
 166 @PUT
 167 @Produces({MediaType.APPLICATION_JSON})
 168 @Consumes({MediaType.APPLICATION_JSON})
 169 @StatusCodes({
 170         @ResponseCode(code = 200, condition = "Operation successful"),
 171         @ResponseCode(code = 401, condition = "Unauthorized"),
 172         @ResponseCode(code = 404, condition = "Not Found"),
 173         @ResponseCode(code = 501, condition = "Not Implemented"),
 174         @ResponseCode(code = 503, condition = "No providers available") })
 175 public Response createLoadBalancerPoolMember(
 176         @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 177         final NeutronLoadBalancerPoolMemberRequest input) {
 178
 179     INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = NeutronCRUDInterfaces.getINeutronLoadBalancerPoolCRUD(this);
 180     if (loadBalancerPoolInterface == null) {
 181         throw new ServiceUnavailableException("LoadBalancerPool CRUD Interface "
 182                 + RestMessages.SERVICEUNAVAILABLE.toString());
 183     }
 184     // Verify that the loadBalancerPool exists, for the member to be added to its cache
 185     if (!loadBalancerPoolInterface.neutronLoadBalancerPoolExists(loadBalancerPoolUUID)) {
 186         throw new ResourceNotFoundException("loadBalancerPool UUID does not exist.");
 187     }
 188     NeutronLoadBalancerPool singletonPool = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID);
 189
 190     if (input.isSingleton()) {
 191         NeutronLoadBalancerPoolMember singleton = input.getSingleton();
 192         singleton.setPoolID(loadBalancerPoolUUID);
 193         String loadBalancerPoolMemberUUID = singleton.getPoolMemberID();
 194
 195         /*
 196          *  Verify that the LoadBalancerPoolMember doesn't already exist.
 197          */
 198         List<NeutronLoadBalancerPoolMember> members = singletonPool.getLoadBalancerPoolMembers();
 199         for (NeutronLoadBalancerPoolMember member: members) {
 200             if (member.getPoolMemberID().equals(loadBalancerPoolMemberUUID))
 201                 throw new BadRequestException("LoadBalancerPoolMember UUID already exists");
 202         }
 203
 204         Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolMemberAware.class, this);
 205         if (instances != null) {
 206             if (instances.length > 0) {
 207                 for (Object instance : instances) {
 208                     INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 209                     int status = service.canCreateNeutronLoadBalancerPoolMember(singleton);
 210                     if (status < 200 || status > 299) {
 211                         return Response.status(status).build();
 212                     }
 213                 }
 214             } else {
 215                 throw new ServiceUnavailableException("No providers registered.  Please try again later");
 216             }
 217         } else {
 218             throw new ServiceUnavailableException("Couldn't get providers list.  Please try again later");
 219         }
 220
 221         if (instances != null) {
 222             for (Object instance : instances) {
 223                 INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 224                 service.neutronLoadBalancerPoolMemberCreated(singleton);
 225             }
 226         }
 227
 228         /**
 229          * Add the member from the neutron load balancer pool as well
 230          */
 231         singletonPool.addLoadBalancerPoolMember(singleton);
 232
 233     } else {
 234         List<NeutronLoadBalancerPoolMember> bulk = input.getBulk();
 235         Iterator<NeutronLoadBalancerPoolMember> i = bulk.iterator();
 236         HashMap<String, NeutronLoadBalancerPoolMember> testMap = new HashMap<String, NeutronLoadBalancerPoolMember>();
 237         Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolMemberAware.class, this);
 238         while (i.hasNext()) {
 239             NeutronLoadBalancerPoolMember test = i.next();
 240             String loadBalancerPoolMemberUUID = test.getPoolMemberID();
 241
 242             /*
 243              *  Verify that the LoadBalancerPoolMember doesn't already exist.
 244              */
 245             List<NeutronLoadBalancerPoolMember> members = singletonPool.getLoadBalancerPoolMembers();
 246             for (NeutronLoadBalancerPoolMember member: members) {
 247                 if (member.getPoolMemberID().equals(loadBalancerPoolMemberUUID))
 248                     throw new BadRequestException("LoadBalancerPoolMember UUID already exists");
 249             }
 250
 251             if (testMap.containsKey(test.getPoolMemberID())) {
 252                 throw new BadRequestException("Load Balancer PoolMember UUID already exists");
 253             }
 254             if (instances != null) {
 255                 if (instances.length > 0) {
 256                     for (Object instance : instances) {
 257                         INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 258                         int status = service.canCreateNeutronLoadBalancerPoolMember(test);
 259                         if (status < 200 || status > 299) {
 260                             return Response.status(status).build();
 261                         }
 262                     }
 263                 } else {
 264                     throw new ServiceUnavailableException("No providers registered.  Please try again later");
 265                 }
 266             } else {
 267                 throw new ServiceUnavailableException("Couldn't get providers list.  Please try again later");
 268             }
 269         }
 270         /*
 271          * now, each element of the bulk request can be added to the cache
 272          */
 273         i = bulk.iterator();
 274         while (i.hasNext()) {
 275             NeutronLoadBalancerPoolMember test = i.next();
 276             if (instances != null) {
 277                 for (Object instance : instances) {
 278                     INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 279                     service.neutronLoadBalancerPoolMemberCreated(test);
 280                 }
 281             }
 282             singletonPool.addLoadBalancerPoolMember(test);
 283         }
 284     }
 285     return Response.status(201).entity(input).build();
 286 }
 287
 288 /**
 289  * Updates a LB member pool
 290  */
 291
 292 @Path("{loadBalancerPoolMemberUUID}")
 293 @PUT
 294 @Produces({ MediaType.APPLICATION_JSON })
 295 @Consumes({ MediaType.APPLICATION_JSON })
 296 @StatusCodes({
 297         @ResponseCode(code = 200, condition = "Operation successful"),
 298         @ResponseCode(code = 400, condition = "Bad Request"),
 299         @ResponseCode(code = 401, condition = "Unauthorized"),
 300         @ResponseCode(code = 403, condition = "Forbidden"),
 301         @ResponseCode(code = 404, condition = "Not Found"),
 302         @ResponseCode(code = 501, condition = "Not Implemented") })
 303 public Response updateLoadBalancerPoolMember(
 304         @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 305         @PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID,
 306         final NeutronLoadBalancerPoolMemberRequest input) {
 307
 308     //TODO: Implement update LB member pool
 309     return Response.status(501).entity(input).build();
 310 }
 311
 312 /**
 313  * Deletes a LoadBalancerPoolMember
 314  */
 315
 316 @Path("{loadBalancerPoolMemberUUID}")
 317 @DELETE
 318 @StatusCodes({
 319     @ResponseCode(code = 204, condition = "No Content"),
 320     @ResponseCode(code = 401, condition = "Unauthorized"),
 321     @ResponseCode(code = 403, condition = "Forbidden"),
 322     @ResponseCode(code = 404, condition = "Not Found"),
 323     @ResponseCode(code = 501, condition = "Not Implemented"),
 324     @ResponseCode(code = 503, condition = "No providers available") })
 325 public Response deleteLoadBalancerPoolMember(
 326         @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 327         @PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID) {
 328     INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = NeutronCRUDInterfaces.getINeutronLoadBalancerPoolCRUD(this);
 329     if (loadBalancerPoolInterface == null) {
 330         throw new ServiceUnavailableException("LoadBalancerPool CRUD Interface "
 331                 + RestMessages.SERVICEUNAVAILABLE.toString());
 332     }
 333
 334     // Verify that the loadBalancerPool exists, for the member to be removed from its cache
 335     if (!loadBalancerPoolInterface.neutronLoadBalancerPoolExists(loadBalancerPoolUUID)) {
 336         throw new ResourceNotFoundException("loadBalancerPool UUID does not exist.");
 337     }
 338
 339     //Verify that the LB pool member exists
 340     NeutronLoadBalancerPoolMember singleton = null;
 341     List<NeutronLoadBalancerPoolMember> members =
 342             loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID).getLoadBalancerPoolMembers();
 343     for (NeutronLoadBalancerPoolMember member: members) {
 344         if (member.getPoolMemberID().equals(loadBalancerPoolMemberUUID)) {
 345             singleton = member;
 346             break;
 347         }
 348     }
 349     if (singleton == null)
 350         throw new BadRequestException("LoadBalancerPoolMember UUID does not exist.");
 351
 352     Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolMemberAware.class, this);
 353     if (instances != null) {
 354         if (instances.length > 0) {
 355             for (Object instance : instances) {
 356                 INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 357                 int status = service.canDeleteNeutronLoadBalancerPoolMember(singleton);
 358                 if (status < 200 || status > 299) {
 359                     return Response.status(status).build();
 360                 }
 361             }
 362         } else {
 363             throw new ServiceUnavailableException("No providers registered.  Please try again later");
 364         }
 365     } else {
 366         throw new ServiceUnavailableException("Couldn't get providers list.  Please try again later");
 367     }
 368
 369     if (instances != null) {
 370         for (Object instance : instances) {
 371             INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
 372             service.neutronLoadBalancerPoolMemberDeleted(singleton);
 373         }
 374     }
 375
 376     /**
 377      * Remove the member from the neutron load balancer pool
 378      */
 379     NeutronLoadBalancerPool singletonPool = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID);
 380     singletonPool.removeLoadBalancerPoolMember(singleton);
 381
 382     return Response.status(204).build();
 383 }
 384 }