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