package org.opendaylight.neutron.northbound.api;
import java.net.HttpURLConnection;
-
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
-
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
-
import org.codehaus.enunciate.jaxrs.ResponseCode;
import org.codehaus.enunciate.jaxrs.StatusCodes;
-import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolAware;
import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolCRUD;
-import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolMemberAware;
import org.opendaylight.neutron.spi.NeutronCRUDInterfaces;
import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
import org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember;
*/
@Path("/lbaas/pools")
-public class NeutronLoadBalancerPoolNorthbound extends AbstractNeutronNorthbound {
+public class NeutronLoadBalancerPoolNorthbound
+ extends AbstractNeutronNorthbound<NeutronLoadBalancerPool, NeutronLoadBalancerPoolRequest, INeutronLoadBalancerPoolCRUD> {
private static final String RESOURCE_NAME = "LoadBalancerPool";
- private NeutronLoadBalancerPool extractFields(NeutronLoadBalancerPool o, List<String> fields) {
+ @Override
+ protected String getResourceName() {
+ return RESOURCE_NAME;
+ }
+
+ @Override
+ protected NeutronLoadBalancerPool extractFields(NeutronLoadBalancerPool o, List<String> fields) {
return o.extractFields(fields);
}
- private NeutronCRUDInterfaces getNeutronInterfaces() {
+ @Override
+ protected NeutronLoadBalancerPoolRequest newNeutronRequest(NeutronLoadBalancerPool o) {
+ return new NeutronLoadBalancerPoolRequest(o);
+ }
+
+ @Override
+ protected INeutronLoadBalancerPoolCRUD getNeutronCRUD() {
NeutronCRUDInterfaces answer = new NeutronCRUDInterfaces().
fetchINeutronLoadBalancerPoolCRUD(this);
if (answer.getLoadBalancerPoolInterface() == null) {
- throw new ServiceUnavailableException(serviceUnavailable(RESOURCE_NAME));
+ throw new ServiceUnavailableException(serviceUnavailable());
}
- return answer;
+ return answer.getLoadBalancerPoolInterface();
}
-
/**
* Returns a list of all LoadBalancerPool
* */
@QueryParam("id") String queryLoadBalancerPoolID,
@QueryParam("tenant_id") String queryLoadBalancerPoolTenantID,
@QueryParam("name") String queryLoadBalancerPoolName,
- @QueryParam("description") String queryLoadBalancerDescription,
@QueryParam("protocol") String queryLoadBalancerProtocol,
@QueryParam("lb_algorithm") String queryLoadBalancerPoolLbAlgorithm,
@QueryParam("healthmonitor_id") String queryLoadBalancerPoolHealthMonitorID,
- @QueryParam("admin_state_up") String queryLoadBalancerIsAdminStateUp,
+ @QueryParam("admin_state_up") Boolean queryLoadBalancerIsAdminStateUp,
@QueryParam("members") List<NeutronLoadBalancerPoolMember> queryLoadBalancerPoolMembers,
// pagination
@QueryParam("limit") String limit,
@QueryParam("page_reverse") String pageReverse
// sorting not supported
) {
- INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
- List<NeutronLoadBalancerPool> allLoadBalancerPools = loadBalancerPoolInterface.getAllNeutronLoadBalancerPools();
+ INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
+ List<NeutronLoadBalancerPool> allLoadBalancerPools = loadBalancerPoolInterface.getAll();
List<NeutronLoadBalancerPool> ans = new ArrayList<NeutronLoadBalancerPool>();
Iterator<NeutronLoadBalancerPool> i = allLoadBalancerPools.iterator();
while (i.hasNext()) {
queryLoadBalancerPoolTenantID.equals(nsg.getTenantID())) &&
(queryLoadBalancerPoolName == null ||
queryLoadBalancerPoolName.equals(nsg.getLoadBalancerPoolName())) &&
- (queryLoadBalancerDescription == null ||
- queryLoadBalancerDescription.equals(nsg.getLoadBalancerPoolDescription())) &&
(queryLoadBalancerPoolLbAlgorithm == null ||
queryLoadBalancerPoolLbAlgorithm.equals(nsg.getLoadBalancerPoolLbAlgorithm())) &&
(queryLoadBalancerPoolHealthMonitorID == null ||
public Response showLoadBalancerPool(@PathParam("loadBalancerPoolID") String loadBalancerPoolID,
// return fields
@QueryParam("fields") List<String> fields) {
- INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
- if (!loadBalancerPoolInterface.neutronLoadBalancerPoolExists(loadBalancerPoolID)) {
- throw new ResourceNotFoundException(uuidNoExist(RESOURCE_NAME));
- }
- if (fields.size() > 0) {
- NeutronLoadBalancerPool ans = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolID);
- return Response.status(HttpURLConnection.HTTP_OK).entity(
- new NeutronLoadBalancerPoolRequest(extractFields(ans, fields))).build();
- } else {
- return Response.status(HttpURLConnection.HTTP_OK).entity(new NeutronLoadBalancerPoolRequest(loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolID))).build();
- }
+ return show(loadBalancerPoolID, fields);
}
/**
@ResponseCode(code = HttpURLConnection.HTTP_CREATED, condition = "Created"),
@ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
public Response createLoadBalancerPools(final NeutronLoadBalancerPoolRequest input) {
- INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
- if (input.isSingleton()) {
- NeutronLoadBalancerPool singleton = input.getSingleton();
-
- Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolAware.class, this);
- if (instances != null) {
- if (instances.length > 0) {
- for (Object instance : instances) {
- INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
- int status = service.canCreateNeutronLoadBalancerPool(singleton);
- if (status < HttpURLConnection.HTTP_OK || status > HTTP_OK_TOP) {
- return Response.status(status).build();
- }
- }
- } else {
- throw new ServiceUnavailableException(NO_PROVIDERS);
- }
- } else {
- throw new ServiceUnavailableException(NO_PROVIDER_LIST);
- }
- loadBalancerPoolInterface.addNeutronLoadBalancerPool(singleton);
- if (instances != null) {
- for (Object instance : instances) {
- INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
- service.neutronLoadBalancerPoolCreated(singleton);
- }
- }
- } else {
- Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolAware.class, this);
- for (NeutronLoadBalancerPool test : input.getBulk()) {
-
- if (instances != null) {
- if (instances.length > 0) {
- for (Object instance : instances) {
- INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
- int status = service.canCreateNeutronLoadBalancerPool(test);
- if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
- return Response.status(status).build();
- }
- }
- } else {
- throw new ServiceUnavailableException(NO_PROVIDERS);
- }
- } else {
- throw new ServiceUnavailableException(NO_PROVIDER_LIST);
- }
- }
- /*
- * now, each element of the bulk request can be added to the cache
- */
- for (NeutronLoadBalancerPool test : input.getBulk()) {
- loadBalancerPoolInterface.addNeutronLoadBalancerPool(test);
- if (instances != null) {
- for (Object instance : instances) {
- INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
- service.neutronLoadBalancerPoolCreated(test);
- }
- }
- }
- }
- return Response.status(HttpURLConnection.HTTP_CREATED).entity(input).build();
+ return create(input);
}
/**
@Consumes({ MediaType.APPLICATION_JSON })
@StatusCodes({
@ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
+ @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
@ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
public Response updateLoadBalancerPool(
@PathParam("loadBalancerPoolID") String loadBalancerPoolID, final NeutronLoadBalancerPoolRequest input) {
- INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
-
- NeutronLoadBalancerPool delta = input.getSingleton();
- NeutronLoadBalancerPool original = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolID);
-
- Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolAware.class, this);
- if (instances != null) {
- if (instances.length > 0) {
- for (Object instance : instances) {
- INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
- int status = service.canUpdateNeutronLoadBalancerPool(delta, original);
- if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
- return Response.status(status).build();
- }
- }
- } else {
- throw new ServiceUnavailableException(NO_PROVIDERS);
- }
- } else {
- throw new ServiceUnavailableException(NO_PROVIDER_LIST);
- }
-
- /*
- * update the object and return it
- */
- loadBalancerPoolInterface.updateNeutronLoadBalancerPool(loadBalancerPoolID, delta);
- NeutronLoadBalancerPool updatedLoadBalancerPool = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolID);
- if (instances != null) {
- for (Object instance : instances) {
- INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
- service.neutronLoadBalancerPoolUpdated(updatedLoadBalancerPool);
- }
- }
- return Response.status(HttpURLConnection.HTTP_OK).entity(new NeutronLoadBalancerPoolRequest(loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolID))).build();
+ return update(loadBalancerPoolID, input);
}
/**
@DELETE
@StatusCodes({
@ResponseCode(code = HttpURLConnection.HTTP_NO_CONTENT, condition = "No Content"),
+ @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
@ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
public Response deleteLoadBalancerPool(
@PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID) {
- final INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
-
- NeutronLoadBalancerPool singleton = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID);
- Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolAware.class, this);
- if (instances != null) {
- if (instances.length > 0) {
- for (Object instance : instances) {
- INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
- int status = service.canDeleteNeutronLoadBalancerPool(singleton);
- if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
- return Response.status(status).build();
- }
- }
- } else {
- throw new ServiceUnavailableException(NO_PROVIDERS);
- }
- } else {
- throw new ServiceUnavailableException(NO_PROVIDER_LIST);
- }
-
- /*
- * remove it and return 204 status
- */
- deleteUuid(RESOURCE_NAME, loadBalancerPoolUUID,
- new Remover() {
- public boolean remove(String uuid) {
- return loadBalancerPoolInterface.removeNeutronLoadBalancerPool(uuid);
- }
- });
- if (instances != null) {
- for (Object instance : instances) {
- INeutronLoadBalancerPoolAware service = (INeutronLoadBalancerPoolAware) instance;
- service.neutronLoadBalancerPoolDeleted(singleton);
- }
- }
- return Response.status(HttpURLConnection.HTTP_NO_CONTENT).build();
+ return delete(loadBalancerPoolUUID);
}
- private NeutronLoadBalancerPoolMember extractFields(NeutronLoadBalancerPoolMember o, List<String> fields) {
+ protected NeutronLoadBalancerPoolMember extractFields(NeutronLoadBalancerPoolMember o, List<String> fields) {
return o.extractFields(fields);
}
@QueryParam("tenant_id") String queryLoadBalancerPoolMemberTenantID,
@QueryParam("address") String queryLoadBalancerPoolMemberAddress,
@QueryParam("protocol_port") String queryLoadBalancerPoolMemberProtoPort,
- @QueryParam("admin_state_up") String queryLoadBalancerPoolMemberAdminStateUp,
- @QueryParam("weight") String queryLoadBalancerPoolMemberWeight,
+ @QueryParam("admin_state_up") Boolean queryLoadBalancerPoolMemberAdminStateUp,
+ @QueryParam("weight") Integer queryLoadBalancerPoolMemberWeight,
@QueryParam("subnet_id") String queryLoadBalancerPoolMemberSubnetID,
// pagination
@QueryParam("page_reverse") String pageReverse
// sorting not supported
) {
- INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
- if (!loadBalancerPoolInterface.neutronLoadBalancerPoolExists(loadBalancerPoolUUID)) {
- throw new ResourceNotFoundException(uuidNoExist(RESOURCE_NAME));
+ INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
+ if (!loadBalancerPoolInterface.exists(loadBalancerPoolUUID)) {
+ throw new ResourceNotFoundException(uuidNoExist());
}
List<NeutronLoadBalancerPoolMember> members =
- loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID).getLoadBalancerPoolMembers();
+ loadBalancerPoolInterface.get(loadBalancerPoolUUID).getLoadBalancerPoolMembers();
List<NeutronLoadBalancerPoolMember> ans = new ArrayList<NeutronLoadBalancerPoolMember>();
Iterator<NeutronLoadBalancerPoolMember> i = members.iterator();
while (i.hasNext()) {
// return fields
@QueryParam("fields") List<String> fields ) {
- INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
- if (!loadBalancerPoolInterface.neutronLoadBalancerPoolExists(loadBalancerPoolUUID)) {
- throw new ResourceNotFoundException(uuidNoExist(RESOURCE_NAME));
+ INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
+ if (!loadBalancerPoolInterface.exists(loadBalancerPoolUUID)) {
+ throw new ResourceNotFoundException(uuidNoExist());
}
List<NeutronLoadBalancerPoolMember> members =
- loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID).getLoadBalancerPoolMembers();
+ loadBalancerPoolInterface.get(loadBalancerPoolUUID).getLoadBalancerPoolMembers();
for (NeutronLoadBalancerPoolMember ans: members) {
if (!ans.getID().equals(loadBalancerPoolMemberUUID)) {
continue;
new NeutronLoadBalancerPoolMemberRequest(ans)).build();
}
}
- throw new ResourceNotFoundException(uuidNoExist(RESOURCE_NAME));
+ throw new ResourceNotFoundException(uuidNoExist());
}
/**
@PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
final NeutronLoadBalancerPoolMemberRequest input) {
- INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
- NeutronLoadBalancerPool singletonPool = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID);
+ INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
+ NeutronLoadBalancerPool singletonPool = loadBalancerPoolInterface.get(loadBalancerPoolUUID);
if (input.isSingleton()) {
NeutronLoadBalancerPoolMember singleton = input.getSingleton();
singleton.setPoolID(loadBalancerPoolUUID);
-
- Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolMemberAware.class, this);
- if (instances != null) {
- if (instances.length > 0) {
- for (Object instance : instances) {
- INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
- int status = service.canCreateNeutronLoadBalancerPoolMember(singleton);
- if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
- return Response.status(status).build();
- }
- }
- } else {
- throw new ServiceUnavailableException(NO_PROVIDERS);
- }
- } else {
- throw new ServiceUnavailableException(NO_PROVIDER_LIST);
- }
-
- if (instances != null) {
- for (Object instance : instances) {
- INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
- service.neutronLoadBalancerPoolMemberCreated(singleton);
- }
- }
-
/**
* Add the member from the neutron load balancer pool as well
*/
loadBalancerPoolInterface.addNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, singleton);
} else {
- Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolMemberAware.class, this);
- for (NeutronLoadBalancerPoolMember test : input.getBulk()) {
-
- if (instances != null) {
- if (instances.length > 0) {
- for (Object instance : instances) {
- INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
- int status = service.canCreateNeutronLoadBalancerPoolMember(test);
- if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
- return Response.status(status).build();
- }
- }
- } else {
- throw new ServiceUnavailableException(NO_PROVIDERS);
- }
- } else {
- throw new ServiceUnavailableException(NO_PROVIDER_LIST);
- }
- }
/*
* now, each element of the bulk request can be added to the cache
*/
for (NeutronLoadBalancerPoolMember test : input.getBulk()) {
- if (instances != null) {
- for (Object instance : instances) {
- INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
- service.neutronLoadBalancerPoolMemberCreated(test);
- }
- }
loadBalancerPoolInterface.addNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, test);
}
}
@Produces({ MediaType.APPLICATION_JSON })
@Consumes({ MediaType.APPLICATION_JSON })
@StatusCodes({
- @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful") })
+ @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
+ @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found") })
public Response updateLoadBalancerPoolMember(
@PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
@PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID,
final NeutronLoadBalancerPoolMemberRequest input) {
- INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
- NeutronLoadBalancerPool singletonPool = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID);
+ INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
+ NeutronLoadBalancerPool singletonPool = loadBalancerPoolInterface.get(loadBalancerPoolUUID);
NeutronLoadBalancerPoolMember singleton = input.getSingleton();
singleton.setPoolID(loadBalancerPoolUUID);
}
NeutronLoadBalancerPoolMember original = singletonPool.getNeutronLoadBalancerPoolMember(loadBalancerPoolMemberUUID);
- Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolMemberAware.class, this);
- if (instances != null) {
- if (instances.length > 0) {
- for (Object instance : instances) {
- INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
- int status = service.canUpdateNeutronLoadBalancerPoolMember(singleton, original);
- if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
- return Response.status(status).build();
- }
- }
- } else {
- throw new ServiceUnavailableException(NO_PROVIDERS);
- }
- } else {
- throw new ServiceUnavailableException(NO_PROVIDER_LIST);
- }
-
loadBalancerPoolInterface.updateNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, loadBalancerPoolMemberUUID, singleton);
-
- if (instances != null) {
- for (Object instance : instances) {
- INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
- service.neutronLoadBalancerPoolMemberUpdated(singleton);
- }
- }
return Response.status(HttpURLConnection.HTTP_OK).entity(input).build();
}
@DELETE
@StatusCodes({
@ResponseCode(code = HttpURLConnection.HTTP_NO_CONTENT, condition = "No Content"),
+ @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
@ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
public Response deleteLoadBalancerPoolMember(
@PathParam("loadBalancerPoolUUID") String loadBalancerPoolUUID,
@PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID) {
- INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
+ INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
//Verify that the LB pool member exists
NeutronLoadBalancerPoolMember singleton = null;
List<NeutronLoadBalancerPoolMember> members =
- loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID).getLoadBalancerPoolMembers();
+ loadBalancerPoolInterface.get(loadBalancerPoolUUID).getLoadBalancerPoolMembers();
for (NeutronLoadBalancerPoolMember member: members) {
if (member.getID().equals(loadBalancerPoolMemberUUID)) {
singleton = member;
throw new BadRequestException("LoadBalancerPoolMember UUID does not exist.");
}
- Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolMemberAware.class, this);
- if (instances != null) {
- if (instances.length > 0) {
- for (Object instance : instances) {
- INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
- int status = service.canDeleteNeutronLoadBalancerPoolMember(singleton);
- if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
- return Response.status(status).build();
- }
- }
- } else {
- throw new ServiceUnavailableException(NO_PROVIDERS);
- }
- } else {
- throw new ServiceUnavailableException(NO_PROVIDER_LIST);
- }
-
- if (instances != null) {
- for (Object instance : instances) {
- INeutronLoadBalancerPoolMemberAware service = (INeutronLoadBalancerPoolMemberAware) instance;
- service.neutronLoadBalancerPoolMemberDeleted(singleton);
- }
- }
-
/**
* Remove the member from the neutron load balancer pool
*/
Code Review / neutron.git / blobdiff