northbound-api/src/main/java/org/opendaylight/neutron/northbound/api/NeutronLoadBalancerHealthMonitorNorthbound.java

   1 /*
   2  * Copyright (C) 2014 Red Hat, Inc.
   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.INeutronLoadBalancerHealthMonitorAware;
  32 import org.opendaylight.neutron.spi.INeutronLoadBalancerHealthMonitorCRUD;
  33 import org.opendaylight.neutron.spi.NeutronCRUDInterfaces;
  34 import org.opendaylight.neutron.spi.NeutronLoadBalancerHealthMonitor;
  35
  36 /**
  37  * Neutron Northbound REST APIs for Load Balancer HealthMonitor.<br>
  38  * This class provides REST APIs for managing neutron LoadBalancerHealthMonitor
  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 @Path("/lbaas/healthmonitors")
  54 public class NeutronLoadBalancerHealthMonitorNorthbound {
  55
  56     private static final int HTTP_OK_BOTTOM = 200;
  57     private static final int HTTP_OK_TOP = 299;
  58     private static final String INTERFACE_NAME = "LoadBalancerHealthMonitor CRUD Interface";
  59     private static final String UUID_NO_EXIST = "LoadBalancerHealthMonitor UUID does not exist.";
  60     private static final String NO_PROVIDERS = "No providers registered.  Please try again later";
  61     private static final String NO_PROVIDER_LIST = "Couldn't get providers list.  Please try again later";
  62
  63
  64     private NeutronLoadBalancerHealthMonitor extractFields(NeutronLoadBalancerHealthMonitor o, List<String> fields) {
  65         return o.extractFields(fields);
  66     }
  67
  68     private NeutronCRUDInterfaces getNeutronInterfaces() {
  69         NeutronCRUDInterfaces answer = new NeutronCRUDInterfaces().fetchINeutronLoadBalancerHealthMonitorCRUD(this);
  70         if (answer.getLoadBalancerHealthMonitorInterface() == null) {
  71             throw new ServiceUnavailableException(INTERFACE_NAME
  72                 + RestMessages.SERVICEUNAVAILABLE.toString());
  73         }
  74         return answer;
  75     }
  76
  77     /**
  78      * Returns a list of all LoadBalancerHealthMonitor */
  79     @GET
  80     @Produces({ MediaType.APPLICATION_JSON })
  81     @StatusCodes({
  82             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
  83             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
  84             @ResponseCode(code = HttpURLConnection.HTTP_NOT_IMPLEMENTED, condition = "Not Implemented"),
  85             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
  86
  87     public Response listGroups(
  88             // return fields
  89             @QueryParam("fields") List<String> fields,
  90             // OpenStack LoadBalancerHealthMonitor attributes
  91             @QueryParam("id") String queryLoadBalancerHealthMonitorID,
  92             @QueryParam("tenant_id") String queryLoadBalancerHealthMonitorTenantID,
  93             // TODO "type" is being a property by the JSON parser.
  94             @QueryParam("type") String queryLoadBalancerHealthMonitorType,
  95             @QueryParam("delay") Integer queryLoadBalancerHealthMonitorDelay,
  96             @QueryParam("timeout") Integer queryLoadBalancerHealthMonitorTimeout,
  97             @QueryParam("max_retries") Integer queryLoadBalancerHealthMonitorMaxRetries,
  98             @QueryParam("http_method") String queryLoadBalancerHealthMonitorHttpMethod,
  99             @QueryParam("url_path") String queryLoadBalancerHealthMonitorUrlPath,
 100             @QueryParam("expected_codes") String queryLoadBalancerHealthMonitorExpectedCodes,
 101             @QueryParam("admin_state_up") Boolean queryLoadBalancerHealthMonitorIsAdminStateUp,
 102             // pagination
 103             @QueryParam("limit") String limit,
 104             @QueryParam("marker") String marker,
 105             @QueryParam("page_reverse") String pageReverse
 106             // sorting not supported
 107     ) {
 108         INeutronLoadBalancerHealthMonitorCRUD loadBalancerHealthMonitorInterface = getNeutronInterfaces().getLoadBalancerHealthMonitorInterface();
 109         List<NeutronLoadBalancerHealthMonitor> allLoadBalancerHealthMonitors = loadBalancerHealthMonitorInterface.getAllNeutronLoadBalancerHealthMonitors();
 110         List<NeutronLoadBalancerHealthMonitor> ans = new ArrayList<NeutronLoadBalancerHealthMonitor>();
 111         Iterator<NeutronLoadBalancerHealthMonitor> i = allLoadBalancerHealthMonitors.iterator();
 112         while (i.hasNext()) {
 113             NeutronLoadBalancerHealthMonitor nsg = i.next();
 114             if ((queryLoadBalancerHealthMonitorID == null ||
 115                     queryLoadBalancerHealthMonitorID.equals(nsg.getLoadBalancerHealthMonitorID())) &&
 116                     (queryLoadBalancerHealthMonitorTenantID == null ||
 117                             queryLoadBalancerHealthMonitorTenantID.equals
 118                                     (nsg.getLoadBalancerHealthMonitorTenantID())) &&
 119                     (queryLoadBalancerHealthMonitorType == null ||
 120                             queryLoadBalancerHealthMonitorType.equals
 121                                     (nsg.getLoadBalancerHealthMonitorType())) &&
 122                     (queryLoadBalancerHealthMonitorDelay == null ||
 123                             queryLoadBalancerHealthMonitorDelay.equals
 124                                     (nsg.getLoadBalancerHealthMonitorDelay())) &&
 125                     (queryLoadBalancerHealthMonitorTimeout == null ||
 126                             queryLoadBalancerHealthMonitorTimeout.equals
 127                                     (nsg.getLoadBalancerHealthMonitorTimeout())) &&
 128                     (queryLoadBalancerHealthMonitorMaxRetries == null ||
 129                             queryLoadBalancerHealthMonitorMaxRetries.equals
 130                                     (nsg.getLoadBalancerHealthMonitorMaxRetries())) &&
 131                     (queryLoadBalancerHealthMonitorHttpMethod == null ||
 132                             queryLoadBalancerHealthMonitorHttpMethod.equals
 133                                     (nsg.getLoadBalancerHealthMonitorHttpMethod())) &&
 134                     (queryLoadBalancerHealthMonitorUrlPath == null ||
 135                             queryLoadBalancerHealthMonitorUrlPath.equals
 136                                     (nsg.getLoadBalancerHealthMonitorUrlPath())) &&
 137                     (queryLoadBalancerHealthMonitorExpectedCodes == null ||
 138                             queryLoadBalancerHealthMonitorExpectedCodes.equals
 139                                     (nsg.getLoadBalancerHealthMonitorExpectedCodes())) &&
 140                     (queryLoadBalancerHealthMonitorIsAdminStateUp == null ||
 141                             queryLoadBalancerHealthMonitorIsAdminStateUp.equals
 142                                     (nsg.getLoadBalancerHealthMonitorAdminStateIsUp()))) {
 143                 if (fields.size() > 0) {
 144                     ans.add(extractFields(nsg,fields));
 145                 } else {
 146                     ans.add(nsg);
 147                 }
 148             }
 149         }
 150         return Response.status(HttpURLConnection.HTTP_OK).entity(
 151                 new NeutronLoadBalancerHealthMonitorRequest(ans)).build();
 152     }
 153
 154     /**
 155      * Returns a specific LoadBalancerHealthMonitor */
 156
 157     @Path("{loadBalancerHealthMonitorID}")
 158     @GET
 159     @Produces({ MediaType.APPLICATION_JSON })
 160     @StatusCodes({
 161             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 162             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 163             @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 164             @ResponseCode(code = HttpURLConnection.HTTP_NOT_IMPLEMENTED, condition = "Not Implemented"),
 165             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 166     public Response showLoadBalancerHealthMonitor(@PathParam("loadBalancerHealthMonitorID") String loadBalancerHealthMonitorID,
 167             // return fields
 168             @QueryParam("fields") List<String> fields) {
 169         INeutronLoadBalancerHealthMonitorCRUD loadBalancerHealthMonitorInterface = getNeutronInterfaces().getLoadBalancerHealthMonitorInterface();
 170         if (!loadBalancerHealthMonitorInterface.neutronLoadBalancerHealthMonitorExists(loadBalancerHealthMonitorID)) {
 171             throw new ResourceNotFoundException(UUID_NO_EXIST);
 172         }
 173         if (fields.size() > 0) {
 174             NeutronLoadBalancerHealthMonitor ans = loadBalancerHealthMonitorInterface.getNeutronLoadBalancerHealthMonitor(loadBalancerHealthMonitorID);
 175             return Response.status(HttpURLConnection.HTTP_OK).entity(
 176                     new NeutronLoadBalancerHealthMonitorRequest(extractFields(ans, fields))).build();
 177         } else {
 178             return Response.status(HttpURLConnection.HTTP_OK).entity(new NeutronLoadBalancerHealthMonitorRequest(loadBalancerHealthMonitorInterface.getNeutronLoadBalancerHealthMonitor(loadBalancerHealthMonitorID))).build();
 179         }
 180     }
 181
 182     /**
 183      * Creates new LoadBalancerHealthMonitor */
 184
 185     @POST
 186     @Produces({ MediaType.APPLICATION_JSON })
 187     @Consumes({ MediaType.APPLICATION_JSON })
 188     @StatusCodes({
 189             @ResponseCode(code = HttpURLConnection.HTTP_CREATED, condition = "Created"),
 190             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 191     public Response createLoadBalancerHealthMonitors(final NeutronLoadBalancerHealthMonitorRequest input) {
 192         INeutronLoadBalancerHealthMonitorCRUD loadBalancerHealthMonitorInterface = getNeutronInterfaces().getLoadBalancerHealthMonitorInterface();
 193         if (input.isSingleton()) {
 194             NeutronLoadBalancerHealthMonitor singleton = input.getSingleton();
 195
 196             Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerHealthMonitorAware.class, this);
 197             if (instances != null) {
 198                 if (instances.length > 0) {
 199                     for (Object instance : instances) {
 200                         INeutronLoadBalancerHealthMonitorAware service = (INeutronLoadBalancerHealthMonitorAware) instance;
 201                         int status = service.canCreateNeutronLoadBalancerHealthMonitor(singleton);
 202                         if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 203                             return Response.status(status).build();
 204                         }
 205                     }
 206                 } else {
 207                     throw new ServiceUnavailableException(NO_PROVIDERS);
 208                 }
 209             } else {
 210                 throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 211             }
 212             loadBalancerHealthMonitorInterface.addNeutronLoadBalancerHealthMonitor(singleton);
 213             if (instances != null) {
 214                 for (Object instance : instances) {
 215                     INeutronLoadBalancerHealthMonitorAware service = (INeutronLoadBalancerHealthMonitorAware) instance;
 216                     service.neutronLoadBalancerHealthMonitorCreated(singleton);
 217                 }
 218             }
 219         } else {
 220             Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerHealthMonitorAware.class, this);
 221             for (NeutronLoadBalancerHealthMonitor test : input.getBulk()) {
 222                 if (instances != null) {
 223                     if (instances.length > 0) {
 224                         for (Object instance : instances) {
 225                             INeutronLoadBalancerHealthMonitorAware service = (INeutronLoadBalancerHealthMonitorAware) instance;
 226                             int status = service.canCreateNeutronLoadBalancerHealthMonitor(test);
 227                             if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 228                                 return Response.status(status).build();
 229                             }
 230                         }
 231                     } else {
 232                         throw new ServiceUnavailableException(NO_PROVIDERS);
 233                     }
 234                 } else {
 235                     throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 236                 }
 237             }
 238             /*
 239              * now, each element of the bulk request can be added to the cache
 240              */
 241             for (NeutronLoadBalancerHealthMonitor test : input.getBulk()) {
 242                 loadBalancerHealthMonitorInterface.addNeutronLoadBalancerHealthMonitor(test);
 243                 if (instances != null) {
 244                     for (Object instance : instances) {
 245                         INeutronLoadBalancerHealthMonitorAware service = (INeutronLoadBalancerHealthMonitorAware) instance;
 246                         service.neutronLoadBalancerHealthMonitorCreated(test);
 247                     }
 248                 }
 249             }
 250         }
 251         return Response.status(HttpURLConnection.HTTP_CREATED).entity(input).build();
 252     }
 253
 254     /**
 255      * Updates a LoadBalancerHealthMonitor Policy
 256      */
 257     @Path("{loadBalancerHealthMonitorID}")
 258     @PUT
 259     @Produces({ MediaType.APPLICATION_JSON })
 260     @Consumes({ MediaType.APPLICATION_JSON })
 261     @StatusCodes({
 262             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 263             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 264     public Response updateLoadBalancerHealthMonitor(
 265             @PathParam("loadBalancerHealthMonitorID") String loadBalancerHealthMonitorID,
 266             final NeutronLoadBalancerHealthMonitorRequest input) {
 267         INeutronLoadBalancerHealthMonitorCRUD loadBalancerHealthMonitorInterface = getNeutronInterfaces().getLoadBalancerHealthMonitorInterface();
 268
 269         NeutronLoadBalancerHealthMonitor delta = input.getSingleton();
 270         NeutronLoadBalancerHealthMonitor original = loadBalancerHealthMonitorInterface
 271                 .getNeutronLoadBalancerHealthMonitor(loadBalancerHealthMonitorID);
 272
 273         Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerHealthMonitorAware.class, this);
 274         if (instances != null) {
 275             if (instances.length > 0) {
 276                 for (Object instance : instances) {
 277                     INeutronLoadBalancerHealthMonitorAware service = (INeutronLoadBalancerHealthMonitorAware) instance;
 278                     int status = service.canUpdateNeutronLoadBalancerHealthMonitor(delta, original);
 279                     if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 280                         return Response.status(status).build();
 281                     }
 282                 }
 283             } else {
 284                 throw new ServiceUnavailableException(NO_PROVIDERS);
 285             }
 286         } else {
 287             throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 288         }
 289
 290         /*
 291          * update the object and return it
 292          */
 293         loadBalancerHealthMonitorInterface.updateNeutronLoadBalancerHealthMonitor(loadBalancerHealthMonitorID, delta);
 294         NeutronLoadBalancerHealthMonitor updatedLoadBalancerHealthMonitor = loadBalancerHealthMonitorInterface
 295                 .getNeutronLoadBalancerHealthMonitor(loadBalancerHealthMonitorID);
 296         if (instances != null) {
 297             for (Object instance : instances) {
 298                 INeutronLoadBalancerHealthMonitorAware service = (INeutronLoadBalancerHealthMonitorAware) instance;
 299                 service.neutronLoadBalancerHealthMonitorUpdated(updatedLoadBalancerHealthMonitor);
 300             }
 301         }
 302         return Response.status(HttpURLConnection.HTTP_OK).entity(new NeutronLoadBalancerHealthMonitorRequest
 303                 (loadBalancerHealthMonitorInterface.getNeutronLoadBalancerHealthMonitor
 304                         (loadBalancerHealthMonitorID))).build();
 305     }
 306
 307
 308
 309     /**
 310      * Deletes a LoadBalancerHealthMonitor
 311      * */
 312     @Path("{loadBalancerHealthMonitorID}")
 313     @DELETE
 314     @StatusCodes({
 315             @ResponseCode(code = HttpURLConnection.HTTP_NO_CONTENT, condition = "No Content"),
 316             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 317     public Response deleteLoadBalancerHealthMonitor(
 318             @PathParam("loadBalancerHealthMonitorID") String loadBalancerHealthMonitorID) {
 319         INeutronLoadBalancerHealthMonitorCRUD loadBalancerHealthMonitorInterface = getNeutronInterfaces().getLoadBalancerHealthMonitorInterface();
 320         NeutronLoadBalancerHealthMonitor singleton = loadBalancerHealthMonitorInterface.getNeutronLoadBalancerHealthMonitor(loadBalancerHealthMonitorID);
 321
 322         Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerHealthMonitorAware.class, this);
 323         if (instances != null) {
 324             if (instances.length > 0) {
 325                 for (Object instance : instances) {
 326                     INeutronLoadBalancerHealthMonitorAware service = (INeutronLoadBalancerHealthMonitorAware) instance;
 327                     int status = service.canDeleteNeutronLoadBalancerHealthMonitor(singleton);
 328                     if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 329                         return Response.status(status).build();
 330                     }
 331                 }
 332             } else {
 333                 throw new ServiceUnavailableException(NO_PROVIDERS);
 334             }
 335         } else {
 336             throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 337         }
 338         loadBalancerHealthMonitorInterface.removeNeutronLoadBalancerHealthMonitor(loadBalancerHealthMonitorID);
 339         if (instances != null) {
 340             for (Object instance : instances) {
 341                 INeutronLoadBalancerHealthMonitorAware service = (INeutronLoadBalancerHealthMonitorAware) instance;
 342                 service.neutronLoadBalancerHealthMonitorDeleted(singleton);
 343             }
 344         }
 345         return Response.status(HttpURLConnection.HTTP_NO_CONTENT).build();
 346     }
 347 }