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 package org.opendaylight.neutron.northbound.api;
   9
  10 import java.net.HttpURLConnection;
  11 import java.util.ArrayList;
  12 import java.util.List;
  13 import javax.inject.Inject;
  14 import javax.inject.Singleton;
  15 import javax.ws.rs.Consumes;
  16 import javax.ws.rs.DELETE;
  17 import javax.ws.rs.GET;
  18 import javax.ws.rs.POST;
  19 import javax.ws.rs.PUT;
  20 import javax.ws.rs.Path;
  21 import javax.ws.rs.PathParam;
  22 import javax.ws.rs.Produces;
  23 import javax.ws.rs.QueryParam;
  24 import javax.ws.rs.core.MediaType;
  25 import javax.ws.rs.core.Response;
  26 import org.codehaus.enunciate.jaxrs.ResponseCode;
  27 import org.codehaus.enunciate.jaxrs.StatusCodes;
  28 import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolCRUD;
  29 import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
  30 import org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember;
  31 import org.ops4j.pax.cdi.api.OsgiService;
  32
  33 /**
  34  * Neutron Northbound REST APIs for LoadBalancerPool Policies.
  35  *
  36  * <p>For now, the LB pool member data is maintained with the INeutronLoadBalancerPoolCRUD,
  37  * and not duplicated within the INeutronLoadBalancerPoolMemberCRUD's cache.
  38  */
  39 @Singleton
  40 @Path("/lbaas/pools")
  41 public final class NeutronLoadBalancerPoolNorthbound extends AbstractNeutronNorthbound<NeutronLoadBalancerPool,
  42         NeutronLoadBalancerPoolRequest, INeutronLoadBalancerPoolCRUD> {
  43
  44     private static final String RESOURCE_NAME = "LoadBalancerPool";
  45
  46     @Inject
  47     public NeutronLoadBalancerPoolNorthbound(@OsgiService INeutronLoadBalancerPoolCRUD neutronCRUD) {
  48         super(neutronCRUD);
  49     }
  50
  51     @Override
  52     protected String getResourceName() {
  53         return RESOURCE_NAME;
  54     }
  55
  56     /**
  57      * Returns a list of all LoadBalancerPool.
  58      * */
  59     @GET
  60     @Produces({ MediaType.APPLICATION_JSON })
  61     @StatusCodes({ @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
  62             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
  63             @ResponseCode(code = HttpURLConnection.HTTP_NOT_IMPLEMENTED, condition = "Not Implemented"),
  64             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
  65     public Response listGroups(
  66             // return fields
  67             @QueryParam("fields") List<String> fields,
  68             // OpenStack LoadBalancerPool attributes
  69             @QueryParam("id") String queryLoadBalancerPoolID,
  70             @QueryParam("tenant_id") String queryLoadBalancerPoolTenantID,
  71             @QueryParam("name") String queryLoadBalancerPoolName,
  72             @QueryParam("protocol") String queryLoadBalancerProtocol,
  73             @QueryParam("lb_algorithm") String queryLoadBalancerPoolLbAlgorithm,
  74             @QueryParam("healthmonitor_id") String queryLoadBalancerPoolHealthMonitorID,
  75             @QueryParam("admin_state_up") Boolean queryLoadBalancerIsAdminStateUp,
  76             @QueryParam("members") List<NeutronLoadBalancerPoolMember> queryLoadBalancerPoolMembers,
  77             // pagination
  78             @QueryParam("limit") String limit,
  79             @QueryParam("marker") String marker,
  80             @QueryParam("page_reverse") String pageReverse
  81     // sorting not supported
  82     ) {
  83         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
  84         List<NeutronLoadBalancerPool> allLoadBalancerPools = loadBalancerPoolInterface.getAll();
  85         List<NeutronLoadBalancerPool> ans = new ArrayList<>();
  86         for (NeutronLoadBalancerPool nsg : allLoadBalancerPools) {
  87             if ((queryLoadBalancerPoolID == null || queryLoadBalancerPoolID.equals(nsg.getID()))
  88                     && (queryLoadBalancerPoolTenantID == null
  89                             || queryLoadBalancerPoolTenantID.equals(nsg.getTenantID()))
  90                     && (queryLoadBalancerPoolName == null
  91                             || queryLoadBalancerPoolName.equals(nsg.getName()))
  92                     && (queryLoadBalancerPoolLbAlgorithm == null
  93                             || queryLoadBalancerPoolLbAlgorithm.equals(nsg.getLoadBalancerPoolLbAlgorithm()))
  94                     && (queryLoadBalancerPoolHealthMonitorID == null || queryLoadBalancerPoolHealthMonitorID
  95                             .equals(nsg.getLoadBalancerPoolHealthMonitorID()))
  96                     && (queryLoadBalancerIsAdminStateUp == null
  97                             || queryLoadBalancerIsAdminStateUp.equals(nsg.getLoadBalancerPoolAdminIsStateIsUp()))
  98                     && (queryLoadBalancerPoolMembers.size() == 0
  99                             || queryLoadBalancerPoolMembers.equals(nsg.getLoadBalancerPoolMembers()))) {
 100                 if (fields.size() > 0) {
 101                     ans.add(nsg.extractFields(fields));
 102                 } else {
 103                     ans.add(nsg);
 104                 }
 105             }
 106         }
 107         return Response.status(HttpURLConnection.HTTP_OK).entity(new NeutronLoadBalancerPoolRequest(ans)).build();
 108     }
 109
 110     /**
 111      * Returns a specific LoadBalancerPool.
 112      */
 113     @Path("{loadBalancerPoolID}")
 114     @GET
 115     @Produces({ MediaType.APPLICATION_JSON })
 116     @StatusCodes({ @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 117             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 118             @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 119             @ResponseCode(code = HttpURLConnection.HTTP_NOT_IMPLEMENTED, condition = "Not Implemented"),
 120             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 121     public Response showLoadBalancerPool(@PathParam("loadBalancerPoolID") String loadBalancerPoolID,
 122             // return fields
 123             @QueryParam("fields") List<String> fields) {
 124         return show(loadBalancerPoolID, fields);
 125     }
 126
 127     /**
 128      * Creates new LoadBalancerPool.
 129      */
 130     @POST
 131     @Produces({ MediaType.APPLICATION_JSON })
 132     @Consumes({ MediaType.APPLICATION_JSON })
 133     @StatusCodes({ @ResponseCode(code = HttpURLConnection.HTTP_CREATED, condition = "Created"),
 134             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 135     public Response createLoadBalancerPools(final NeutronLoadBalancerPoolRequest input) {
 136         return create(input);
 137     }
 138
 139     /**
 140      * Updates a LoadBalancerPool Policy.
 141      */
 142     @Path("{loadBalancerPoolID}")
 143     @PUT
 144     @Produces({ MediaType.APPLICATION_JSON })
 145     @Consumes({ MediaType.APPLICATION_JSON })
 146     @StatusCodes({ @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 147             @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 148             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 149     public Response updateLoadBalancerPool(@PathParam("loadBalancerPoolID") String loadBalancerPoolID,
 150             final NeutronLoadBalancerPoolRequest input) {
 151         return update(loadBalancerPoolID, input);
 152     }
 153
 154     /**
 155      * Deletes a LoadBalancerPool.
 156      */
 157     @Path("{loadBalancerPoolUUID}")
 158     @DELETE
 159     @StatusCodes({ @ResponseCode(code = HttpURLConnection.HTTP_NO_CONTENT, condition = "No Content"),
 160             @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 161             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 162     public Response deleteLoadBalancerPool(@PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID) {
 163         return delete(loadBalancerPoolUUID);
 164     }
 165
 166     /**
 167      * Returns a list of all LoadBalancerPoolMembers in specified pool.
 168      */
 169     @Path("{loadBalancerPoolUUID}/members")
 170     @GET
 171     @Produces({ MediaType.APPLICATION_JSON })
 172     @StatusCodes({ @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 173             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 174             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 175     public Response listMembers(
 176             //Path param
 177             @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 178
 179             // return fields
 180             @QueryParam("fields") List<String> fields,
 181
 182             // OpenStack LoadBalancerPool attributes
 183             @QueryParam("id") String queryLoadBalancerPoolMemberID,
 184             @QueryParam("tenant_id") String queryLoadBalancerPoolMemberTenantID,
 185             @QueryParam("address") String queryLoadBalancerPoolMemberAddress,
 186             @QueryParam("protocol_port") String queryLoadBalancerPoolMemberProtoPort,
 187             @QueryParam("admin_state_up") Boolean queryLoadBalancerPoolMemberAdminStateUp,
 188             @QueryParam("weight") Integer queryLoadBalancerPoolMemberWeight,
 189             @QueryParam("subnet_id") String queryLoadBalancerPoolMemberSubnetID,
 190
 191             // pagination
 192             @QueryParam("limit") String limit,
 193             @QueryParam("marker") String marker,
 194             @QueryParam("page_reverse") String pageReverse
 195     // sorting not supported
 196     ) {
 197         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
 198         if (!loadBalancerPoolInterface.exists(loadBalancerPoolUUID)) {
 199             throw new ResourceNotFoundException(uuidNoExist());
 200         }
 201         List<NeutronLoadBalancerPoolMember> members = loadBalancerPoolInterface.get(loadBalancerPoolUUID)
 202                 .getLoadBalancerPoolMembers();
 203         List<NeutronLoadBalancerPoolMember> ans = new ArrayList<>();
 204         for (NeutronLoadBalancerPoolMember nsg : members) {
 205             if ((queryLoadBalancerPoolMemberID == null || queryLoadBalancerPoolMemberID.equals(nsg.getID()))
 206                     && loadBalancerPoolUUID.equals(nsg.getPoolID())
 207                     && (queryLoadBalancerPoolMemberTenantID == null
 208                             || queryLoadBalancerPoolMemberTenantID.equals(nsg.getTenantID()))
 209                     && (queryLoadBalancerPoolMemberAddress == null
 210                             || queryLoadBalancerPoolMemberAddress.equals(nsg.getPoolMemberAddress()))
 211                     && (queryLoadBalancerPoolMemberAdminStateUp == null
 212                             || queryLoadBalancerPoolMemberAdminStateUp.equals(nsg.getPoolMemberAdminStateIsUp()))
 213                     && (queryLoadBalancerPoolMemberWeight == null
 214                             || queryLoadBalancerPoolMemberWeight.equals(nsg.getPoolMemberWeight()))
 215                     && (queryLoadBalancerPoolMemberSubnetID == null
 216                             || queryLoadBalancerPoolMemberSubnetID.equals(nsg.getPoolMemberSubnetID()))) {
 217                 if (fields.size() > 0) {
 218                     ans.add(nsg.extractFields(fields));
 219                 } else {
 220                     ans.add(nsg);
 221                 }
 222             }
 223         }
 224         return Response.status(HttpURLConnection.HTTP_OK).entity(new NeutronLoadBalancerPoolMemberRequest(ans)).build();
 225     }
 226
 227     /**
 228      * Returns a specific LoadBalancerPoolMember.
 229      */
 230     @Path("{loadBalancerPoolUUID}/members/{loadBalancerPoolMemberUUID}")
 231     @GET
 232     @Produces({ MediaType.APPLICATION_JSON })
 233     //@TypeHint(OpenStackLoadBalancerPoolMembers.class)
 234     @StatusCodes({ @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 235             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 236             @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 237             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 238     public Response showLoadBalancerPoolMember(@PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 239             @PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID,
 240             // return fields
 241             @QueryParam("fields") List<String> fields) {
 242
 243         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
 244         if (!loadBalancerPoolInterface.exists(loadBalancerPoolUUID)) {
 245             throw new ResourceNotFoundException(uuidNoExist());
 246         }
 247         List<NeutronLoadBalancerPoolMember> members = loadBalancerPoolInterface.get(loadBalancerPoolUUID)
 248                 .getLoadBalancerPoolMembers();
 249         for (NeutronLoadBalancerPoolMember ans : members) {
 250             if (!ans.getID().equals(loadBalancerPoolMemberUUID)) {
 251                 continue;
 252             }
 253
 254             if (fields.size() > 0) {
 255                 return Response.status(HttpURLConnection.HTTP_OK)
 256                         .entity(new NeutronLoadBalancerPoolMemberRequest(ans.extractFields(fields))).build();
 257             } else {
 258                 return Response.status(HttpURLConnection.HTTP_OK).entity(new NeutronLoadBalancerPoolMemberRequest(ans))
 259                         .build();
 260             }
 261         }
 262         throw new ResourceNotFoundException(uuidNoExist());
 263     }
 264
 265     /**
 266      * Adds a Member to an LBaaS Pool member.
 267      */
 268     @Path("{loadBalancerPoolUUID}/members")
 269     @POST
 270     @Produces({ MediaType.APPLICATION_JSON })
 271     @Consumes({ MediaType.APPLICATION_JSON })
 272     @StatusCodes({ @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 273             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 274     public Response createLoadBalancerPoolMember(@PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 275             final NeutronLoadBalancerPoolMemberRequest input) {
 276
 277         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
 278
 279         if (input.isSingleton()) {
 280             NeutronLoadBalancerPoolMember singleton = input.getSingleton();
 281             singleton.setPoolID(loadBalancerPoolUUID);
 282             /**
 283              * Add the member from the neutron load balancer pool as well
 284              */
 285
 286             loadBalancerPoolInterface.addNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, singleton);
 287         } else {
 288             /*
 289              * now, each element of the bulk request can be added to the cache
 290              */
 291             for (NeutronLoadBalancerPoolMember test : input.getBulk()) {
 292                 loadBalancerPoolInterface.addNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, test);
 293             }
 294         }
 295         return Response.status(HttpURLConnection.HTTP_CREATED).entity(input).build();
 296     }
 297
 298     /**
 299      * Updates a LB member pool.
 300      */
 301     @Path("{loadBalancerPoolUUID}/members/{loadBalancerPoolMemberUUID}")
 302     @PUT
 303     @Produces({ MediaType.APPLICATION_JSON })
 304     @Consumes({ MediaType.APPLICATION_JSON })
 305     @StatusCodes({ @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 306             @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found") })
 307     public Response updateLoadBalancerPoolMember(@PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 308             @PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID,
 309             final NeutronLoadBalancerPoolMemberRequest input) {
 310         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
 311         NeutronLoadBalancerPool singletonPool = loadBalancerPoolInterface.get(loadBalancerPoolUUID);
 312         NeutronLoadBalancerPoolMember singleton = input.getSingleton();
 313         singleton.setPoolID(loadBalancerPoolUUID);
 314
 315         if (singletonPool == null) {
 316             throw new ResourceNotFoundException("Pool doesn't Exist");
 317         }
 318         loadBalancerPoolInterface.updateNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, loadBalancerPoolMemberUUID,
 319                 singleton);
 320         return Response.status(HttpURLConnection.HTTP_OK).entity(input).build();
 321     }
 322
 323     /**
 324      * Deletes a LoadBalancerPoolMember.
 325      */
 326     @Path("{loadBalancerPoolUUID}/members/{loadBalancerPoolMemberUUID}")
 327     @DELETE
 328     @StatusCodes({ @ResponseCode(code = HttpURLConnection.HTTP_NO_CONTENT, condition = "No Content"),
 329             @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 330             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 331     public Response deleteLoadBalancerPoolMember(@PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 332             @PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID) {
 333         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
 334
 335         //Verify that the LB pool member exists
 336         NeutronLoadBalancerPoolMember singleton = null;
 337         List<NeutronLoadBalancerPoolMember> members = loadBalancerPoolInterface.get(loadBalancerPoolUUID)
 338                 .getLoadBalancerPoolMembers();
 339         for (NeutronLoadBalancerPoolMember member : members) {
 340             if (member.getID().equals(loadBalancerPoolMemberUUID)) {
 341                 singleton = member;
 342                 break;
 343             }
 344         }
 345         if (singleton == null) {
 346             throw new BadRequestException("LoadBalancerPoolMember UUID does not exist.");
 347         }
 348
 349         /**
 350          * Remove the member from the neutron load balancer pool
 351          */
 352         loadBalancerPoolInterface.removeNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, loadBalancerPoolMemberUUID);
 353
 354         return Response.status(HttpURLConnection.HTTP_NO_CONTENT).build();
 355     }
 356 }