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
   9 package org.opendaylight.neutron.northbound.api;
  10
  11 import java.net.HttpURLConnection;
  12
  13 import java.util.ArrayList;
  14 import java.util.Iterator;
  15 import java.util.List;
  16
  17 import javax.ws.rs.Consumes;
  18 import javax.ws.rs.DELETE;
  19 import javax.ws.rs.GET;
  20 import javax.ws.rs.POST;
  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.NeutronCRUDInterfaces;
  33 import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
  34 import org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember;
  35
  36 /**
  37  * Neutron Northbound REST APIs for LoadBalancerPool Policies.<br>
  38  * This class provides REST APIs for managing neutron LoadBalancerPool Policies
  39  *
  40  * <br>
  41  * <br>
  42  * Authentication scheme : <b>HTTP Basic</b><br>
  43  * Authentication realm : <b>opendaylight</b><br>
  44  * Transport : <b>HTTP and HTTPS</b><br>
  45  * <br>
  46  * HTTPS Authentication is disabled by default. Administrator can enable it in
  47  * tomcat-server.xml after adding a proper keystore / SSL certificate from a
  48  * trusted authority.<br>
  49  * More info :
  50  * http://tomcat.apache.org/tomcat-7.0-doc/ssl-howto.html#Configuration
  51  *
  52  */
  53
  54 /**
  55  * For now, the LB pool member data is maintained with the INeutronLoadBalancerPoolCRUD,
  56  * and not duplicated within the INeutronLoadBalancerPoolMemberCRUD's cache.
  57  */
  58
  59 @Path("/lbaas/pools")
  60 public class NeutronLoadBalancerPoolNorthbound
  61     extends AbstractNeutronNorthbound<NeutronLoadBalancerPool, NeutronLoadBalancerPoolRequest, INeutronLoadBalancerPoolCRUD> {
  62
  63     private static final String RESOURCE_NAME = "LoadBalancerPool";
  64
  65     @Override
  66     protected String getResourceName() {
  67         return RESOURCE_NAME;
  68     }
  69
  70     @Override
  71     protected NeutronLoadBalancerPool extractFields(NeutronLoadBalancerPool o, List<String> fields) {
  72         return o.extractFields(fields);
  73     }
  74
  75     @Override
  76     protected NeutronLoadBalancerPoolRequest newNeutronRequest(NeutronLoadBalancerPool o) {
  77         return new NeutronLoadBalancerPoolRequest(o);
  78     }
  79
  80     @Override
  81     protected INeutronLoadBalancerPoolCRUD getNeutronCRUD() {
  82         NeutronCRUDInterfaces answer = new NeutronCRUDInterfaces().
  83             fetchINeutronLoadBalancerPoolCRUD(this);
  84         if (answer.getLoadBalancerPoolInterface() == null) {
  85             throw new ServiceUnavailableException(serviceUnavailable());
  86         }
  87         return answer.getLoadBalancerPoolInterface();
  88     }
  89
  90     /**
  91      * Returns a list of all LoadBalancerPool
  92      * */
  93     @GET
  94     @Produces({ MediaType.APPLICATION_JSON })
  95     @StatusCodes({
  96             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
  97             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
  98             @ResponseCode(code = HttpURLConnection.HTTP_NOT_IMPLEMENTED, condition = "Not Implemented"),
  99             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 100
 101     public Response listGroups(
 102             // return fields
 103             @QueryParam("fields") List<String> fields,
 104             // OpenStack LoadBalancerPool attributes
 105             @QueryParam("id") String queryLoadBalancerPoolID,
 106             @QueryParam("tenant_id") String queryLoadBalancerPoolTenantID,
 107             @QueryParam("name") String queryLoadBalancerPoolName,
 108             @QueryParam("protocol") String queryLoadBalancerProtocol,
 109             @QueryParam("lb_algorithm") String queryLoadBalancerPoolLbAlgorithm,
 110             @QueryParam("healthmonitor_id") String queryLoadBalancerPoolHealthMonitorID,
 111             @QueryParam("admin_state_up") Boolean queryLoadBalancerIsAdminStateUp,
 112             @QueryParam("members") List<NeutronLoadBalancerPoolMember> queryLoadBalancerPoolMembers,
 113             // pagination
 114             @QueryParam("limit") String limit,
 115             @QueryParam("marker") String marker,
 116             @QueryParam("page_reverse") String pageReverse
 117             // sorting not supported
 118     ) {
 119         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
 120         List<NeutronLoadBalancerPool> allLoadBalancerPools = loadBalancerPoolInterface.getAllNeutronLoadBalancerPools();
 121         List<NeutronLoadBalancerPool> ans = new ArrayList<NeutronLoadBalancerPool>();
 122         Iterator<NeutronLoadBalancerPool> i = allLoadBalancerPools.iterator();
 123         while (i.hasNext()) {
 124             NeutronLoadBalancerPool nsg = i.next();
 125             if ((queryLoadBalancerPoolID == null ||
 126                     queryLoadBalancerPoolID.equals(nsg.getID())) &&
 127                     (queryLoadBalancerPoolTenantID == null ||
 128                             queryLoadBalancerPoolTenantID.equals(nsg.getTenantID())) &&
 129                     (queryLoadBalancerPoolName == null ||
 130                             queryLoadBalancerPoolName.equals(nsg.getLoadBalancerPoolName())) &&
 131                     (queryLoadBalancerPoolLbAlgorithm == null ||
 132                             queryLoadBalancerPoolLbAlgorithm.equals(nsg.getLoadBalancerPoolLbAlgorithm())) &&
 133                     (queryLoadBalancerPoolHealthMonitorID == null ||
 134                             queryLoadBalancerPoolHealthMonitorID.equals(nsg.getNeutronLoadBalancerPoolHealthMonitorID())) &&
 135                     (queryLoadBalancerIsAdminStateUp == null ||
 136                             queryLoadBalancerIsAdminStateUp.equals(nsg.getLoadBalancerPoolAdminIsStateIsUp())) &&
 137                     (queryLoadBalancerPoolMembers.size() == 0 ||
 138                             queryLoadBalancerPoolMembers.equals(nsg.getLoadBalancerPoolMembers()))) {
 139                 if (fields.size() > 0) {
 140                     ans.add(extractFields(nsg,fields));
 141                 } else {
 142                     ans.add(nsg);
 143                 }
 144             }
 145         }
 146         return Response.status(HttpURLConnection.HTTP_OK).entity(
 147                 new NeutronLoadBalancerPoolRequest(ans)).build();
 148     }
 149
 150     /**
 151      * Returns a specific LoadBalancerPool */
 152
 153     @Path("{loadBalancerPoolID}")
 154     @GET
 155     @Produces({ MediaType.APPLICATION_JSON })
 156     @StatusCodes({
 157             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 158             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 159             @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 160             @ResponseCode(code = HttpURLConnection.HTTP_NOT_IMPLEMENTED, condition = "Not Implemented"),
 161             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 162     public Response showLoadBalancerPool(@PathParam("loadBalancerPoolID") String loadBalancerPoolID,
 163             // return fields
 164             @QueryParam("fields") List<String> fields) {
 165         return show(loadBalancerPoolID, fields);
 166     }
 167
 168     /**
 169      * Creates new LoadBalancerPool */
 170
 171     @POST
 172     @Produces({ MediaType.APPLICATION_JSON })
 173     @Consumes({ MediaType.APPLICATION_JSON })
 174     @StatusCodes({
 175             @ResponseCode(code = HttpURLConnection.HTTP_CREATED, condition = "Created"),
 176             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 177     public Response createLoadBalancerPools(final NeutronLoadBalancerPoolRequest input) {
 178         return create(input);
 179     }
 180
 181     /**
 182      * Updates a LoadBalancerPool Policy
 183      */
 184     @Path("{loadBalancerPoolID}")
 185     @PUT
 186     @Produces({ MediaType.APPLICATION_JSON })
 187     @Consumes({ MediaType.APPLICATION_JSON })
 188     @StatusCodes({
 189             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 190             @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 191             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 192     public Response updateLoadBalancerPool(
 193             @PathParam("loadBalancerPoolID") String loadBalancerPoolID, final NeutronLoadBalancerPoolRequest input) {
 194         return update(loadBalancerPoolID, input);
 195     }
 196
 197     /**
 198      * Deletes a LoadBalancerPool
 199      */
 200
 201     @Path("{loadBalancerPoolUUID}")
 202     @DELETE
 203     @StatusCodes({
 204             @ResponseCode(code = HttpURLConnection.HTTP_NO_CONTENT, condition = "No Content"),
 205             @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 206             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 207     public Response deleteLoadBalancerPool(
 208             @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID) {
 209         return delete(loadBalancerPoolUUID);
 210     }
 211
 212     protected NeutronLoadBalancerPoolMember extractFields(NeutronLoadBalancerPoolMember o, List<String> fields) {
 213         return o.extractFields(fields);
 214     }
 215
 216     /**
 217      * Returns a list of all LoadBalancerPoolMembers in specified pool
 218      */
 219     @Path("{loadBalancerPoolUUID}/members")
 220     @GET
 221     @Produces({MediaType.APPLICATION_JSON})
 222     @StatusCodes({
 223             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 224             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 225             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 226     public Response listMembers(
 227             //Path param
 228             @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 229
 230             // return fields
 231             @QueryParam("fields") List<String> fields,
 232
 233             // OpenStack LoadBalancerPool attributes
 234             @QueryParam("id") String queryLoadBalancerPoolMemberID,
 235             @QueryParam("tenant_id") String queryLoadBalancerPoolMemberTenantID,
 236             @QueryParam("address") String queryLoadBalancerPoolMemberAddress,
 237             @QueryParam("protocol_port") String queryLoadBalancerPoolMemberProtoPort,
 238             @QueryParam("admin_state_up") Boolean queryLoadBalancerPoolMemberAdminStateUp,
 239             @QueryParam("weight") Integer queryLoadBalancerPoolMemberWeight,
 240             @QueryParam("subnet_id") String queryLoadBalancerPoolMemberSubnetID,
 241
 242             // pagination
 243             @QueryParam("limit") String limit,
 244             @QueryParam("marker") String marker,
 245             @QueryParam("page_reverse") String pageReverse
 246             // sorting not supported
 247     ) {
 248         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
 249         if (!loadBalancerPoolInterface.neutronLoadBalancerPoolExists(loadBalancerPoolUUID)) {
 250             throw new ResourceNotFoundException(uuidNoExist());
 251         }
 252         List<NeutronLoadBalancerPoolMember> members =
 253                     loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID).getLoadBalancerPoolMembers();
 254         List<NeutronLoadBalancerPoolMember> ans = new ArrayList<NeutronLoadBalancerPoolMember>();
 255         Iterator<NeutronLoadBalancerPoolMember> i = members.iterator();
 256         while (i.hasNext()) {
 257             NeutronLoadBalancerPoolMember nsg = i.next();
 258             if ((queryLoadBalancerPoolMemberID == null ||
 259                 queryLoadBalancerPoolMemberID.equals(nsg.getID())) &&
 260                 loadBalancerPoolUUID.equals(nsg.getPoolID()) &&
 261                 (queryLoadBalancerPoolMemberTenantID == null ||
 262                         queryLoadBalancerPoolMemberTenantID.equals(nsg.getTenantID())) &&
 263                 (queryLoadBalancerPoolMemberAddress == null ||
 264                         queryLoadBalancerPoolMemberAddress.equals(nsg.getPoolMemberAddress())) &&
 265                 (queryLoadBalancerPoolMemberAdminStateUp == null ||
 266                         queryLoadBalancerPoolMemberAdminStateUp.equals(nsg.getPoolMemberAdminStateIsUp())) &&
 267                 (queryLoadBalancerPoolMemberWeight == null ||
 268                         queryLoadBalancerPoolMemberWeight.equals(nsg.getPoolMemberWeight())) &&
 269                 (queryLoadBalancerPoolMemberSubnetID == null ||
 270                         queryLoadBalancerPoolMemberSubnetID.equals(nsg.getPoolMemberSubnetID()))) {
 271                 if (fields.size() > 0) {
 272                     ans.add(extractFields(nsg, fields));
 273                 } else {
 274                     ans.add(nsg);
 275                 }
 276             }
 277         }
 278         return Response.status(HttpURLConnection.HTTP_OK).entity(
 279                 new NeutronLoadBalancerPoolMemberRequest(ans)).build();
 280     }
 281
 282     /**
 283      * Returns a specific LoadBalancerPoolMember
 284      */
 285     @Path("{loadBalancerPoolUUID}/members/{loadBalancerPoolMemberUUID}")
 286     @GET
 287     @Produces({ MediaType.APPLICATION_JSON })
 288     //@TypeHint(OpenStackLoadBalancerPoolMembers.class)
 289     @StatusCodes({
 290         @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 291         @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 292         @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 293         @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 294     public Response showLoadBalancerPoolMember(
 295             @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 296             @PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID,
 297             // return fields
 298             @QueryParam("fields") List<String> fields ) {
 299
 300         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
 301         if (!loadBalancerPoolInterface.neutronLoadBalancerPoolExists(loadBalancerPoolUUID)) {
 302             throw new ResourceNotFoundException(uuidNoExist());
 303         }
 304         List<NeutronLoadBalancerPoolMember> members =
 305                     loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID).getLoadBalancerPoolMembers();
 306         for (NeutronLoadBalancerPoolMember ans: members) {
 307             if (!ans.getID().equals(loadBalancerPoolMemberUUID)) {
 308                 continue;
 309             }
 310
 311             if (fields.size() > 0) {
 312                 return Response.status(HttpURLConnection.HTTP_OK).entity(
 313                     new NeutronLoadBalancerPoolMemberRequest(extractFields(ans, fields))).build();
 314             } else {
 315                 return Response.status(HttpURLConnection.HTTP_OK).entity(
 316                     new NeutronLoadBalancerPoolMemberRequest(ans)).build();
 317             }
 318         }
 319         throw new ResourceNotFoundException(uuidNoExist());
 320     }
 321
 322     /**
 323      * Adds a Member to an LBaaS Pool member
 324      */
 325     @Path("{loadBalancerPoolUUID}/members")
 326     @POST
 327     @Produces({MediaType.APPLICATION_JSON})
 328     @Consumes({MediaType.APPLICATION_JSON})
 329     @StatusCodes({
 330             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 331             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 332     public Response createLoadBalancerPoolMember(
 333             @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 334             final NeutronLoadBalancerPoolMemberRequest input) {
 335
 336         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
 337         NeutronLoadBalancerPool singletonPool = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID);
 338
 339         if (input.isSingleton()) {
 340             NeutronLoadBalancerPoolMember singleton = input.getSingleton();
 341             singleton.setPoolID(loadBalancerPoolUUID);
 342             /**
 343              * Add the member from the neutron load balancer pool as well
 344              */
 345
 346             loadBalancerPoolInterface.addNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, singleton);
 347         } else {
 348             /*
 349              * now, each element of the bulk request can be added to the cache
 350              */
 351             for (NeutronLoadBalancerPoolMember test : input.getBulk()) {
 352                 loadBalancerPoolInterface.addNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, test);
 353             }
 354         }
 355         return Response.status(HttpURLConnection.HTTP_CREATED).entity(input).build();
 356     }
 357
 358     /**
 359      * Updates a LB member pool
 360      */
 361
 362     @Path("{loadBalancerPoolUUID}/members/{loadBalancerPoolMemberUUID}")
 363     @PUT
 364     @Produces({ MediaType.APPLICATION_JSON })
 365     @Consumes({ MediaType.APPLICATION_JSON })
 366     @StatusCodes({
 367             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 368             @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found") })
 369     public Response updateLoadBalancerPoolMember(
 370             @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 371             @PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID,
 372             final NeutronLoadBalancerPoolMemberRequest input) {
 373         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
 374         NeutronLoadBalancerPool singletonPool = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID);
 375         NeutronLoadBalancerPoolMember singleton = input.getSingleton();
 376         singleton.setPoolID(loadBalancerPoolUUID);
 377
 378         if (singletonPool == null) {
 379             throw new ResourceNotFoundException("Pool doesn't Exist");
 380         }
 381         NeutronLoadBalancerPoolMember original = singletonPool.getNeutronLoadBalancerPoolMember(loadBalancerPoolMemberUUID);
 382
 383         loadBalancerPoolInterface.updateNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, loadBalancerPoolMemberUUID, singleton);
 384         return Response.status(HttpURLConnection.HTTP_OK).entity(input).build();
 385     }
 386
 387     /**
 388      * Deletes a LoadBalancerPoolMember
 389      */
 390
 391     @Path("{loadBalancerPoolUUID}/members/{loadBalancerPoolMemberUUID}")
 392     @DELETE
 393     @StatusCodes({
 394         @ResponseCode(code = HttpURLConnection.HTTP_NO_CONTENT, condition = "No Content"),
 395         @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 396         @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 397     public Response deleteLoadBalancerPoolMember(
 398             @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
 399             @PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID) {
 400         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
 401
 402         //Verify that the LB pool member exists
 403         NeutronLoadBalancerPoolMember singleton = null;
 404         List<NeutronLoadBalancerPoolMember> members =
 405                 loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID).getLoadBalancerPoolMembers();
 406         for (NeutronLoadBalancerPoolMember member: members) {
 407             if (member.getID().equals(loadBalancerPoolMemberUUID)) {
 408                 singleton = member;
 409                 break;
 410             }
 411         }
 412         if (singleton == null) {
 413             throw new BadRequestException("LoadBalancerPoolMember UUID does not exist.");
 414         }
 415
 416         /**
 417          * Remove the member from the neutron load balancer pool
 418          */
 419         loadBalancerPoolInterface.removeNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, loadBalancerPoolMemberUUID);
 420
 421         return Response.status(HttpURLConnection.HTTP_NO_CONTENT).build();
 422     }
 423 }