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.INeutronLoadBalancerPoolAware;
  32 import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolCRUD;
  33 import org.opendaylight.neutron.spi.NeutronCRUDInterfaces;
  34 import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
  35 import org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember;
  36
  37 /**
  38  * Neutron Northbound REST APIs for LoadBalancerPool Policies.<br>
  39  * This class provides REST APIs for managing neutron LoadBalancerPool Policies
  40  *
  41  * <br>
  42  * <br>
  43  * Authentication scheme : <b>HTTP Basic</b><br>
  44  * Authentication realm : <b>opendaylight</b><br>
  45  * Transport : <b>HTTP and HTTPS</b><br>
  46  * <br>
  47  * HTTPS Authentication is disabled by default. Administrator can enable it in
  48  * tomcat-server.xml after adding a proper keystore / SSL certificate from a
  49  * trusted authority.<br>
  50  * More info :
  51  * http://tomcat.apache.org/tomcat-7.0-doc/ssl-howto.html#Configuration
  52  *
  53  */
  54
  55 /**
  56  * For now, the LB pool member data is maintained with the INeutronLoadBalancerPoolCRUD,
  57  * and not duplicated within the INeutronLoadBalancerPoolMemberCRUD's cache.
  58  */
  59
  60 @Path("/lbaas/pools")
  61 public class NeutronLoadBalancerPoolNorthbound {
  62
  63     private static final int HTTP_OK_BOTTOM = 200;
  64     private static final int HTTP_OK_TOP = 299;
  65     private static final String INTERFACE_NAME = "LoadBalancerPool CRUD Interface";
  66     private static final String UUID_NO_EXIST = "LoadBalancerPool UUID does not exist.";
  67     private static final String NO_PROVIDERS = "No providers registered.  Please try again later";
  68     private static final String NO_PROVIDER_LIST = "Couldn't get providers list.  Please try again later";
  69
  70     private NeutronLoadBalancerPool extractFields(NeutronLoadBalancerPool o, List<String> fields) {
  71         return o.extractFields(fields);
  72     }
  73
  74     private NeutronCRUDInterfaces getNeutronInterfaces() {
  75         NeutronCRUDInterfaces answer = new NeutronCRUDInterfaces().fetchINeutronLoadBalancerPoolCRUD(this);
  76         if (answer.getLoadBalancerPoolInterface() == null) {
  77             throw new ServiceUnavailableException(INTERFACE_NAME
  78                     + RestMessages.SERVICEUNAVAILABLE.toString());
  79         }
  80         return answer;
  81     }
  82
  83     /**
  84      * Returns a list of all LoadBalancerPool
  85      * */
  86     @GET
  87     @Produces({ MediaType.APPLICATION_JSON })
  88     @StatusCodes({
  89             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
  90             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
  91             @ResponseCode(code = HttpURLConnection.HTTP_NOT_IMPLEMENTED, condition = "Not Implemented"),
  92             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
  93
  94     public Response listGroups(
  95             // return fields
  96             @QueryParam("fields") List<String> fields,
  97             // OpenStack LoadBalancerPool attributes
  98             @QueryParam("id") String queryLoadBalancerPoolID,
  99             @QueryParam("tenant_id") String queryLoadBalancerPoolTenantID,
 100             @QueryParam("name") String queryLoadBalancerPoolName,
 101             @QueryParam("description") String queryLoadBalancerDescription,
 102             @QueryParam("protocol") String queryLoadBalancerProtocol,
 103             @QueryParam("lb_algorithm") String queryLoadBalancerPoolLbAlgorithm,
 104             @QueryParam("healthmonitor_id") String queryLoadBalancerPoolHealthMonitorID,
 105             @QueryParam("admin_state_up") String queryLoadBalancerIsAdminStateUp,
 106             @QueryParam("members") List<NeutronLoadBalancerPoolMember> queryLoadBalancerPoolMembers,
 107             // pagination
 108             @QueryParam("limit") String limit,
 109             @QueryParam("marker") String marker,
 110             @QueryParam("page_reverse") String pageReverse
 111             // sorting not supported
 112     ) {
 113         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 114         List<NeutronLoadBalancerPool> allLoadBalancerPools = loadBalancerPoolInterface.getAllNeutronLoadBalancerPools();
 115         List<NeutronLoadBalancerPool> ans = new ArrayList<NeutronLoadBalancerPool>();
 116         Iterator<NeutronLoadBalancerPool> i = allLoadBalancerPools.iterator();
 117         while (i.hasNext()) {
 118             NeutronLoadBalancerPool nsg = i.next();
 119             if ((queryLoadBalancerPoolID == null ||
 120                     queryLoadBalancerPoolID.equals(nsg.getID())) &&
 121                     (queryLoadBalancerPoolTenantID == null ||
 122                             queryLoadBalancerPoolTenantID.equals(nsg.getLoadBalancerPoolTenantID())) &&
 123                     (queryLoadBalancerPoolName == null ||
 124                             queryLoadBalancerPoolName.equals(nsg.getLoadBalancerPoolName())) &&
 125                     (queryLoadBalancerDescription == null ||
 126                             queryLoadBalancerDescription.equals(nsg.getLoadBalancerPoolDescription())) &&
 127                     (queryLoadBalancerPoolLbAlgorithm == null ||
 128                             queryLoadBalancerPoolLbAlgorithm.equals(nsg.getLoadBalancerPoolLbAlgorithm())) &&
 129                     (queryLoadBalancerPoolHealthMonitorID == null ||
 130                             queryLoadBalancerPoolHealthMonitorID.equals(nsg.getNeutronLoadBalancerPoolHealthMonitorID())) &&
 131                     (queryLoadBalancerIsAdminStateUp == null ||
 132                             queryLoadBalancerIsAdminStateUp.equals(nsg.getLoadBalancerPoolAdminIsStateIsUp())) &&
 133                     (queryLoadBalancerPoolMembers.size() == 0 ||
 134                             queryLoadBalancerPoolMembers.equals(nsg.getLoadBalancerPoolMembers()))) {
 135                 if (fields.size() > 0) {
 136                     ans.add(extractFields(nsg,fields));
 137                 } else {
 138                     ans.add(nsg);
 139                 }
 140             }
 141         }
 142         return Response.status(HttpURLConnection.HTTP_OK).entity(
 143                 new NeutronLoadBalancerPoolRequest(ans)).build();
 144     }
 145
 146     /**
 147      * Returns a specific LoadBalancerPool */
 148
 149     @Path("{loadBalancerPoolID}")
 150     @GET
 151     @Produces({ MediaType.APPLICATION_JSON })
 152     @StatusCodes({
 153             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 154             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 155             @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 156             @ResponseCode(code = HttpURLConnection.HTTP_NOT_IMPLEMENTED, condition = "Not Implemented"),
 157             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 158     public Response showLoadBalancerPool(@PathParam("loadBalancerPoolID") String loadBalancerPoolID,
 159             // return fields
 160             @QueryParam("fields") List<String> fields) {
 161         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 162         if (!loadBalancerPoolInterface.neutronLoadBalancerPoolExists(loadBalancerPoolID)) {
 163             throw new ResourceNotFoundException(UUID_NO_EXIST);
 164         }
 165         if (fields.size() > 0) {
 166             NeutronLoadBalancerPool ans = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolID);
 167             return Response.status(HttpURLConnection.HTTP_OK).entity(
 168                     new NeutronLoadBalancerPoolRequest(extractFields(ans, fields))).build();
 169         } else {
 170             return Response.status(HttpURLConnection.HTTP_OK).entity(new NeutronLoadBalancerPoolRequest(loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolID))).build();
 171         }
 172     }
 173
 174     /**
 175      * Creates new LoadBalancerPool */
 176
 177     @POST
 178     @Produces({ MediaType.APPLICATION_JSON })
 179     @Consumes({ MediaType.APPLICATION_JSON })
 180     @StatusCodes({
 181             @ResponseCode(code = HttpURLConnection.HTTP_CREATED, condition = "Created"),
 182             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 183     public Response createLoadBalancerPools(final NeutronLoadBalancerPoolRequest input) {
 184         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 185         if (input.isSingleton()) {
 186             NeutronLoadBalancerPool singleton = input.getSingleton();
 187
 188             Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolAware.class, this);
 189             if (instances != null) {
 190                 if (instances.length > 0) {
 191                     for (Object instance : instances) {
 192                         INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
 193                         int status = service.canCreateNeutronLoadBalancerPool(singleton);
 194                         if (status < HttpURLConnection.HTTP_OK || status > HTTP_OK_TOP) {
 195                             return Response.status(status).build();
 196                         }
 197                     }
 198                 } else {
 199                     throw new ServiceUnavailableException(NO_PROVIDERS);
 200                 }
 201             } else {
 202                 throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 203             }
 204             loadBalancerPoolInterface.addNeutronLoadBalancerPool(singleton);
 205             if (instances != null) {
 206                 for (Object instance : instances) {
 207                     INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
 208                     service.neutronLoadBalancerPoolCreated(singleton);
 209                 }
 210             }
 211         } else {
 212             Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolAware.class, this);
 213             for (NeutronLoadBalancerPool test : input.getBulk()) {
 214
 215                 if (instances != null) {
 216                     if (instances.length > 0) {
 217                         for (Object instance : instances) {
 218                             INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
 219                             int status = service.canCreateNeutronLoadBalancerPool(test);
 220                             if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 221                                 return Response.status(status).build();
 222                             }
 223                         }
 224                     } else {
 225                         throw new ServiceUnavailableException(NO_PROVIDERS);
 226                     }
 227                 } else {
 228                     throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 229                 }
 230             }
 231             /*
 232              * now, each element of the bulk request can be added to the cache
 233              */
 234             for (NeutronLoadBalancerPool test : input.getBulk()) {
 235                 loadBalancerPoolInterface.addNeutronLoadBalancerPool(test);
 236                 if (instances != null) {
 237                     for (Object instance : instances) {
 238                         INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
 239                         service.neutronLoadBalancerPoolCreated(test);
 240                     }
 241                 }
 242             }
 243         }
 244         return Response.status(HttpURLConnection.HTTP_CREATED).entity(input).build();
 245     }
 246
 247     /**
 248      * Updates a LoadBalancerPool Policy
 249      */
 250     @Path("{loadBalancerPoolID}")
 251     @PUT
 252     @Produces({ MediaType.APPLICATION_JSON })
 253     @Consumes({ MediaType.APPLICATION_JSON })
 254     @StatusCodes({
 255             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 256             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 257     public Response updateLoadBalancerPool(
 258             @PathParam("loadBalancerPoolID") String loadBalancerPoolID, final NeutronLoadBalancerPoolRequest input) {
 259         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 260
 261         NeutronLoadBalancerPool delta = input.getSingleton();
 262         NeutronLoadBalancerPool original = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolID);
 263
 264         Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolAware.class, this);
 265         if (instances != null) {
 266             if (instances.length > 0) {
 267                 for (Object instance : instances) {
 268                     INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
 269                     int status = service.canUpdateNeutronLoadBalancerPool(delta, original);
 270                     if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 271                         return Response.status(status).build();
 272                     }
 273                 }
 274             } else {
 275                 throw new ServiceUnavailableException(NO_PROVIDERS);
 276             }
 277         } else {
 278             throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 279         }
 280
 281         /*
 282          * update the object and return it
 283          */
 284         loadBalancerPoolInterface.updateNeutronLoadBalancerPool(loadBalancerPoolID, delta);
 285         NeutronLoadBalancerPool updatedLoadBalancerPool = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolID);
 286         if (instances != null) {
 287             for (Object instance : instances) {
 288                 INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
 289                 service.neutronLoadBalancerPoolUpdated(updatedLoadBalancerPool);
 290             }
 291         }
 292         return Response.status(HttpURLConnection.HTTP_OK).entity(new NeutronLoadBalancerPoolRequest(loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolID))).build();
 293     }
 294
 295     /**
 296      * Deletes a LoadBalancerPool
 297      */
 298
 299     @Path("{loadBalancerPoolUUID}")
 300     @DELETE
 301     @StatusCodes({
 302             @ResponseCode(code = HttpURLConnection.HTTP_NO_CONTENT, condition = "No Content"),
 303             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 304     public Response deleteLoadBalancerPool(
 305             @PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID) {
 306         INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
 307
 308         NeutronLoadBalancerPool singleton = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID);
 309         Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolAware.class, this);
 310         if (instances != null) {
 311             if (instances.length > 0) {
 312                 for (Object instance : instances) {
 313                     INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
 314                     int status = service.canDeleteNeutronLoadBalancerPool(singleton);
 315                     if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 316                         return Response.status(status).build();
 317                     }
 318                 }
 319             } else {
 320                 throw new ServiceUnavailableException(NO_PROVIDERS);
 321             }
 322         } else {
 323             throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 324         }
 325
 326         /*
 327          * remove it and return 204 status
 328          */
 329         loadBalancerPoolInterface.removeNeutronLoadBalancerPool(loadBalancerPoolUUID);
 330         if (instances != null) {
 331             for (Object instance : instances) {
 332                 INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
 333                 service.neutronLoadBalancerPoolDeleted(singleton);
 334             }
 335         }
 336         return Response.status(HttpURLConnection.HTTP_NO_CONTENT).build();
 337     }
 338 }