northbound-api/src/main/java/org/opendaylight/neutron/northbound/api/NeutronFirewallPolicyNorthbound.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.List;
  15
  16 import javax.ws.rs.Consumes;
  17 import javax.ws.rs.DELETE;
  18 import javax.ws.rs.GET;
  19 import javax.ws.rs.POST;
  20 import javax.ws.rs.PUT;
  21 import javax.ws.rs.Path;
  22 import javax.ws.rs.PathParam;
  23 import javax.ws.rs.Produces;
  24 import javax.ws.rs.QueryParam;
  25 import javax.ws.rs.core.MediaType;
  26 import javax.ws.rs.core.Response;
  27
  28 import org.codehaus.enunciate.jaxrs.ResponseCode;
  29 import org.codehaus.enunciate.jaxrs.StatusCodes;
  30 import org.opendaylight.neutron.spi.INeutronFirewallPolicyAware;
  31 import org.opendaylight.neutron.spi.INeutronFirewallPolicyCRUD;
  32 import org.opendaylight.neutron.spi.NeutronCRUDInterfaces;
  33 import org.opendaylight.neutron.spi.NeutronFirewallPolicy;
  34
  35 /**
  36  * Neutron Northbound REST APIs for Firewall Policies.<br>
  37  * This class provides REST APIs for managing neutron Firewall Policies
  38  *
  39  * <br>
  40  * <br>
  41  * Authentication scheme : <b>HTTP Basic</b><br>
  42  * Authentication realm : <b>opendaylight</b><br>
  43  * Transport : <b>HTTP and HTTPS</b><br>
  44  * <br>
  45  * HTTPS Authentication is disabled by default. Administrator can enable it in
  46  * tomcat-server.xml after adding a proper keystore / SSL certificate from a
  47  * trusted authority.<br>
  48  * More info :
  49  * http://tomcat.apache.org/tomcat-7.0-doc/ssl-howto.html#Configuration
  50  *
  51  */
  52 @Path("/fw/firewall_policies")
  53 public class NeutronFirewallPolicyNorthbound {
  54
  55     private static final int HTTP_OK_BOTTOM = 200;
  56     private static final int HTTP_OK_TOP = 299;
  57     private static final String INTERFACE_NAME = "Firewall Policy CRUD Interface";
  58     private static final String UUID_NO_EXIST = "Firewall Policy UUID does not exist.";
  59     private static final String NO_PROVIDERS = "No providers registered.  Please try again later";
  60     private static final String NO_PROVIDER_LIST = "Couldn't get providers list.  Please try again later";
  61
  62     private NeutronFirewallPolicy extractFields(NeutronFirewallPolicy o, List<String> fields) {
  63         return o.extractFields(fields);
  64     }
  65
  66     private NeutronCRUDInterfaces getNeutronInterfaces() {
  67         NeutronCRUDInterfaces answer = new NeutronCRUDInterfaces().fetchINeutronFirewallPolicyCRUD(this);
  68         if (answer.getFirewallPolicyInterface() == null) {
  69             throw new ServiceUnavailableException(INTERFACE_NAME
  70                 + RestMessages.SERVICEUNAVAILABLE.toString());
  71         }
  72         return answer;
  73     }
  74
  75     /**
  76      * Returns a list of all Firewall Policies */
  77     @GET
  78     @Produces({ MediaType.APPLICATION_JSON })
  79     @StatusCodes({
  80             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
  81             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
  82             @ResponseCode(code = HttpURLConnection.HTTP_NOT_IMPLEMENTED, condition = "Not Implemented"),
  83             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
  84
  85     public Response listGroups(
  86             // return fields
  87             @QueryParam("fields") List<String> fields,
  88             // OpenStack Firewall Policy attributes
  89             @QueryParam("id") String queryFirewallPolicyUUID,
  90             @QueryParam("tenant_id") String queryFirewallPolicyTenantID,
  91             @QueryParam("name") String queryFirewallPolicyName,
  92             @QueryParam("description") String querySecurityPolicyDescription,
  93             @QueryParam("shared") String querySecurityPolicyIsShared,
  94             @QueryParam("firewall_rules") List<String> querySecurityPolicyFirewallRules,
  95             @QueryParam("audited") Boolean querySecurityPolicyIsAudited,
  96             // pagination
  97             @QueryParam("limit") String limit,
  98             @QueryParam("marker") String marker,
  99             @QueryParam("page_reverse") String pageReverse
 100             // sorting not supported
 101     ) {
 102         INeutronFirewallPolicyCRUD firewallPolicyInterface = getNeutronInterfaces().getFirewallPolicyInterface();
 103         List<NeutronFirewallPolicy> ans = new ArrayList<NeutronFirewallPolicy>();
 104         for (NeutronFirewallPolicy nsg : firewallPolicyInterface.getAllNeutronFirewallPolicies()) {
 105             if ((queryFirewallPolicyUUID == null ||
 106                 queryFirewallPolicyUUID.equals(nsg.getID())) &&
 107                 (queryFirewallPolicyTenantID == null ||
 108                     queryFirewallPolicyTenantID.equals(nsg.getTenantID())) &&
 109                 (queryFirewallPolicyName == null ||
 110                     queryFirewallPolicyName.equals(nsg.getFirewallPolicyName())) &&
 111                 (querySecurityPolicyDescription == null ||
 112                     querySecurityPolicyDescription.equals(nsg.getFirewallPolicyDescription())) &&
 113                 (querySecurityPolicyIsShared == null ||
 114                     querySecurityPolicyIsShared.equals(nsg.getFirewallPolicyIsShared())) &&
 115                 (querySecurityPolicyFirewallRules.size() == 0 ||
 116                     querySecurityPolicyFirewallRules.equals(nsg.getFirewallPolicyRules())) &&
 117                 (querySecurityPolicyIsAudited == null ||
 118                     querySecurityPolicyIsAudited.equals(nsg.getFirewallPolicyIsAudited()))) {
 119                 if (fields.size() > 0) {
 120                     ans.add(extractFields(nsg,fields));
 121                 } else {
 122                     ans.add(nsg);
 123                 }
 124             }
 125         }
 126         //TODO: apply pagination to results
 127         return Response.status(HttpURLConnection.HTTP_OK).entity(
 128                 new NeutronFirewallPolicyRequest(ans)).build();
 129     }
 130
 131     /**
 132      * Returns a specific Firewall Policy */
 133
 134     @Path("{firewallPolicyUUID}")
 135     @GET
 136     @Produces({ MediaType.APPLICATION_JSON })
 137     @StatusCodes({
 138             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 139             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 140             @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 141             @ResponseCode(code = HttpURLConnection.HTTP_NOT_IMPLEMENTED, condition = "Not Implemented"),
 142             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 143     public Response showFirewallPolicy(@PathParam("firewallPolicyUUID") String firewallPolicyUUID,
 144                                       // return fields
 145                                       @QueryParam("fields") List<String> fields) {
 146         INeutronFirewallPolicyCRUD firewallPolicyInterface = getNeutronInterfaces().getFirewallPolicyInterface();
 147         if (!firewallPolicyInterface.neutronFirewallPolicyExists(firewallPolicyUUID)) {
 148             throw new ResourceNotFoundException(UUID_NO_EXIST);
 149         }
 150         if (fields.size() > 0) {
 151             NeutronFirewallPolicy ans = firewallPolicyInterface.getNeutronFirewallPolicy(firewallPolicyUUID);
 152             return Response.status(HttpURLConnection.HTTP_OK).entity(
 153                     new NeutronFirewallPolicyRequest(extractFields(ans, fields))).build();
 154         } else {
 155             return Response.status(HttpURLConnection.HTTP_OK).entity(new NeutronFirewallPolicyRequest(firewallPolicyInterface.getNeutronFirewallPolicy(firewallPolicyUUID))).build();
 156         }
 157     }
 158
 159     /**
 160      * Creates new Firewall Policy
 161      * */
 162     @POST
 163     @Produces({ MediaType.APPLICATION_JSON })
 164     @Consumes({ MediaType.APPLICATION_JSON })
 165     @StatusCodes({
 166             @ResponseCode(code = HttpURLConnection.HTTP_CREATED, condition = "Created"),
 167             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 168     public Response createFirewallPolicies(final NeutronFirewallPolicyRequest input) {
 169         INeutronFirewallPolicyCRUD firewallPolicyInterface = getNeutronInterfaces().getFirewallPolicyInterface();
 170         if (input.isSingleton()) {
 171             NeutronFirewallPolicy singleton = input.getSingleton();
 172
 173             Object[] instances = NeutronUtil.getInstances(INeutronFirewallPolicyAware.class, this);
 174             if (instances != null) {
 175                 if (instances.length > 0) {
 176                     for (Object instance : instances) {
 177                         INeutronFirewallPolicyAware service = (INeutronFirewallPolicyAware) instance;
 178                         int status = service.canCreateNeutronFirewallPolicy(singleton);
 179                         if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 180                             return Response.status(status).build();
 181                         }
 182                     }
 183                 } else {
 184                     throw new ServiceUnavailableException(NO_PROVIDERS);
 185                 }
 186             } else {
 187                 throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 188             }
 189             firewallPolicyInterface.addNeutronFirewallPolicy(singleton);
 190             if (instances != null) {
 191                 for (Object instance : instances) {
 192                     INeutronFirewallPolicyAware service = (INeutronFirewallPolicyAware) instance;
 193                     service.neutronFirewallPolicyCreated(singleton);
 194                 }
 195             }
 196         } else {
 197             Object[] instances = NeutronUtil.getInstances(INeutronFirewallPolicyAware.class, this);
 198             for (NeutronFirewallPolicy test : input.getBulk()) {
 199                 if (instances != null) {
 200                     if (instances.length > 0) {
 201                         for (Object instance : instances) {
 202                             INeutronFirewallPolicyAware service = (INeutronFirewallPolicyAware) instance;
 203                             int status = service.canCreateNeutronFirewallPolicy(test);
 204                             if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 205                                 return Response.status(status).build();
 206                             }
 207                         }
 208                     } else {
 209                         throw new ServiceUnavailableException(NO_PROVIDERS);
 210                     }
 211                 } else {
 212                     throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 213                 }
 214             }
 215             /*
 216              * now, each element of the bulk request can be added to the cache
 217              */
 218             for (NeutronFirewallPolicy test : input.getBulk()) {
 219                 firewallPolicyInterface.addNeutronFirewallPolicy(test);
 220                 if (instances != null) {
 221                     for (Object instance : instances) {
 222                         INeutronFirewallPolicyAware service = (INeutronFirewallPolicyAware) instance;
 223                         service.neutronFirewallPolicyCreated(test);
 224                     }
 225                 }
 226             }
 227         }
 228         return Response.status(HttpURLConnection.HTTP_CREATED).entity(input).build();
 229     }
 230
 231     /**
 232      * Updates a Firewall Policy
 233      */
 234     @Path("{firewallPolicyUUID}")
 235     @PUT
 236     @Produces({ MediaType.APPLICATION_JSON })
 237     @Consumes({ MediaType.APPLICATION_JSON })
 238     //@TypeHint(OpenStackSubnets.class)
 239     @StatusCodes({
 240             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 241             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 242     public Response updateFirewallPolicy(
 243             @PathParam("firewallPolicyUUID") String firewallPolicyUUID, final NeutronFirewallPolicyRequest input) {
 244         INeutronFirewallPolicyCRUD firewallPolicyInterface = getNeutronInterfaces().getFirewallPolicyInterface();
 245
 246         NeutronFirewallPolicy delta = input.getSingleton();
 247         NeutronFirewallPolicy original = firewallPolicyInterface.getNeutronFirewallPolicy(firewallPolicyUUID);
 248
 249         Object[] instances = NeutronUtil.getInstances(INeutronFirewallPolicyAware.class, this);
 250         if (instances != null) {
 251             if (instances.length > 0) {
 252                 for (Object instance : instances) {
 253                     INeutronFirewallPolicyAware service = (INeutronFirewallPolicyAware) instance;
 254                     int status = service.canUpdateNeutronFirewallPolicy(delta, original);
 255                     if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 256                         return Response.status(status).build();
 257                     }
 258                 }
 259             } else {
 260                 throw new ServiceUnavailableException(NO_PROVIDERS);
 261             }
 262         } else {
 263             throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 264         }
 265
 266         /*
 267          * update the object and return it
 268          */
 269         firewallPolicyInterface.updateNeutronFirewallPolicy(firewallPolicyUUID, delta);
 270         NeutronFirewallPolicy updatedFirewallPolicy = firewallPolicyInterface.getNeutronFirewallPolicy(firewallPolicyUUID);
 271         if (instances != null) {
 272             for (Object instance : instances) {
 273                 INeutronFirewallPolicyAware service = (INeutronFirewallPolicyAware) instance;
 274                 service.neutronFirewallPolicyUpdated(updatedFirewallPolicy);
 275             }
 276         }
 277         return Response.status(HttpURLConnection.HTTP_OK).entity(new NeutronFirewallPolicyRequest(firewallPolicyInterface.getNeutronFirewallPolicy(firewallPolicyUUID))).build();
 278     }
 279
 280     /**
 281      * Deletes a Firewall Policy */
 282
 283     @Path("{firewallPolicyUUID}")
 284     @DELETE
 285     @StatusCodes({
 286             @ResponseCode(code = HttpURLConnection.HTTP_NO_CONTENT, condition = "No Content"),
 287             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 288     public Response deleteFirewallPolicy(
 289             @PathParam("firewallPolicyUUID") String firewallPolicyUUID) {
 290         INeutronFirewallPolicyCRUD firewallPolicyInterface = getNeutronInterfaces().getFirewallPolicyInterface();
 291
 292         NeutronFirewallPolicy singleton = firewallPolicyInterface.getNeutronFirewallPolicy(firewallPolicyUUID);
 293         Object[] instances = NeutronUtil.getInstances(INeutronFirewallPolicyAware.class, this);
 294         if (instances != null) {
 295             if (instances.length > 0) {
 296                 for (Object instance : instances) {
 297                     INeutronFirewallPolicyAware service = (INeutronFirewallPolicyAware) instance;
 298                     int status = service.canDeleteNeutronFirewallPolicy(singleton);
 299                     if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 300                         return Response.status(status).build();
 301                     }
 302                 }
 303             } else {
 304                 throw new ServiceUnavailableException(NO_PROVIDERS);
 305             }
 306         } else {
 307             throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 308         }
 309
 310         firewallPolicyInterface.removeNeutronFirewallPolicy(firewallPolicyUUID);
 311         if (instances != null) {
 312             for (Object instance : instances) {
 313                 INeutronFirewallPolicyAware service = (INeutronFirewallPolicyAware) instance;
 314                 service.neutronFirewallPolicyDeleted(singleton);
 315             }
 316         }
 317         return Response.status(HttpURLConnection.HTTP_NO_CONTENT).build();
 318     }
 319 }