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

   1 /*
   2  * Copyright (c) 2014, 2015 Red Hat, Inc. 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.INeutronLoadBalancerAware;
  32 import org.opendaylight.neutron.spi.INeutronLoadBalancerCRUD;
  33 import org.opendaylight.neutron.spi.NeutronCRUDInterfaces;
  34 import org.opendaylight.neutron.spi.NeutronLoadBalancer;
  35
  36 /**
  37  * Neutron Northbound REST APIs for LoadBalancers.<br>
  38  * This class provides REST APIs for managing neutron LoadBalancers
  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/loadbalancers")
  54 public class NeutronLoadBalancerNorthbound
  55     extends AbstractNeutronNorthbound<NeutronLoadBalancer, NeutronLoadBalancerRequest, INeutronLoadBalancerCRUD, INeutronLoadBalancerAware> {
  56
  57     private static final String RESOURCE_NAME = "LoadBalancer";
  58
  59     @Override
  60     protected String getResourceName() {
  61         return RESOURCE_NAME;
  62     }
  63
  64     @Override
  65     protected NeutronLoadBalancer extractFields(NeutronLoadBalancer o, List<String> fields) {
  66         return o.extractFields(fields);
  67     }
  68
  69     @Override
  70     protected NeutronLoadBalancerRequest newNeutronRequest(NeutronLoadBalancer o) {
  71         return new NeutronLoadBalancerRequest(o);
  72     }
  73
  74     @Override
  75     protected INeutronLoadBalancerCRUD getNeutronCRUD() {
  76         NeutronCRUDInterfaces answer = new NeutronCRUDInterfaces().fetchINeutronLoadBalancerCRUD(this);
  77         if (answer.getLoadBalancerInterface() == null) {
  78             throw new ServiceUnavailableException(serviceUnavailable());
  79         }
  80         return answer.getLoadBalancerInterface();
  81     }
  82
  83     @Override
  84     protected Object[] getInstances() {
  85         return NeutronUtil.getInstances(INeutronLoadBalancerAware.class, this);
  86     }
  87
  88     @Override
  89     protected int canCreate(Object instance, NeutronLoadBalancer singleton) {
  90         INeutronLoadBalancerAware service = (INeutronLoadBalancerAware) instance;
  91         return service.canCreateNeutronLoadBalancer(singleton);
  92     }
  93
  94     @Override
  95     protected void created(Object instance, NeutronLoadBalancer singleton) {
  96         INeutronLoadBalancerAware service = (INeutronLoadBalancerAware) instance;
  97         service.neutronLoadBalancerCreated(singleton);
  98     }
  99
 100     @Override
 101     protected int canUpdate(Object instance, NeutronLoadBalancer delta, NeutronLoadBalancer original) {
 102         INeutronLoadBalancerAware service = (INeutronLoadBalancerAware) instance;
 103         return service.canUpdateNeutronLoadBalancer(delta, original);
 104     }
 105
 106     @Override
 107     protected void updated(Object instance, NeutronLoadBalancer updated) {
 108         INeutronLoadBalancerAware service = (INeutronLoadBalancerAware) instance;
 109         service.neutronLoadBalancerUpdated(updated);
 110     }
 111
 112     @Override
 113     protected int canDelete(Object instance, NeutronLoadBalancer singleton) {
 114         INeutronLoadBalancerAware service = (INeutronLoadBalancerAware) instance;
 115         return service.canDeleteNeutronLoadBalancer(singleton);
 116     }
 117
 118     @Override
 119     protected void deleted(Object instance, NeutronLoadBalancer singleton) {
 120         INeutronLoadBalancerAware service = (INeutronLoadBalancerAware) instance;
 121         service.neutronLoadBalancerDeleted(singleton);
 122     }
 123
 124     /**
 125      * Returns a list of all LoadBalancer */
 126     @GET
 127     @Produces({ MediaType.APPLICATION_JSON })
 128     @StatusCodes({
 129             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 130             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 131             @ResponseCode(code = HttpURLConnection.HTTP_NOT_IMPLEMENTED, condition = "Not Implemented"),
 132             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 133
 134     public Response listGroups(
 135             // return fields
 136             @QueryParam("fields") List<String> fields,
 137             // OpenStack LoadBalancer attributes
 138             @QueryParam("id") String queryLoadBalancerID,
 139             @QueryParam("tenant_id") String queryLoadBalancerTenantID,
 140             @QueryParam("name") String queryLoadBalancerName,
 141             @QueryParam("description") String queryLoadBalancerDescription,
 142             @QueryParam("status") String queryLoadBalancerStatus,
 143             @QueryParam("vip_address") String queryLoadBalancerVipAddress,
 144             @QueryParam("vip_subnet") String queryLoadBalancerVipSubnet,
 145             // pagination
 146             @QueryParam("limit") String limit,
 147             @QueryParam("marker") String marker,
 148             @QueryParam("page_reverse") String pageReverse
 149             // sorting not supported
 150     ) {
 151         INeutronLoadBalancerCRUD loadBalancerInterface = getNeutronCRUD();
 152         List<NeutronLoadBalancer> allLoadBalancers = loadBalancerInterface.getAllNeutronLoadBalancers();
 153         List<NeutronLoadBalancer> ans = new ArrayList<NeutronLoadBalancer>();
 154         Iterator<NeutronLoadBalancer> i = allLoadBalancers.iterator();
 155         while (i.hasNext()) {
 156             NeutronLoadBalancer nsg = i.next();
 157             if ((queryLoadBalancerID == null ||
 158                     queryLoadBalancerID.equals(nsg.getID())) &&
 159                     (queryLoadBalancerTenantID == null ||
 160                             queryLoadBalancerTenantID.equals(nsg.getTenantID())) &&
 161                     (queryLoadBalancerName == null ||
 162                             queryLoadBalancerName.equals(nsg.getLoadBalancerName())) &&
 163                     (queryLoadBalancerDescription == null ||
 164                             queryLoadBalancerDescription.equals(nsg.getLoadBalancerDescription())) &&
 165                     (queryLoadBalancerVipAddress == null ||
 166                             queryLoadBalancerVipAddress.equals(nsg.getLoadBalancerVipAddress())) &&
 167                     (queryLoadBalancerVipSubnet == null ||
 168                             queryLoadBalancerVipSubnet.equals(nsg.getLoadBalancerVipSubnetID()))) {
 169                 if (fields.size() > 0) {
 170                     ans.add(extractFields(nsg,fields));
 171                 } else {
 172                     ans.add(nsg);
 173                 }
 174             }
 175         }
 176         return Response.status(HttpURLConnection.HTTP_OK).entity(
 177                 new NeutronLoadBalancerRequest(ans)).build();
 178     }
 179
 180     /**
 181      * Returns a specific LoadBalancer */
 182
 183     @Path("{loadBalancerID}")
 184     @GET
 185     @Produces({ MediaType.APPLICATION_JSON })
 186
 187     @StatusCodes({
 188             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 189             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 190             @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 191             @ResponseCode(code = HttpURLConnection.HTTP_NOT_IMPLEMENTED, condition = "Not Implemented"),
 192             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 193     public Response showLoadBalancer(@PathParam("loadBalancerID") String loadBalancerID,
 194             // return fields
 195             @QueryParam("fields") List<String> fields) {
 196         return show(loadBalancerID, fields);
 197     }
 198
 199     /**
 200      * Creates new LoadBalancer */
 201
 202     @POST
 203     @Produces({ MediaType.APPLICATION_JSON })
 204     @Consumes({ MediaType.APPLICATION_JSON })
 205
 206     @StatusCodes({
 207             @ResponseCode(code = HttpURLConnection.HTTP_CREATED, condition = "Created"),
 208             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 209     public Response createLoadBalancers(final NeutronLoadBalancerRequest input) {
 210         return create(input);
 211     }
 212
 213     /**
 214      * Updates a LoadBalancer Policy
 215      */
 216     @Path("{loadBalancerID}")
 217     @PUT
 218     @Produces({ MediaType.APPLICATION_JSON })
 219     @Consumes({ MediaType.APPLICATION_JSON })
 220
 221     @StatusCodes({
 222             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 223             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 224     public Response updateLoadBalancer(
 225             @PathParam("loadBalancerID") String loadBalancerID, final NeutronLoadBalancerRequest input) {
 226         return update(loadBalancerID, input);
 227     }
 228
 229     /**
 230      * Deletes a LoadBalancer */
 231
 232     @Path("{loadBalancerID}")
 233     @DELETE
 234     @StatusCodes({
 235             @ResponseCode(code = HttpURLConnection.HTTP_NO_CONTENT, condition = "No Content"),
 236             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 237     public Response deleteLoadBalancer(
 238             @PathParam("loadBalancerID") String loadBalancerID) {
 239         return delete(loadBalancerID);
 240     }
 241 }