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