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