northbound-api/src/main/java/org/opendaylight/neutron/northbound/api/NeutronFirewallRulesNorthbound.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 import java.util.Map;
  18
  19 import javax.ws.rs.Consumes;
  20 import javax.ws.rs.DELETE;
  21 import javax.ws.rs.GET;
  22 import javax.ws.rs.POST;
  23 import javax.ws.rs.PUT;
  24 import javax.ws.rs.Path;
  25 import javax.ws.rs.PathParam;
  26 import javax.ws.rs.Produces;
  27 import javax.ws.rs.QueryParam;
  28 import javax.ws.rs.core.MediaType;
  29 import javax.ws.rs.core.Response;
  30
  31 import org.codehaus.enunciate.jaxrs.ResponseCode;
  32 import org.codehaus.enunciate.jaxrs.StatusCodes;
  33 import org.opendaylight.neutron.spi.INeutronFirewallRuleAware;
  34 import org.opendaylight.neutron.spi.INeutronFirewallRuleCRUD;
  35 import org.opendaylight.neutron.spi.NeutronCRUDInterfaces;
  36 import org.opendaylight.neutron.spi.NeutronFirewallRule;
  37
  38 /**
  39  * Neutron Northbound REST APIs for Firewall Rule.<br>
  40  * This class provides REST APIs for managing neutron Firewall Rule
  41  *
  42  * <br>
  43  * <br>
  44  * Authentication scheme : <b>HTTP Basic</b><br>
  45  * Authentication realm : <b>opendaylight</b><br>
  46  * Transport : <b>HTTP and HTTPS</b><br>
  47  * <br>
  48  * HTTPS Authentication is disabled by default. Administrator can enable it in
  49  * tomcat-server.xml after adding a proper keystore / SSL certificate from a
  50  * trusted authority.<br>
  51  * More info :
  52  * http://tomcat.apache.org/tomcat-7.0-doc/ssl-howto.html#Configuration
  53  */
  54
  55 @Path("fw/firewalls_rules")
  56 public class NeutronFirewallRulesNorthbound {
  57     private static final int HTTP_OK_BOTTOM = 200;
  58     private static final int HTTP_OK_TOP = 299;
  59     private static final String INTERFACE_NAME = "Firewall Rule CRUD Interface";
  60     private static final String UUID_NO_EXIST = "Firewall Rule UUID does not exist.";
  61     private static final String UUID_EXISTS = "Firewall Rule UUID already exists.";
  62     private static final String NO_PROVIDERS = "No providers registered.  Please try again later";
  63     private static final String NO_PROVIDER_LIST = "Couldn't get providers list.  Please try again later";
  64
  65
  66     private NeutronFirewallRule extractFields(NeutronFirewallRule o, List<String> fields) {
  67         return o.extractFields(fields);
  68     }
  69
  70     private NeutronCRUDInterfaces getNeutronInterfaces() {
  71         NeutronCRUDInterfaces answer = new NeutronCRUDInterfaces().fetchINeutronFirewallRuleCRUD(this);
  72         if (answer.getFirewallRuleInterface() == null) {
  73             throw new ServiceUnavailableException(INTERFACE_NAME
  74                 + RestMessages.SERVICEUNAVAILABLE.toString());
  75         }
  76         return answer;
  77     }
  78
  79     /**
  80      * Returns a list of all Firewall Rules
  81      */
  82     @GET
  83     @Produces({MediaType.APPLICATION_JSON})
  84     @StatusCodes({
  85             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
  86             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
  87             @ResponseCode(code = HttpURLConnection.HTTP_NOT_IMPLEMENTED, condition = "Not Implemented"),
  88             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
  89     public Response listRules(
  90             // return fields
  91             @QueryParam("fields") List<String> fields,
  92             // OpenStack firewall rule attributes
  93             @QueryParam("id") String queryFirewallRuleUUID,
  94             @QueryParam("tenant_id") String queryFirewallRuleTenantID,
  95             @QueryParam("name") String queryFirewallRuleName,
  96             @QueryParam("description") String queryFirewallRuleDescription,
  97             @QueryParam("status") String queryFirewallRuleStatus,
  98             @QueryParam("shared") Boolean queryFirewallRuleIsShared,
  99             @QueryParam("firewall_policy_id") String queryFirewallRulePolicyID,
 100             @QueryParam("protocol") String queryFirewallRuleProtocol,
 101             @QueryParam("ip_version") Integer queryFirewallRuleIpVer,
 102             @QueryParam("source_ip_address") String queryFirewallRuleSrcIpAddr,
 103             @QueryParam("destination_ip_address") String queryFirewallRuleDstIpAddr,
 104             @QueryParam("source_port") Integer queryFirewallRuleSrcPort,
 105             @QueryParam("destination_port") Integer queryFirewallRuleDstPort,
 106             @QueryParam("position") Integer queryFirewallRulePosition,
 107             @QueryParam("action") String queryFirewallRuleAction,
 108             @QueryParam("enabled") Boolean queryFirewallRuleIsEnabled,
 109             // pagination
 110             @QueryParam("limit") String limit,
 111             @QueryParam("marker") String marker,
 112             @QueryParam("page_reverse") String pageReverse
 113             // sorting not supported
 114     ) {
 115         INeutronFirewallRuleCRUD firewallRuleInterface = getNeutronInterfaces().getFirewallRuleInterface();
 116         List<NeutronFirewallRule> allFirewallRules = firewallRuleInterface.getAllNeutronFirewallRules();
 117         List<NeutronFirewallRule> ans = new ArrayList<NeutronFirewallRule>();
 118         Iterator<NeutronFirewallRule> i = allFirewallRules.iterator();
 119         while (i.hasNext()) {
 120             NeutronFirewallRule nsr = i.next();
 121             if ((queryFirewallRuleUUID == null ||
 122                     queryFirewallRuleUUID.equals(nsr.getFirewallRuleUUID())) &&
 123                     (queryFirewallRuleTenantID == null ||
 124                             queryFirewallRuleTenantID.equals(nsr.getFirewallRuleTenantID())) &&
 125                     (queryFirewallRuleName == null ||
 126                             queryFirewallRuleName.equals(nsr.getFirewallRuleName())) &&
 127                     (queryFirewallRuleDescription == null ||
 128                             queryFirewallRuleDescription.equals(nsr.getFirewallRuleDescription())) &&
 129                     (queryFirewallRuleStatus == null ||
 130                             queryFirewallRuleStatus.equals(nsr.getFirewallRuleStatus())) &&
 131                     (queryFirewallRuleIsShared == null ||
 132                             queryFirewallRuleIsShared.equals(nsr.getFirewallRuleIsShared())) &&
 133                     (queryFirewallRulePolicyID == null ||
 134                             queryFirewallRulePolicyID.equals(nsr.getFirewallRulePolicyID())) &&
 135                     (queryFirewallRuleProtocol == null ||
 136                             queryFirewallRuleProtocol.equals(nsr.getFirewallRuleProtocol())) &&
 137                     (queryFirewallRuleIpVer == null ||
 138                             queryFirewallRuleIpVer.equals(nsr.getFirewallRuleIpVer())) &&
 139                     (queryFirewallRuleSrcIpAddr == null ||
 140                             queryFirewallRuleSrcIpAddr.equals(nsr.getFirewallRuleSrcIpAddr())) &&
 141                     (queryFirewallRuleDstIpAddr == null ||
 142                             queryFirewallRuleDstIpAddr.equals(nsr.getFirewallRuleDstIpAddr())) &&
 143                     (queryFirewallRuleSrcPort == null ||
 144                             queryFirewallRuleSrcPort.equals(nsr.getFirewallRuleSrcPort())) &&
 145                     (queryFirewallRuleDstPort == null ||
 146                             queryFirewallRuleDstPort.equals(nsr.getFirewallRuleDstPort())) &&
 147                     (queryFirewallRulePosition == null ||
 148                             queryFirewallRulePosition.equals(nsr.getFirewallRulePosition())) &&
 149                     (queryFirewallRuleAction == null ||
 150                             queryFirewallRuleAction.equals(nsr.getFirewallRuleAction())) &&
 151                     (queryFirewallRuleIsEnabled == null ||
 152                             queryFirewallRuleIsEnabled.equals(nsr.getFirewallRuleIsEnabled()))) {
 153                 if (fields.size() > 0) {
 154                     ans.add(extractFields(nsr, fields));
 155                 } else {
 156                     ans.add(nsr);
 157                 }
 158             }
 159         }
 160         //TODO: apply pagination to results
 161         return Response.status(HttpURLConnection.HTTP_OK).entity(
 162                 new NeutronFirewallRuleRequest(ans)).build();
 163     }
 164
 165     /**
 166      * Returns a specific Firewall Rule
 167      */
 168
 169     @Path("{firewallRuleUUID}")
 170     @GET
 171     @Produces({MediaType.APPLICATION_JSON})
 172     @StatusCodes({
 173             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 174             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 175             @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 176             @ResponseCode(code = HttpURLConnection.HTTP_NOT_IMPLEMENTED, condition = "Not Implemented"),
 177             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 178     public Response showFirewallRule(@PathParam("firewallRuleUUID") String firewallRuleUUID,
 179             // return fields
 180             @QueryParam("fields") List<String> fields) {
 181         INeutronFirewallRuleCRUD firewallRuleInterface = getNeutronInterfaces().getFirewallRuleInterface();
 182         if (!firewallRuleInterface.neutronFirewallRuleExists(firewallRuleUUID)) {
 183             throw new ResourceNotFoundException(UUID_NO_EXIST);
 184         }
 185         if (fields.size() > 0) {
 186             NeutronFirewallRule ans = firewallRuleInterface.getNeutronFirewallRule(firewallRuleUUID);
 187             return Response.status(HttpURLConnection.HTTP_OK).entity(
 188                     new NeutronFirewallRuleRequest(extractFields(ans, fields))).build();
 189         } else {
 190             return Response.status(HttpURLConnection.HTTP_OK)
 191                     .entity(new NeutronFirewallRuleRequest(
 192                             firewallRuleInterface.getNeutronFirewallRule(firewallRuleUUID)))
 193                     .build();
 194         }
 195     }
 196
 197     /**
 198      * Creates new Firewall Rule
 199      */
 200
 201     @POST
 202     @Produces({MediaType.APPLICATION_JSON})
 203     @Consumes({MediaType.APPLICATION_JSON})
 204     @StatusCodes({
 205             @ResponseCode(code = HttpURLConnection.HTTP_CREATED, condition = "Created"),
 206             @ResponseCode(code = HttpURLConnection.HTTP_BAD_REQUEST, condition = "Bad Request"),
 207             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 208             @ResponseCode(code = HttpURLConnection.HTTP_FORBIDDEN, condition = "Forbidden"),
 209             @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 210             @ResponseCode(code = HttpURLConnection.HTTP_CONFLICT, condition = "Conflict"),
 211             @ResponseCode(code = HttpURLConnection.HTTP_NOT_IMPLEMENTED, condition = "Not Implemented"),
 212             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 213     public Response createFirewallRules(final NeutronFirewallRuleRequest input) {
 214         INeutronFirewallRuleCRUD firewallRuleInterface = getNeutronInterfaces().getFirewallRuleInterface();
 215
 216         if (input.isSingleton()) {
 217             NeutronFirewallRule singleton = input.getSingleton();
 218             if (firewallRuleInterface.neutronFirewallRuleExists(singleton.getFirewallRuleUUID())) {
 219                 throw new BadRequestException(UUID_EXISTS);
 220             }
 221             firewallRuleInterface.addNeutronFirewallRule(singleton);
 222             Object[] instances = NeutronUtil.getInstances(INeutronFirewallRuleAware.class, this);
 223             if (instances != null) {
 224                 if (instances.length > 0) {
 225                     for (Object instance : instances) {
 226                         INeutronFirewallRuleAware service = (INeutronFirewallRuleAware) instance;
 227                         int status = service.canCreateNeutronFirewallRule(singleton);
 228                         if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 229                             return Response.status(status).build();
 230                         }
 231                     }
 232                 } else {
 233                     throw new ServiceUnavailableException(NO_PROVIDERS);
 234                 }
 235             } else {
 236                 throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 237             }
 238             // add rule to cache
 239             singleton.initDefaults();
 240             firewallRuleInterface.addNeutronFirewallRule(singleton);
 241             if (instances != null) {
 242                 for (Object instance : instances) {
 243                     INeutronFirewallRuleAware service = (INeutronFirewallRuleAware) instance;
 244                     service.neutronFirewallRuleCreated(singleton);
 245                 }
 246             }
 247         } else {
 248             List<NeutronFirewallRule> bulk = input.getBulk();
 249             Iterator<NeutronFirewallRule> i = bulk.iterator();
 250             Map<String, NeutronFirewallRule> testMap = new HashMap<String, NeutronFirewallRule>();
 251             Object[] instances = NeutronUtil.getInstances(INeutronFirewallRuleAware.class, this);
 252             while (i.hasNext()) {
 253                 NeutronFirewallRule test = i.next();
 254
 255                 /*
 256                  *  Verify that the Firewall rule doesn't already exist
 257                  */
 258
 259                 if (firewallRuleInterface.neutronFirewallRuleExists(test.getFirewallRuleUUID())) {
 260                     throw new BadRequestException(UUID_EXISTS);
 261                 }
 262                 if (testMap.containsKey(test.getFirewallRuleUUID())) {
 263                     throw new BadRequestException(UUID_EXISTS);
 264                 }
 265                 if (instances != null) {
 266                     if (instances.length > 0) {
 267                         for (Object instance : instances) {
 268                             INeutronFirewallRuleAware service = (INeutronFirewallRuleAware) instance;
 269                             int status = service.canCreateNeutronFirewallRule(test);
 270                             if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 271                                 return Response.status(status).build();
 272                             }
 273                         }
 274                     } else {
 275                         throw new ServiceUnavailableException(NO_PROVIDERS);
 276                     }
 277                 } else {
 278                     throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 279                 }
 280             }
 281             /*
 282              * now, each element of the bulk request can be added to the cache
 283              */
 284             i = bulk.iterator();
 285             while (i.hasNext()) {
 286                 NeutronFirewallRule test = i.next();
 287                 firewallRuleInterface.addNeutronFirewallRule(test);
 288                 if (instances != null) {
 289                     for (Object instance : instances) {
 290                         INeutronFirewallRuleAware service = (INeutronFirewallRuleAware) instance;
 291                         service.neutronFirewallRuleCreated(test);
 292                     }
 293                 }
 294             }
 295         }
 296         return Response.status(HttpURLConnection.HTTP_CREATED).entity(input).build();
 297     }
 298
 299     /**
 300      * Updates a Firewall Rule
 301      */
 302     @Path("{firewallRuleUUID}")
 303     @PUT
 304     @Produces({MediaType.APPLICATION_JSON})
 305     @Consumes({MediaType.APPLICATION_JSON})
 306     @StatusCodes({
 307             @ResponseCode(code = HttpURLConnection.HTTP_OK, condition = "Operation successful"),
 308             @ResponseCode(code = HttpURLConnection.HTTP_BAD_REQUEST, condition = "Bad Request"),
 309             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 310             @ResponseCode(code = HttpURLConnection.HTTP_FORBIDDEN, condition = "Forbidden"),
 311             @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 312             @ResponseCode(code = HttpURLConnection.HTTP_NOT_IMPLEMENTED, condition = "Not Implemented"),
 313             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 314     public Response updateFirewallRule(
 315             @PathParam("firewallRuleUUID") String firewallRuleUUID, final NeutronFirewallRuleRequest input) {
 316         INeutronFirewallRuleCRUD firewallRuleInterface = getNeutronInterfaces().getFirewallRuleInterface();
 317         /*
 318          * verify the Firewall Rule exists
 319          */
 320         if (!firewallRuleInterface.neutronFirewallRuleExists(firewallRuleUUID)) {
 321             throw new ResourceNotFoundException(UUID_NO_EXIST);
 322         }
 323         if (!input.isSingleton()) {
 324             throw new BadRequestException("Only singleton edit supported");
 325         }
 326         NeutronFirewallRule delta = input.getSingleton();
 327         NeutronFirewallRule original = firewallRuleInterface.getNeutronFirewallRule(firewallRuleUUID);
 328
 329         /*
 330          * updates restricted by Neutron
 331          *
 332          */
 333         if (delta.getFirewallRuleUUID() != null ||
 334                 delta.getFirewallRuleTenantID() != null ||
 335                 delta.getFirewallRuleName() != null ||
 336                 delta.getFirewallRuleDescription() != null ||
 337                 delta.getFirewallRuleStatus() != null ||
 338                 delta.getFirewallRuleIsShared() != null ||
 339                 delta.getFirewallRulePolicyID() != null ||
 340                 delta.getFirewallRuleProtocol() != null ||
 341                 delta.getFirewallRuleIpVer() != null ||
 342                 delta.getFirewallRuleSrcIpAddr() != null ||
 343                 delta.getFirewallRuleDstIpAddr() != null ||
 344                 delta.getFirewallRuleSrcPort() != null ||
 345                 delta.getFirewallRuleDstPort() != null ||
 346                 delta.getFirewallRulePosition() != null ||
 347                 delta.getFirewallRuleAction() != null ||
 348                 delta.getFirewallRuleIsEnabled() != null) {
 349             throw new BadRequestException("Attribute edit blocked by Neutron");
 350         }
 351
 352         Object[] instances = NeutronUtil.getInstances(INeutronFirewallRuleAware.class, this);
 353         if (instances != null) {
 354             if (instances.length > 0) {
 355                 for (Object instance : instances) {
 356                     INeutronFirewallRuleAware service = (INeutronFirewallRuleAware) instance;
 357                     int status = service.canUpdateNeutronFirewallRule(delta, original);
 358                     if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 359                         return Response.status(status).build();
 360                     }
 361                 }
 362             } else {
 363                 throw new ServiceUnavailableException(NO_PROVIDERS);
 364             }
 365         } else {
 366             throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 367         }
 368
 369         /*
 370          * update the object and return it
 371          */
 372         firewallRuleInterface.updateNeutronFirewallRule(firewallRuleUUID, delta);
 373         NeutronFirewallRule updatedFirewallRule = firewallRuleInterface.getNeutronFirewallRule(firewallRuleUUID);
 374         if (instances != null) {
 375             for (Object instance : instances) {
 376                 INeutronFirewallRuleAware service = (INeutronFirewallRuleAware) instance;
 377                 service.neutronFirewallRuleUpdated(updatedFirewallRule);
 378             }
 379         }
 380         return Response.status(HttpURLConnection.HTTP_OK)
 381                 .entity(new NeutronFirewallRuleRequest(firewallRuleInterface.getNeutronFirewallRule(firewallRuleUUID)))
 382                 .build();
 383     }
 384
 385     /**
 386      * Deletes a Firewall Rule
 387      */
 388
 389     @Path("{firewallRuleUUID}")
 390     @DELETE
 391     @StatusCodes({
 392             @ResponseCode(code = HttpURLConnection.HTTP_NO_CONTENT, condition = "No Content"),
 393             @ResponseCode(code = HttpURLConnection.HTTP_UNAUTHORIZED, condition = "Unauthorized"),
 394             @ResponseCode(code = HttpURLConnection.HTTP_NOT_FOUND, condition = "Not Found"),
 395             @ResponseCode(code = HttpURLConnection.HTTP_CONFLICT, condition = "Conflict"),
 396             @ResponseCode(code = HttpURLConnection.HTTP_NOT_IMPLEMENTED, condition = "Not Implemented"),
 397             @ResponseCode(code = HttpURLConnection.HTTP_UNAVAILABLE, condition = "No providers available") })
 398     public Response deleteFirewallRule(
 399             @PathParam("firewallRuleUUID") String firewallRuleUUID) {
 400         INeutronFirewallRuleCRUD firewallRuleInterface = getNeutronInterfaces().getFirewallRuleInterface();
 401
 402         /*
 403          * verify the Firewall Rule exists and it isn't currently in use
 404          */
 405         if (!firewallRuleInterface.neutronFirewallRuleExists(firewallRuleUUID)) {
 406             throw new ResourceNotFoundException(UUID_NO_EXIST);
 407         }
 408         if (firewallRuleInterface.neutronFirewallRuleInUse(firewallRuleUUID)) {
 409             return Response.status(HttpURLConnection.HTTP_CONFLICT).build();
 410         }
 411         NeutronFirewallRule singleton = firewallRuleInterface.getNeutronFirewallRule(firewallRuleUUID);
 412         Object[] instances = NeutronUtil.getInstances(INeutronFirewallRuleAware.class, this);
 413         if (instances != null) {
 414             if (instances.length > 0) {
 415                 for (Object instance : instances) {
 416                     INeutronFirewallRuleAware service = (INeutronFirewallRuleAware) instance;
 417                     int status = service.canDeleteNeutronFirewallRule(singleton);
 418                     if (status < HTTP_OK_BOTTOM || status > HTTP_OK_TOP) {
 419                         return Response.status(status).build();
 420                     }
 421                 }
 422             } else {
 423                 throw new ServiceUnavailableException(NO_PROVIDERS);
 424             }
 425         } else {
 426             throw new ServiceUnavailableException(NO_PROVIDER_LIST);
 427         }
 428
 429         /*
 430          * remove it and return 204 status
 431          */
 432         firewallRuleInterface.removeNeutronFirewallRule(firewallRuleUUID);
 433         if (instances != null) {
 434             for (Object instance : instances) {
 435                 INeutronFirewallRuleAware service = (INeutronFirewallRuleAware) instance;
 436                 service.neutronFirewallRuleDeleted(singleton);
 437             }
 438         }
 439         return Response.status(HttpURLConnection.HTTP_NO_CONTENT).build();
 440     }
 441 }