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