opendaylight/networkconfiguration/neutron/northbound/src/main/java/org/opendaylight/controller/networkconfig/neutron/northbound/NeutronNetworksNorthbound.java

   1 /*
   2  * Copyright IBM Corporation, 2013.  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.controller.networkconfig.neutron.northbound;
  10
  11 import java.util.ArrayList;
  12 import java.util.HashMap;
  13 import java.util.Iterator;
  14 import java.util.List;
  15
  16 import javax.ws.rs.Consumes;
  17 import javax.ws.rs.DELETE;
  18 import javax.ws.rs.DefaultValue;
  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.Context;
  27 import javax.ws.rs.core.MediaType;
  28 import javax.ws.rs.core.Response;
  29 import javax.ws.rs.core.UriInfo;
  30
  31 import org.codehaus.enunciate.jaxrs.ResponseCode;
  32 import org.codehaus.enunciate.jaxrs.StatusCodes;
  33 import org.codehaus.enunciate.jaxrs.TypeHint;
  34 import org.opendaylight.controller.networkconfig.neutron.INeutronNetworkAware;
  35 import org.opendaylight.controller.networkconfig.neutron.INeutronNetworkCRUD;
  36 import org.opendaylight.controller.networkconfig.neutron.NeutronCRUDInterfaces;
  37 import org.opendaylight.controller.networkconfig.neutron.NeutronNetwork;
  38
  39 /**
  40  * Neutron Northbound REST APIs for Network.<br>
  41  * This class provides REST APIs for managing neutron Networks
  42  *
  43  * <br>
  44  * <br>
  45  * Authentication scheme : <b>HTTP Basic</b><br>
  46  * Authentication realm : <b>opendaylight</b><br>
  47  * Transport : <b>HTTP and HTTPS</b><br>
  48  * <br>
  49  * HTTPS Authentication is disabled by default. Administrator can enable it in
  50  * tomcat-server.xml after adding a proper keystore / SSL certificate from a
  51  * trusted authority.<br>
  52  * More info :
  53  * http://tomcat.apache.org/tomcat-7.0-doc/ssl-howto.html#Configuration
  54  *
  55  */
  56
  57 @Path("/networks")
  58 public class NeutronNetworksNorthbound {
  59
  60     @Context
  61     UriInfo uriInfo;
  62
  63     private NeutronNetwork extractFields(NeutronNetwork o, List<String> fields) {
  64         return o.extractFields(fields);
  65     }
  66
  67     /**
  68      * Returns a list of all Networks */
  69
  70     @GET
  71     @Produces({ MediaType.APPLICATION_JSON })
  72     //@TypeHint(OpenStackNetworks.class)
  73     @StatusCodes({
  74         @ResponseCode(code = 200, condition = "Operation successful"),
  75         @ResponseCode(code = 401, condition = "Unauthorized")})
  76     public Response listNetworks(
  77             // return fields
  78             @QueryParam("fields") List<String> fields,
  79             // note: openstack isn't clear about filtering on lists, so we aren't handling them
  80             @QueryParam("id") String queryID,
  81             @QueryParam("name") String queryName,
  82             @QueryParam("admin_state_up") String queryAdminStateUp,
  83             @QueryParam("status") String queryStatus,
  84             @QueryParam("shared") String queryShared,
  85             @QueryParam("tenant_id") String queryTenantID,
  86             @QueryParam("router_external") String queryRouterExternal,
  87             @QueryParam("provider_network_type") String queryProviderNetworkType,
  88             @QueryParam("provider_physical_network") String queryProviderPhysicalNetwork,
  89             @QueryParam("provider_segmentation_id") String queryProviderSegmentationID,
  90             // linkTitle
  91             @QueryParam("limit") Integer limit,
  92             @QueryParam("marker") String marker,
  93             @DefaultValue("false") @QueryParam("page_reverse") Boolean pageReverse
  94             // sorting not supported
  95             ) {
  96         INeutronNetworkCRUD networkInterface = NeutronCRUDInterfaces.getINeutronNetworkCRUD(this);
  97         if (networkInterface == null) {
  98             throw new ServiceUnavailableException("Network CRUD Interface "
  99                     + RestMessages.SERVICEUNAVAILABLE.toString());
 100         }
 101         List<NeutronNetwork> allNetworks = networkInterface.getAllNetworks();
 102         List<NeutronNetwork> ans = new ArrayList<NeutronNetwork>();
 103         Iterator<NeutronNetwork> i = allNetworks.iterator();
 104         while (i.hasNext()) {
 105             NeutronNetwork oSN = i.next();
 106             //match filters: TODO provider extension
 107             Boolean bAdminStateUp = null;
 108             Boolean bShared = null;
 109             Boolean bRouterExternal = null;
 110             if (queryAdminStateUp != null) {
 111                 bAdminStateUp = Boolean.valueOf(queryAdminStateUp);
 112             }
 113             if (queryShared != null) {
 114                 bShared = Boolean.valueOf(queryShared);
 115             }
 116             if (queryRouterExternal != null) {
 117                 bRouterExternal = Boolean.valueOf(queryRouterExternal);
 118             }
 119             if ((queryID == null || queryID.equals(oSN.getID())) &&
 120                     (queryName == null || queryName.equals(oSN.getNetworkName())) &&
 121                     (bAdminStateUp == null || bAdminStateUp.booleanValue() == oSN.isAdminStateUp()) &&
 122                     (queryStatus == null || queryStatus.equals(oSN.getStatus())) &&
 123                     (bShared == null || bShared.booleanValue() == oSN.isShared()) &&
 124                     (bRouterExternal == null || bRouterExternal.booleanValue() == oSN.isRouterExternal()) &&
 125                     (queryTenantID == null || queryTenantID.equals(oSN.getTenantID()))) {
 126                 if (fields.size() > 0) {
 127                     ans.add(extractFields(oSN,fields));
 128                 } else {
 129                     ans.add(oSN);
 130                 }
 131             }
 132         }
 133
 134         if (limit != null && ans.size() > 1) {
 135             // Return a paginated request
 136             NeutronNetworkRequest request = (NeutronNetworkRequest) PaginatedRequestFactory.createRequest(limit,
 137                     marker, pageReverse, uriInfo, ans, NeutronNetwork.class);
 138             return Response.status(200).entity(request).build();
 139         }
 140
 141     return Response.status(200).entity(new NeutronNetworkRequest(ans)).build();
 142
 143     }
 144
 145     /**
 146      * Returns a specific Network */
 147
 148     @Path("{netUUID}")
 149     @GET
 150     @Produces({ MediaType.APPLICATION_JSON })
 151     //@TypeHint(OpenStackNetworks.class)
 152     @StatusCodes({
 153         @ResponseCode(code = 200, condition = "Operation successful"),
 154         @ResponseCode(code = 401, condition = "Unauthorized"),
 155         @ResponseCode(code = 404, condition = "Not Found") })
 156     public Response showNetwork(
 157             @PathParam("netUUID") String netUUID,
 158             // return fields
 159             @QueryParam("fields") List<String> fields
 160             ) {
 161         INeutronNetworkCRUD networkInterface = NeutronCRUDInterfaces.getINeutronNetworkCRUD( this);
 162         if (networkInterface == null) {
 163             throw new ServiceUnavailableException("Network CRUD Interface "
 164                     + RestMessages.SERVICEUNAVAILABLE.toString());
 165         }
 166         if (!networkInterface.networkExists(netUUID)) {
 167             throw new ResourceNotFoundException("network UUID does not exist.");
 168         }
 169         if (fields.size() > 0) {
 170             NeutronNetwork ans = networkInterface.getNetwork(netUUID);
 171             return Response.status(200).entity(
 172                     new NeutronNetworkRequest(extractFields(ans, fields))).build();
 173         } else {
 174             return Response.status(200).entity(
 175                     new NeutronNetworkRequest(networkInterface.getNetwork(netUUID))).build();
 176         }
 177     }
 178
 179     /**
 180      * Creates new Networks */
 181     @POST
 182     @Produces({ MediaType.APPLICATION_JSON })
 183     @Consumes({ MediaType.APPLICATION_JSON })
 184     @TypeHint(NeutronNetwork.class)
 185     @StatusCodes({
 186         @ResponseCode(code = 201, condition = "Created"),
 187         @ResponseCode(code = 400, condition = "Bad Request"),
 188         @ResponseCode(code = 401, condition = "Unauthorized") })
 189     public Response createNetworks(final NeutronNetworkRequest input) {
 190         INeutronNetworkCRUD networkInterface = NeutronCRUDInterfaces.getINeutronNetworkCRUD( this);
 191         if (networkInterface == null) {
 192             throw new ServiceUnavailableException("Network CRUD Interface "
 193                     + RestMessages.SERVICEUNAVAILABLE.toString());
 194         }
 195         if (input.isSingleton()) {
 196             NeutronNetwork singleton = input.getSingleton();
 197
 198             /*
 199              * network ID can't already exist
 200              */
 201             if (networkInterface.networkExists(singleton.getID())) {
 202                 throw new BadRequestException("network UUID already exists");
 203             }
 204
 205             Object[] instances = NeutronUtil.getInstances(INeutronNetworkAware.class, this);
 206             if (instances != null) {
 207                 for (Object instance : instances) {
 208                     INeutronNetworkAware service = (INeutronNetworkAware) instance;
 209                     int status = service.canCreateNetwork(singleton);
 210                     if (status < 200 || status > 299) {
 211                         return Response.status(status).build();
 212                     }
 213                 }
 214             }
 215
 216             // add network to cache
 217             singleton.initDefaults();
 218             networkInterface.addNetwork(singleton);
 219             if (instances != null) {
 220                 for (Object instance : instances) {
 221                     INeutronNetworkAware service = (INeutronNetworkAware) instance;
 222                     service.neutronNetworkCreated(singleton);
 223                 }
 224             }
 225
 226         } else {
 227             List<NeutronNetwork> bulk = input.getBulk();
 228             Iterator<NeutronNetwork> i = bulk.iterator();
 229             HashMap<String, NeutronNetwork> testMap = new HashMap<String, NeutronNetwork>();
 230             Object[] instances = NeutronUtil.getInstances(INeutronNetworkAware.class, this);
 231             while (i.hasNext()) {
 232                 NeutronNetwork test = i.next();
 233
 234                 /*
 235                  * network ID can't already exist, nor can there be an entry for this UUID
 236                  * already in this bulk request
 237                  */
 238                 if (networkInterface.networkExists(test.getID())) {
 239                     throw new BadRequestException("network UUID already exists");
 240                 }
 241                 if (testMap.containsKey(test.getID())) {
 242                     throw new BadRequestException("network UUID already exists");
 243                 }
 244                 if (instances != null) {
 245                     for (Object instance: instances) {
 246                         INeutronNetworkAware service = (INeutronNetworkAware) instance;
 247                         int status = service.canCreateNetwork(test);
 248                         if (status < 200 || status > 299) {
 249                             return Response.status(status).build();
 250                         }
 251                     }
 252                 }
 253                 testMap.put(test.getID(),test);
 254             }
 255
 256             // now that everything passed, add items to the cache
 257             i = bulk.iterator();
 258             while (i.hasNext()) {
 259                 NeutronNetwork test = i.next();
 260                 test.initDefaults();
 261                 networkInterface.addNetwork(test);
 262                 if (instances != null) {
 263                     for (Object instance: instances) {
 264                         INeutronNetworkAware service = (INeutronNetworkAware) instance;
 265                         service.neutronNetworkCreated(test);
 266                     }
 267                 }
 268             }
 269         }
 270         return Response.status(201).entity(input).build();
 271     }
 272
 273     /**
 274      * Updates a Network */
 275     @Path("{netUUID}")
 276     @PUT
 277     @Produces({ MediaType.APPLICATION_JSON })
 278     @Consumes({ MediaType.APPLICATION_JSON })
 279     //@TypeHint(OpenStackNetworks.class)
 280     @StatusCodes({
 281         @ResponseCode(code = 200, condition = "Operation successful"),
 282         @ResponseCode(code = 400, condition = "Bad Request"),
 283         @ResponseCode(code = 403, condition = "Forbidden"),
 284         @ResponseCode(code = 404, condition = "Not Found"), })
 285     public Response updateNetwork(
 286             @PathParam("netUUID") String netUUID, final NeutronNetworkRequest input
 287             ) {
 288         INeutronNetworkCRUD networkInterface = NeutronCRUDInterfaces.getINeutronNetworkCRUD( this);
 289         if (networkInterface == null) {
 290             throw new ServiceUnavailableException("Network CRUD Interface "
 291                     + RestMessages.SERVICEUNAVAILABLE.toString());
 292         }
 293
 294         /*
 295          * network has to exist and only a single delta is supported
 296          */
 297         if (!networkInterface.networkExists(netUUID)) {
 298             throw new ResourceNotFoundException("network UUID does not exist.");
 299         }
 300         if (!input.isSingleton()) {
 301             throw new BadRequestException("only singleton edits supported");
 302         }
 303         NeutronNetwork delta = input.getSingleton();
 304
 305         /*
 306          * transitions forbidden by Neutron
 307          */
 308         if (delta.getID() != null || delta.getTenantID() != null ||
 309                 delta.getStatus() != null) {
 310             throw new BadRequestException("attribute edit blocked by Neutron");
 311         }
 312
 313         Object[] instances = NeutronUtil.getInstances(INeutronNetworkAware.class, this);
 314         if (instances != null) {
 315             for (Object instance : instances) {
 316                 INeutronNetworkAware service = (INeutronNetworkAware) instance;
 317                 NeutronNetwork original = networkInterface.getNetwork(netUUID);
 318                 int status = service.canUpdateNetwork(delta, original);
 319                 if (status < 200 || status > 299) {
 320                     return Response.status(status).build();
 321                 }
 322             }
 323         }
 324
 325         // update network object and return the modified object
 326                 networkInterface.updateNetwork(netUUID, delta);
 327                 NeutronNetwork updatedSingleton = networkInterface.getNetwork(netUUID);
 328                 if (instances != null) {
 329                     for (Object instance : instances) {
 330                         INeutronNetworkAware service = (INeutronNetworkAware) instance;
 331                         service.neutronNetworkUpdated(updatedSingleton);
 332                     }
 333                 }
 334                 return Response.status(200).entity(
 335                         new NeutronNetworkRequest(networkInterface.getNetwork(netUUID))).build();
 336     }
 337
 338     /**
 339      * Deletes a Network */
 340
 341     @Path("{netUUID}")
 342     @DELETE
 343     @StatusCodes({
 344         @ResponseCode(code = 204, condition = "No Content"),
 345         @ResponseCode(code = 401, condition = "Unauthorized"),
 346         @ResponseCode(code = 404, condition = "Not Found"),
 347         @ResponseCode(code = 409, condition = "Network In Use") })
 348     public Response deleteNetwork(
 349             @PathParam("netUUID") String netUUID) {
 350         INeutronNetworkCRUD networkInterface = NeutronCRUDInterfaces.getINeutronNetworkCRUD( this);
 351         if (networkInterface == null) {
 352             throw new ServiceUnavailableException("Network CRUD Interface "
 353                     + RestMessages.SERVICEUNAVAILABLE.toString());
 354         }
 355
 356         /*
 357          * network has to exist and not be in use before it can be removed
 358          */
 359         if (!networkInterface.networkExists(netUUID)) {
 360             throw new ResourceNotFoundException("network UUID does not exist.");
 361         }
 362         if (networkInterface.networkInUse(netUUID)) {
 363             throw new ResourceConflictException("Network ID in use");
 364         }
 365
 366         NeutronNetwork singleton = networkInterface.getNetwork(netUUID);
 367         Object[] instances = NeutronUtil.getInstances(INeutronNetworkAware.class, this);
 368         if (instances != null) {
 369             for (Object instance : instances) {
 370                 INeutronNetworkAware service = (INeutronNetworkAware) instance;
 371                 int status = service.canDeleteNetwork(singleton);
 372                 if (status < 200 || status > 299) {
 373                     return Response.status(status).build();
 374                 }
 375             }
 376         }
 377         networkInterface.removeNetwork(netUUID);
 378         if (instances != null) {
 379             for (Object instance : instances) {
 380                 INeutronNetworkAware service = (INeutronNetworkAware) instance;
 381                 service.neutronNetworkDeleted(singleton);
 382             }
 383         }
 384         return Response.status(204).build();
 385     }
 386 }