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