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