opendaylight/networkconfiguration/neutron/northbound/src/main/java/org/opendaylight/controller/networkconfig/neutron/northbound/NeutronFirewallPolicyNorthbound.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.controller.networkconfig.neutron.northbound;
  10
  11
  12 import java.util.ArrayList;
  13 import java.util.HashMap;
  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.controller.networkconfig.neutron.INeutronFirewallPolicyAware;
  32 import org.opendaylight.controller.networkconfig.neutron.INeutronFirewallPolicyCRUD;
  33 import org.opendaylight.controller.networkconfig.neutron.NeutronCRUDInterfaces;
  34 import org.opendaylight.controller.networkconfig.neutron.NeutronFirewallPolicy;
  35
  36 /**
  37  * Neutron Northbound REST APIs for Firewall Policies.<br>
  38  * This class provides REST APIs for managing neutron Firewall Policies
  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("/fw/firewalls_policies")
  54 public class NeutronFirewallPolicyNorthbound {
  55
  56     private NeutronFirewallPolicy extractFields(NeutronFirewallPolicy o, List<String> fields) {
  57         return o.extractFields(fields);
  58     }
  59
  60     /**
  61      * Returns a list of all Firewall Policies */
  62     @GET
  63     @Produces({ MediaType.APPLICATION_JSON })
  64     @StatusCodes({
  65             @ResponseCode(code = 200, condition = "Operation successful"),
  66             @ResponseCode(code = 401, condition = "Unauthorized"),
  67             @ResponseCode(code = 501, condition = "Not Implemented") })
  68
  69     public Response listGroups(
  70             // return fields
  71             @QueryParam("fields") List<String> fields,
  72             // OpenStack Firewall Policy attributes
  73             @QueryParam("id") String queryFirewallPolicyUUID,
  74             @QueryParam("tenant_id") String queryFirewallPolicyTenantID,
  75             @QueryParam("name") String queryFirewallPolicyName,
  76             @QueryParam("description") String querySecurityPolicyDescription,
  77             @QueryParam("shared") String querySecurityPolicyIsShared,
  78             @QueryParam("firewall_rules") List<String> querySecurityPolicyFirewallRules,
  79             @QueryParam("audited") Boolean querySecurityPolicyIsAudited,
  80             // pagination
  81             @QueryParam("limit") String limit,
  82             @QueryParam("marker") String marker,
  83             @QueryParam("page_reverse") String pageReverse
  84             // sorting not supported
  85     ) {
  86         INeutronFirewallPolicyCRUD firewallPolicyInterface = NeutronCRUDInterfaces.getINeutronFirewallPolicyCRUD(this);
  87
  88         if (firewallPolicyInterface == null) {
  89             throw new ServiceUnavailableException("Firewall Policy CRUD Interface "
  90                 + RestMessages.SERVICEUNAVAILABLE.toString());
  91         }
  92         List<NeutronFirewallPolicy> allFirewallPolicies = firewallPolicyInterface.getAllNeutronFirewallPolicies();
  93         List<NeutronFirewallPolicy> ans = new ArrayList<NeutronFirewallPolicy>();
  94         Iterator<NeutronFirewallPolicy> i = allFirewallPolicies.iterator();
  95         while (i.hasNext()) {
  96             NeutronFirewallPolicy nsg = i.next();
  97             if ((queryFirewallPolicyUUID == null ||
  98                 queryFirewallPolicyUUID.equals(nsg.getFirewallPolicyUUID())) &&
  99                 (queryFirewallPolicyTenantID == null ||
 100                     queryFirewallPolicyTenantID.equals(nsg.getFirewallPolicyTenantID())) &&
 101                 (queryFirewallPolicyName == null ||
 102                     queryFirewallPolicyName.equals(nsg.getFirewallPolicyName())) &&
 103                 (querySecurityPolicyDescription == null ||
 104                     querySecurityPolicyDescription.equals(nsg.getFirewallPolicyDescription())) &&
 105                 (querySecurityPolicyIsShared == null ||
 106                     querySecurityPolicyIsShared.equals(nsg.getFirewallPolicyIsShared())) &&
 107                 (querySecurityPolicyFirewallRules.size() == 0 ||
 108                     querySecurityPolicyFirewallRules.equals(nsg.getFirewallPolicyRules())) &&
 109                 (querySecurityPolicyIsAudited == null ||
 110                     querySecurityPolicyIsAudited.equals(nsg.getFirewallPolicyIsAudited()))) {
 111                 if (fields.size() > 0) {
 112                     ans.add(extractFields(nsg,fields));
 113                 } else {
 114                     ans.add(nsg);
 115                 }
 116             }
 117         } // ans.add((NeutronFirewallPolicy) rules);
 118         //TODO: apply pagination to results
 119         return Response.status(200).entity(
 120                 new NeutronFirewallPolicyRequest(ans)).build();
 121     }
 122
 123     /**
 124      * Returns a specific Firewall Policy */
 125
 126     @Path("{firewallPolicyUUID}")
 127     @GET
 128     @Produces({ MediaType.APPLICATION_JSON })
 129     @StatusCodes({
 130             @ResponseCode(code = 200, condition = "Operation successful"),
 131             @ResponseCode(code = 401, condition = "Unauthorized"),
 132             @ResponseCode(code = 404, condition = "Not Found"),
 133             @ResponseCode(code = 501, condition = "Not Implemented") })
 134     public Response showFirewallPolicy(@PathParam("firewallPolicyUUID") String firewallPolicyUUID,
 135                                       // return fields
 136                                       @QueryParam("fields") List<String> fields) {
 137         INeutronFirewallPolicyCRUD firewallPolicyInterface = NeutronCRUDInterfaces.getINeutronFirewallPolicyCRUD(this);
 138         if (firewallPolicyInterface == null) {
 139             throw new ServiceUnavailableException("Firewall Policy CRUD Interface "
 140                     + RestMessages.SERVICEUNAVAILABLE.toString());
 141         }
 142         if (!firewallPolicyInterface.neutronFirewallPolicyExists(firewallPolicyUUID)) {
 143             throw new ResourceNotFoundException("Firewall Policy UUID does not exist.");
 144         }
 145         if (fields.size() > 0) {
 146             NeutronFirewallPolicy ans = firewallPolicyInterface.getNeutronFirewallPolicy(firewallPolicyUUID);
 147             return Response.status(200).entity(
 148                     new NeutronFirewallPolicyRequest(extractFields(ans, fields))).build();
 149         } else {
 150             return Response.status(200).entity(new NeutronFirewallPolicyRequest(firewallPolicyInterface.getNeutronFirewallPolicy(firewallPolicyUUID))).build();
 151         }
 152     }
 153
 154     /**
 155      * Creates new Firewall Policy
 156      * */
 157     @POST
 158     @Produces({ MediaType.APPLICATION_JSON })
 159     @Consumes({ MediaType.APPLICATION_JSON })
 160     @StatusCodes({
 161             @ResponseCode(code = 201, condition = "Created"),
 162             @ResponseCode(code = 400, condition = "Bad Request"),
 163             @ResponseCode(code = 401, condition = "Unauthorized"),
 164             @ResponseCode(code = 403, condition = "Forbidden"),
 165             @ResponseCode(code = 404, condition = "Not Found"),
 166             @ResponseCode(code = 409, condition = "Conflict"),
 167             @ResponseCode(code = 501, condition = "Not Implemented") })
 168     public Response createFirewallPolicies(final NeutronFirewallPolicyRequest input) {
 169         INeutronFirewallPolicyCRUD firewallPolicyInterface = NeutronCRUDInterfaces.getINeutronFirewallPolicyCRUD(this);
 170         if (firewallPolicyInterface == null) {
 171             throw new ServiceUnavailableException("Firewall Policy CRUD Interface "
 172                     + RestMessages.SERVICEUNAVAILABLE.toString());
 173         }
 174         if (input.isSingleton()) {
 175             NeutronFirewallPolicy singleton = input.getSingleton();
 176
 177             /*
 178              *  Verify that the Firewall Policy doesn't already exist.
 179              */
 180             if (firewallPolicyInterface.neutronFirewallPolicyExists(singleton.getFirewallPolicyUUID())) {
 181                 throw new BadRequestException("Firewall Policy UUID already exists");
 182             }
 183             firewallPolicyInterface.addNeutronFirewallPolicy(singleton);
 184
 185             Object[] instances = NeutronUtil.getInstances(INeutronFirewallPolicyAware.class, this);
 186             if (instances != null) {
 187                 for (Object instance : instances) {
 188                     INeutronFirewallPolicyAware service = (INeutronFirewallPolicyAware) instance;
 189                     int status = service.canCreateNeutronFirewallPolicy(singleton);
 190                     if (status < 200 || status > 299) {
 191                         return Response.status(status).build();
 192                     }
 193                 }
 194             }
 195             firewallPolicyInterface.addNeutronFirewallPolicy(singleton);
 196             if (instances != null) {
 197                 for (Object instance : instances) {
 198                     INeutronFirewallPolicyAware service = (INeutronFirewallPolicyAware) instance;
 199                     service.neutronFirewallPolicyCreated(singleton);
 200                 }
 201             }
 202         } else {
 203             List<NeutronFirewallPolicy> bulk = input.getBulk();
 204             Iterator<NeutronFirewallPolicy> i = bulk.iterator();
 205             HashMap<String, NeutronFirewallPolicy> testMap = new HashMap<String, NeutronFirewallPolicy>();
 206             Object[] instances = NeutronUtil.getInstances(INeutronFirewallPolicyAware.class, this);
 207             while (i.hasNext()) {
 208                 NeutronFirewallPolicy test = i.next();
 209
 210                 /*
 211                  *  Verify that the firewall policy doesn't already exist
 212                  */
 213
 214                 if (firewallPolicyInterface.neutronFirewallPolicyExists(test.getFirewallPolicyUUID())) {
 215                     throw new BadRequestException("Firewall Policy UUID already is already created");
 216                 }
 217                 if (testMap.containsKey(test.getFirewallPolicyUUID())) {
 218                     throw new BadRequestException("Firewall Policy UUID already exists");
 219                 }
 220                 if (instances != null) {
 221                     for (Object instance : instances) {
 222                         INeutronFirewallPolicyAware service = (INeutronFirewallPolicyAware) instance;
 223                         int status = service.canCreateNeutronFirewallPolicy(test);
 224                         if (status < 200 || status > 299) {
 225                             return Response.status(status).build();
 226                         }
 227                     }
 228                 }
 229             }
 230             /*
 231              * now, each element of the bulk request can be added to the cache
 232              */
 233             i = bulk.iterator();
 234             while (i.hasNext()) {
 235                 NeutronFirewallPolicy test = i.next();
 236                 firewallPolicyInterface.addNeutronFirewallPolicy(test);
 237                 if (instances != null) {
 238                     for (Object instance : instances) {
 239                         INeutronFirewallPolicyAware service = (INeutronFirewallPolicyAware) instance;
 240                         service.neutronFirewallPolicyCreated(test);
 241                     }
 242                 }
 243             }
 244         }
 245         return Response.status(201).entity(input).build();
 246     }
 247
 248     /**
 249      * Updates a Firewall Policy
 250      */
 251     @Path("{firewallPolicyUUID}")
 252     @PUT
 253     @Produces({ MediaType.APPLICATION_JSON })
 254     @Consumes({ MediaType.APPLICATION_JSON })
 255     //@TypeHint(OpenStackSubnets.class)
 256     @StatusCodes({
 257             @ResponseCode(code = 200, condition = "Operation successful"),
 258             @ResponseCode(code = 400, condition = "Bad Request"),
 259             @ResponseCode(code = 401, condition = "Unauthorized"),
 260             @ResponseCode(code = 403, condition = "Forbidden"),
 261             @ResponseCode(code = 404, condition = "Not Found"),
 262             @ResponseCode(code = 501, condition = "Not Implemented") })
 263     public Response updateFirewallPolicy(
 264             @PathParam("firewallPolicyUUID") String firewallPolicyUUID, final NeutronFirewallPolicyRequest input) {
 265         INeutronFirewallPolicyCRUD firewallPolicyInterface = NeutronCRUDInterfaces.getINeutronFirewallPolicyCRUD(this);
 266         if (firewallPolicyInterface == null) {
 267             throw new ServiceUnavailableException("Firewall Policy CRUD Interface "
 268                     + RestMessages.SERVICEUNAVAILABLE.toString());
 269         }
 270
 271         /*
 272          * verify the Firewall Policy exists and there is only one delta provided
 273          */
 274         if (!firewallPolicyInterface.neutronFirewallPolicyExists(firewallPolicyUUID)) {
 275             throw new ResourceNotFoundException("Firewall Policy UUID does not exist.");
 276         }
 277         if (!input.isSingleton()) {
 278             throw new BadRequestException("Only singleton edit supported");
 279         }
 280         NeutronFirewallPolicy delta = input.getSingleton();
 281         NeutronFirewallPolicy original = firewallPolicyInterface.getNeutronFirewallPolicy(firewallPolicyUUID);
 282
 283         /*
 284          * updates restricted by Neutron
 285          */
 286         if (delta.getFirewallPolicyUUID() != null ||
 287                 delta.getFirewallPolicyTenantID() != null ||
 288                 delta.getFirewallPolicyName() != null ||
 289                 delta.getFirewallPolicyDescription() != null ||
 290                 delta.getFirewallPolicyIsShared() != null ||
 291                 delta.getFirewallPolicyRules().size() > 0 ||
 292                 delta.getFirewallPolicyIsAudited() != null) {
 293             throw new BadRequestException("Attribute edit blocked by Neutron");
 294         }
 295
 296         Object[] instances = NeutronUtil.getInstances(INeutronFirewallPolicyAware.class, this);
 297         if (instances != null) {
 298             for (Object instance : instances) {
 299                 INeutronFirewallPolicyAware service = (INeutronFirewallPolicyAware) instance;
 300                 int status = service.canUpdateNeutronFirewallPolicy(delta, original);
 301                 if (status < 200 || status > 299) {
 302                     return Response.status(status).build();
 303                 }
 304             }
 305         }
 306
 307         /*
 308          * update the object and return it
 309          */
 310         firewallPolicyInterface.updateNeutronFirewallPolicy(firewallPolicyUUID, delta);
 311         NeutronFirewallPolicy updatedFirewallPolicy = firewallPolicyInterface.getNeutronFirewallPolicy(firewallPolicyUUID);
 312         if (instances != null) {
 313             for (Object instance : instances) {
 314                 INeutronFirewallPolicyAware service = (INeutronFirewallPolicyAware) instance;
 315                 service.neutronFirewallPolicyUpdated(updatedFirewallPolicy);
 316             }
 317         }
 318         return Response.status(200).entity(new NeutronFirewallPolicyRequest(firewallPolicyInterface.getNeutronFirewallPolicy(firewallPolicyUUID))).build();
 319     }
 320
 321     /**
 322      * Deletes a Firewall Policy */
 323
 324     @Path("{firewallPolicyUUID}")
 325     @DELETE
 326     @StatusCodes({
 327             @ResponseCode(code = 204, condition = "No Content"),
 328             @ResponseCode(code = 401, condition = "Unauthorized"),
 329             @ResponseCode(code = 404, condition = "Not Found"),
 330             @ResponseCode(code = 409, condition = "Conflict"),
 331             @ResponseCode(code = 501, condition = "Not Implemented") })
 332     public Response deleteFirewallPolicy(
 333             @PathParam("firewallPolicyUUID") String firewallPolicyUUID) {
 334         INeutronFirewallPolicyCRUD firewallPolicyInterface = NeutronCRUDInterfaces.getINeutronFirewallPolicyCRUD(this);
 335         if (firewallPolicyInterface == null) {
 336             throw new ServiceUnavailableException("Firewall Policy CRUD Interface "
 337                     + RestMessages.SERVICEUNAVAILABLE.toString());
 338         }
 339
 340         /*
 341          * verify the Firewall Policy exists and it isn't currently in use
 342          */
 343         if (!firewallPolicyInterface.neutronFirewallPolicyExists(firewallPolicyUUID)) {
 344             throw new ResourceNotFoundException("Firewall Policy UUID does not exist.");
 345         }
 346         if (firewallPolicyInterface.neutronFirewallPolicyInUse(firewallPolicyUUID)) {
 347             return Response.status(409).build();
 348         }
 349         NeutronFirewallPolicy singleton = firewallPolicyInterface.getNeutronFirewallPolicy(firewallPolicyUUID);
 350         Object[] instances = NeutronUtil.getInstances(INeutronFirewallPolicyAware.class, this);
 351         if (instances != null) {
 352             for (Object instance : instances) {
 353                 INeutronFirewallPolicyAware service = (INeutronFirewallPolicyAware) instance;
 354                 int status = service.canDeleteNeutronFirewallPolicy(singleton);
 355                 if (status < 200 || status > 299) {
 356                     return Response.status(status).build();
 357                 }
 358             }
 359         }
 360
 361         firewallPolicyInterface.removeNeutronFirewallPolicy(firewallPolicyUUID);
 362         if (instances != null) {
 363             for (Object instance : instances) {
 364                 INeutronFirewallPolicyAware service = (INeutronFirewallPolicyAware) instance;
 365                 service.neutronFirewallPolicyDeleted(singleton);
 366             }
 367         }
 368         return Response.status(204).build();
 369     }
 370 }