78646a6383e38131c4e7df4100c318fe6ab5a2cb
[controller.git] / opendaylight / northbound / networkconfiguration / neutron / src / main / java / org / opendaylight / controller / networkconfig / neutron / northbound / NeutronPortsNorthbound.java
1 /*\r
2  * Copyright IBM Corporation, 2013.  All rights reserved.\r
3  *\r
4  * This program and the accompanying materials are made available under the\r
5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
6  * and is available at http://www.eclipse.org/legal/epl-v10.html\r
7  */\r
8 \r
9 package org.opendaylight.controller.networkconfig.neutron.northbound;\r
10 \r
11 import java.util.ArrayList;\r
12 import java.util.HashMap;\r
13 import java.util.Iterator;\r
14 import java.util.List;\r
15 import javax.ws.rs.Consumes;\r
16 import javax.ws.rs.DELETE;\r
17 import javax.ws.rs.GET;\r
18 import javax.ws.rs.POST;\r
19 import javax.ws.rs.PUT;\r
20 import javax.ws.rs.Path;\r
21 import javax.ws.rs.PathParam;\r
22 import javax.ws.rs.Produces;\r
23 import javax.ws.rs.QueryParam;\r
24 import javax.ws.rs.core.MediaType;\r
25 import javax.ws.rs.core.Response;\r
26 \r
27 import org.codehaus.enunciate.jaxrs.ResponseCode;\r
28 import org.codehaus.enunciate.jaxrs.StatusCodes;\r
29 import org.opendaylight.controller.networkconfig.neutron.INeutronNetworkCRUD;\r
30 import org.opendaylight.controller.networkconfig.neutron.INeutronPortAware;\r
31 import org.opendaylight.controller.networkconfig.neutron.INeutronPortCRUD;\r
32 import org.opendaylight.controller.networkconfig.neutron.INeutronSubnetAware;\r
33 import org.opendaylight.controller.networkconfig.neutron.INeutronSubnetCRUD;\r
34 import org.opendaylight.controller.networkconfig.neutron.NeutronPort;\r
35 import org.opendaylight.controller.networkconfig.neutron.NeutronSubnet;\r
36 import org.opendaylight.controller.networkconfig.neutron.Neutron_IPs;\r
37 import org.opendaylight.controller.northbound.commons.RestMessages;\r
38 import org.opendaylight.controller.northbound.commons.exception.ServiceUnavailableException;\r
39 import org.opendaylight.controller.sal.utils.ServiceHelper;\r
40 \r
41 /**\r
42  * Open DOVE Northbound REST APIs.<br>\r
43  * This class provides REST APIs for managing the open DOVE\r
44  *\r
45  * <br>\r
46  * <br>\r
47  * Authentication scheme : <b>HTTP Basic</b><br>\r
48  * Authentication realm : <b>opendaylight</b><br>\r
49  * Transport : <b>HTTP and HTTPS</b><br>\r
50  * <br>\r
51  * HTTPS Authentication is disabled by default. Administrator can enable it in\r
52  * tomcat-server.xml after adding a proper keystore / SSL certificate from a\r
53  * trusted authority.<br>\r
54  * More info :\r
55  * http://tomcat.apache.org/tomcat-7.0-doc/ssl-howto.html#Configuration\r
56  *\r
57  */\r
58 \r
59 @Path("/ports")\r
60 public class NeutronPortsNorthbound {\r
61 \r
62     private NeutronPort extractFields(NeutronPort o, List<String> fields) {\r
63         return o.extractFields(fields);\r
64     }\r
65 \r
66     /**\r
67      * Returns a list of all Ports */\r
68 \r
69     @GET\r
70     @Produces({ MediaType.APPLICATION_JSON })\r
71     //@TypeHint(OpenStackPorts.class)\r
72     @StatusCodes({\r
73             @ResponseCode(code = 200, condition = "Operation successful"),\r
74             @ResponseCode(code = 401, condition = "Unauthorized"),\r
75             @ResponseCode(code = 501, condition = "Not Implemented") })\r
76     public Response listPorts(\r
77             // return fields\r
78             @QueryParam("fields") List<String> fields,\r
79             // note: openstack isn't clear about filtering on lists, so we aren't handling them\r
80             @QueryParam("id") String queryID,\r
81             @QueryParam("network_id") String queryNetworkID,\r
82             @QueryParam("name") String queryName,\r
83             @QueryParam("admin_state_up") String queryAdminStateUp,\r
84             @QueryParam("status") String queryStatus,\r
85             @QueryParam("mac_address") String queryMACAddress,\r
86             @QueryParam("device_id") String queryDeviceID,\r
87             @QueryParam("device_owner") String queryDeviceOwner,\r
88             @QueryParam("tenant_id") String queryTenantID,\r
89             // pagination\r
90             @QueryParam("limit") String limit,\r
91             @QueryParam("marker") String marker,\r
92             @QueryParam("page_reverse") String pageReverse\r
93             // sorting not supported\r
94             ) {\r
95         INeutronPortCRUD portInterface = NeutronNBInterfaces.getIfNBPortCRUD("default",this);\r
96         if (portInterface == null) {\r
97             throw new ServiceUnavailableException("Port CRUD Interface "\r
98                     + RestMessages.SERVICEUNAVAILABLE.toString());\r
99         }\r
100         List<NeutronPort> allPorts = portInterface.getAllPorts();\r
101         List<NeutronPort> ans = new ArrayList<NeutronPort>();\r
102         Iterator<NeutronPort> i = allPorts.iterator();\r
103         while (i.hasNext()) {\r
104             NeutronPort oSS = i.next();\r
105             if ((queryID == null || queryID.equals(oSS.getID())) &&\r
106                     (queryNetworkID == null || queryNetworkID.equals(oSS.getNetworkUUID())) &&\r
107                     (queryName == null || queryName.equals(oSS.getName())) &&\r
108                     (queryAdminStateUp == null || queryAdminStateUp.equals(oSS.getAdminStateUp())) &&\r
109                     (queryStatus == null || queryStatus.equals(oSS.getStatus())) &&\r
110                     (queryMACAddress == null || queryMACAddress.equals(oSS.getMacAddress())) &&\r
111                     (queryDeviceID == null || queryDeviceID.equals(oSS.getDeviceID())) &&\r
112                     (queryDeviceOwner == null || queryDeviceOwner.equals(oSS.getDeviceOwner())) &&\r
113                     (queryTenantID == null || queryTenantID.equals(oSS.getTenantID()))) {\r
114                 if (fields.size() > 0)\r
115                     ans.add(extractFields(oSS,fields));\r
116                 else\r
117                     ans.add(oSS);\r
118             }\r
119         }\r
120         //TODO: apply pagination to results\r
121         return Response.status(200).entity(\r
122                 new NeutronPortRequest(ans)).build();\r
123     }\r
124 \r
125     /**\r
126      * Returns a specific Port */\r
127 \r
128     @Path("{portUUID}")\r
129     @GET\r
130     @Produces({ MediaType.APPLICATION_JSON })\r
131     //@TypeHint(OpenStackPorts.class)\r
132     @StatusCodes({\r
133             @ResponseCode(code = 200, condition = "Operation successful"),\r
134             @ResponseCode(code = 401, condition = "Unauthorized"),\r
135             @ResponseCode(code = 404, condition = "Not Found"),\r
136             @ResponseCode(code = 501, condition = "Not Implemented") })\r
137     public Response showPort(\r
138             @PathParam("portUUID") String portUUID,\r
139             // return fields\r
140             @QueryParam("fields") List<String> fields ) {\r
141         INeutronPortCRUD portInterface = NeutronNBInterfaces.getIfNBPortCRUD("default",this);\r
142         if (portInterface == null) {\r
143             throw new ServiceUnavailableException("Port CRUD Interface "\r
144                     + RestMessages.SERVICEUNAVAILABLE.toString());\r
145         }\r
146         if (!portInterface.portExists(portUUID))\r
147             return Response.status(404).build();\r
148         if (fields.size() > 0) {\r
149             NeutronPort ans = portInterface.getPort(portUUID);\r
150             return Response.status(200).entity(\r
151                     new NeutronPortRequest(extractFields(ans, fields))).build();\r
152         } else\r
153             return Response.status(200).entity(\r
154                     new NeutronPortRequest(portInterface.getPort(portUUID))).build();\r
155     }\r
156 \r
157     /**\r
158      * Creates new Ports */\r
159 \r
160     @POST\r
161     @Produces({ MediaType.APPLICATION_JSON })\r
162     @Consumes({ MediaType.APPLICATION_JSON })\r
163     //@TypeHint(OpenStackPorts.class)\r
164     @StatusCodes({\r
165             @ResponseCode(code = 201, condition = "Created"),\r
166             @ResponseCode(code = 400, condition = "Bad Request"),\r
167             @ResponseCode(code = 401, condition = "Unauthorized"),\r
168             @ResponseCode(code = 403, condition = "Forbidden"),\r
169             @ResponseCode(code = 404, condition = "Not Found"),\r
170             @ResponseCode(code = 409, condition = "Conflict"),\r
171             @ResponseCode(code = 501, condition = "Not Implemented"),\r
172             @ResponseCode(code = 503, condition = "MAC generation failure") })\r
173     public Response createPorts(final NeutronPortRequest input) {\r
174         INeutronPortCRUD portInterface = NeutronNBInterfaces.getIfNBPortCRUD("default",this);\r
175         if (portInterface == null) {\r
176             throw new ServiceUnavailableException("Port CRUD Interface "\r
177                     + RestMessages.SERVICEUNAVAILABLE.toString());\r
178         }\r
179         INeutronNetworkCRUD networkInterface = NeutronNBInterfaces.getIfNBNetworkCRUD("default", this);\r
180         if (networkInterface == null) {\r
181             throw new ServiceUnavailableException("Network CRUD Interface "\r
182                     + RestMessages.SERVICEUNAVAILABLE.toString());\r
183         }\r
184         INeutronSubnetCRUD subnetInterface = NeutronNBInterfaces.getIfNBSubnetCRUD("default", this);\r
185         if (subnetInterface == null) {\r
186             throw new ServiceUnavailableException("Subnet CRUD Interface "\r
187                     + RestMessages.SERVICEUNAVAILABLE.toString());\r
188         }\r
189         if (input.isSingleton()) {\r
190             NeutronPort singleton = input.getSingleton();\r
191 \r
192             /*\r
193              * the port must be part of an existing network, must not already exist,\r
194              * have a valid MAC and the MAC not be in use\r
195              */\r
196             if (singleton.getNetworkUUID() == null)\r
197                 return Response.status(400).build();\r
198             if (portInterface.portExists(singleton.getID()))\r
199                 return Response.status(400).build();\r
200             if (!networkInterface.networkExists(singleton.getNetworkUUID()))\r
201                 return Response.status(404).build();\r
202             if (singleton.getMacAddress() == null ||\r
203                     !singleton.getMacAddress().matches("^([0-9A-F]{2}[:-]){5}([0-9A-F]{2})$"))\r
204                 return Response.status(400).build();\r
205             if (portInterface.macInUse(singleton.getMacAddress()))\r
206                 return Response.status(409).build();\r
207             Object[] instances = ServiceHelper.getGlobalInstances(INeutronPortAware.class, this, null);\r
208             if (instances != null) {\r
209                 for (Object instance : instances) {\r
210                     INeutronPortAware service = (INeutronPortAware) instance;\r
211                     int status = service.canCreatePort(singleton);\r
212                     if (status < 200 || status > 299)\r
213                         return Response.status(status).build();\r
214                 }\r
215             }\r
216             /*\r
217              * if fixed IPs are specified, each one has to have an existing subnet ID\r
218              * that is in the same scoping network as the port.  In addition, if an IP\r
219              * address is specified it has to be a valid address for the subnet and not\r
220              * already in use\r
221              */\r
222             List<Neutron_IPs> fixedIPs = singleton.getFixedIPs();\r
223             if (fixedIPs != null && fixedIPs.size() > 0) {\r
224                 Iterator<Neutron_IPs> fixedIPIterator = fixedIPs.iterator();\r
225                 while (fixedIPIterator.hasNext()) {\r
226                     Neutron_IPs ip = fixedIPIterator.next();\r
227                     if (ip.getSubnetUUID() == null)\r
228                         return Response.status(400).build();\r
229                     if (!subnetInterface.subnetExists(ip.getSubnetUUID()))\r
230                         return Response.status(400).build();\r
231                     NeutronSubnet subnet = subnetInterface.getSubnet(ip.getSubnetUUID());\r
232                     if (!singleton.getNetworkUUID().equalsIgnoreCase(subnet.getNetworkUUID()))\r
233                         return Response.status(400).build();\r
234                     if (ip.getIpAddress() != null) {\r
235                         if (!subnet.isValidIP(ip.getIpAddress()))\r
236                             return Response.status(400).build();\r
237                         if (subnet.isIPInUse(ip.getIpAddress()))\r
238                             return Response.status(409).build();\r
239                     }\r
240                 }\r
241             }\r
242 \r
243             // add the port to the cache\r
244             portInterface.addPort(singleton);\r
245             if (instances != null) {\r
246                 for (Object instance : instances) {\r
247                     INeutronPortAware service = (INeutronPortAware) instance;\r
248                     service.neutronPortCreated(singleton);\r
249                 }\r
250             }\r
251         } else {\r
252             List<NeutronPort> bulk = input.getBulk();\r
253             Iterator<NeutronPort> i = bulk.iterator();\r
254             HashMap<String, NeutronPort> testMap = new HashMap<String, NeutronPort>();\r
255             Object[] instances = ServiceHelper.getGlobalInstances(INeutronSubnetAware.class, this, null);\r
256             while (i.hasNext()) {\r
257                 NeutronPort test = i.next();\r
258 \r
259                 /*\r
260                  * the port must be part of an existing network, must not already exist,\r
261                  * have a valid MAC and the MAC not be in use.  Further the bulk request\r
262                  * can't already contain a new port with the same UUID\r
263                  */\r
264                 if (portInterface.portExists(test.getID()))\r
265                     return Response.status(400).build();\r
266                 if (testMap.containsKey(test.getID()))\r
267                     return Response.status(400).build();\r
268                 for (NeutronPort check : testMap.values()) {\r
269                     if (test.getMacAddress().equalsIgnoreCase(check.getMacAddress()))\r
270                         return Response.status(409).build();\r
271                     for (Neutron_IPs test_fixedIP : test.getFixedIPs()) {\r
272                         for (Neutron_IPs check_fixedIP : check.getFixedIPs()) {\r
273                             if (test_fixedIP.getIpAddress().equals(check_fixedIP.getIpAddress()))\r
274                                 return Response.status(409).build();\r
275                         }\r
276                     }\r
277                 }\r
278                 testMap.put(test.getID(), test);\r
279                 if (!networkInterface.networkExists(test.getNetworkUUID()))\r
280                     return Response.status(404).build();\r
281                 if (!test.getMacAddress().matches("^([0-9A-F]{2}[:-]){5}([0-9A-F]{2})$"))\r
282                     return Response.status(400).build();\r
283                 if (portInterface.macInUse(test.getMacAddress()))\r
284                     return Response.status(409).build();\r
285                 if (instances != null) {\r
286                     for (Object instance : instances) {\r
287                         INeutronPortAware service = (INeutronPortAware) instance;\r
288                         int status = service.canCreatePort(test);\r
289                         if (status < 200 || status > 299)\r
290                             return Response.status(status).build();\r
291                     }\r
292                 }\r
293                 /*\r
294                  * if fixed IPs are specified, each one has to have an existing subnet ID\r
295                  * that is in the same scoping network as the port.  In addition, if an IP\r
296                  * address is specified it has to be a valid address for the subnet and not\r
297                  * already in use (or be the gateway IP address of the subnet)\r
298                  */\r
299                 List<Neutron_IPs> fixedIPs = test.getFixedIPs();\r
300                 if (fixedIPs != null && fixedIPs.size() > 0) {\r
301                     Iterator<Neutron_IPs> fixedIPIterator = fixedIPs.iterator();\r
302                     while (fixedIPIterator.hasNext()) {\r
303                         Neutron_IPs ip = fixedIPIterator.next();\r
304                         if (ip.getSubnetUUID() == null)\r
305                             return Response.status(400).build();\r
306                         if (!subnetInterface.subnetExists(ip.getSubnetUUID()))\r
307                             return Response.status(400).build();\r
308                         NeutronSubnet subnet = subnetInterface.getSubnet(ip.getSubnetUUID());\r
309                         if (!test.getNetworkUUID().equalsIgnoreCase(subnet.getNetworkUUID()))\r
310                             return Response.status(400).build();\r
311                         if (ip.getIpAddress() != null) {\r
312                             if (!subnet.isValidIP(ip.getIpAddress()))\r
313                                 return Response.status(400).build();\r
314                             //TODO: need to add consideration for a fixed IP being assigned the same address as a allocated IP in the\r
315                             //same bulk create\r
316                             if (subnet.isIPInUse(ip.getIpAddress()))\r
317                                 return Response.status(409).build();\r
318                         }\r
319                     }\r
320                 }\r
321             }\r
322 \r
323             //once everything has passed, then we can add to the cache\r
324             i = bulk.iterator();\r
325             while (i.hasNext()) {\r
326                 NeutronPort test = i.next();\r
327                 portInterface.addPort(test);\r
328                 if (instances != null) {\r
329                     for (Object instance : instances) {\r
330                         INeutronPortAware service = (INeutronPortAware) instance;\r
331                         service.neutronPortCreated(test);\r
332                     }\r
333                 }\r
334             }\r
335         }\r
336         return Response.status(201).entity(input).build();\r
337     }\r
338 \r
339     /**\r
340      * Updates a Port */\r
341 \r
342     @Path("{portUUID}")\r
343     @PUT\r
344     @Produces({ MediaType.APPLICATION_JSON })\r
345     @Consumes({ MediaType.APPLICATION_JSON })\r
346     //@TypeHint(OpenStackPorts.class)\r
347     @StatusCodes({\r
348             @ResponseCode(code = 200, condition = "Operation successful"),\r
349             @ResponseCode(code = 400, condition = "Bad Request"),\r
350             @ResponseCode(code = 401, condition = "Unauthorized"),\r
351             @ResponseCode(code = 403, condition = "Forbidden"),\r
352             @ResponseCode(code = 404, condition = "Not Found"),\r
353             @ResponseCode(code = 409, condition = "Conflict"),\r
354             @ResponseCode(code = 501, condition = "Not Implemented") })\r
355     public Response updatePort(\r
356             @PathParam("portUUID") String portUUID,\r
357             NeutronPortRequest input\r
358             ) {\r
359         INeutronPortCRUD portInterface = NeutronNBInterfaces.getIfNBPortCRUD("default",this);\r
360         if (portInterface == null) {\r
361             throw new ServiceUnavailableException("Port CRUD Interface "\r
362                     + RestMessages.SERVICEUNAVAILABLE.toString());\r
363         }\r
364         INeutronSubnetCRUD subnetInterface = NeutronNBInterfaces.getIfNBSubnetCRUD("default", this);\r
365         if (subnetInterface == null) {\r
366             throw new ServiceUnavailableException("Subnet CRUD Interface "\r
367                     + RestMessages.SERVICEUNAVAILABLE.toString());\r
368         }\r
369 \r
370         // port has to exist and only a single delta is supported\r
371         if (!portInterface.portExists(portUUID))\r
372             return Response.status(404).build();\r
373         NeutronPort target = portInterface.getPort(portUUID);\r
374         if (!input.isSingleton())\r
375             return Response.status(400).build();\r
376         NeutronPort singleton = input.getSingleton();\r
377         NeutronPort original = portInterface.getPort(portUUID);\r
378 \r
379         // deltas restricted by Neutron\r
380         if (singleton.getID() != null || singleton.getTenantID() != null ||\r
381                 singleton.getStatus() != null)\r
382             return Response.status(400).build();\r
383 \r
384         Object[] instances = ServiceHelper.getGlobalInstances(INeutronPortAware.class, this, null);\r
385         if (instances != null) {\r
386             for (Object instance : instances) {\r
387                 INeutronPortAware service = (INeutronPortAware) instance;\r
388                 int status = service.canUpdatePort(singleton, original);\r
389                 if (status < 200 || status > 299)\r
390                     return Response.status(status).build();\r
391             }\r
392         }\r
393 \r
394         // Verify the new fixed ips are valid\r
395         List<Neutron_IPs> fixedIPs = singleton.getFixedIPs();\r
396         if (fixedIPs != null && fixedIPs.size() > 0) {\r
397             Iterator<Neutron_IPs> fixedIPIterator = fixedIPs.iterator();\r
398             while (fixedIPIterator.hasNext()) {\r
399                 Neutron_IPs ip = fixedIPIterator.next();\r
400                 if (ip.getSubnetUUID() == null)\r
401                     return Response.status(400).build();\r
402                 if (!subnetInterface.subnetExists(ip.getSubnetUUID()))\r
403                     return Response.status(400).build();\r
404                 NeutronSubnet subnet = subnetInterface.getSubnet(ip.getSubnetUUID());\r
405                 if (!target.getNetworkUUID().equalsIgnoreCase(subnet.getNetworkUUID()))\r
406                     return Response.status(400).build();\r
407                 if (ip.getIpAddress() != null) {\r
408                     if (!subnet.isValidIP(ip.getIpAddress()))\r
409                         return Response.status(400).build();\r
410                     if (subnet.isIPInUse(ip.getIpAddress()))\r
411                         return Response.status(409).build();\r
412                 }\r
413             }\r
414         }\r
415 \r
416 //        TODO: Support change of security groups\r
417         // update the port and return the modified object\r
418         portInterface.updatePort(portUUID, singleton);\r
419         NeutronPort updatedPort = portInterface.getPort(portUUID);\r
420         if (instances != null) {\r
421             for (Object instance : instances) {\r
422                 INeutronPortAware service = (INeutronPortAware) instance;\r
423                 service.neutronPortUpdated(updatedPort);\r
424             }\r
425         }\r
426         return Response.status(200).entity(\r
427                 new NeutronPortRequest(updatedPort)).build();\r
428 \r
429     }\r
430 \r
431     /**\r
432      * Deletes a Port */\r
433 \r
434     @Path("{portUUID}")\r
435     @DELETE\r
436     @StatusCodes({\r
437         @ResponseCode(code = 204, condition = "No Content"),\r
438         @ResponseCode(code = 401, condition = "Unauthorized"),\r
439         @ResponseCode(code = 403, condition = "Forbidden"),\r
440         @ResponseCode(code = 404, condition = "Not Found"),\r
441         @ResponseCode(code = 501, condition = "Not Implemented") })\r
442     public Response deletePort(\r
443             @PathParam("portUUID") String portUUID) {\r
444         INeutronPortCRUD portInterface = NeutronNBInterfaces.getIfNBPortCRUD("default",this);\r
445         if (portInterface == null) {\r
446             throw new ServiceUnavailableException("Port CRUD Interface "\r
447                     + RestMessages.SERVICEUNAVAILABLE.toString());\r
448         }\r
449 \r
450         // port has to exist and not be owned by anyone.  then it can be removed from the cache\r
451         if (!portInterface.portExists(portUUID))\r
452             return Response.status(404).build();\r
453         NeutronPort port = portInterface.getPort(portUUID);\r
454         if (port.getDeviceID() != null ||\r
455                 port.getDeviceOwner() != null)\r
456             Response.status(403).build();\r
457         NeutronPort singleton = portInterface.getPort(portUUID);\r
458         Object[] instances = ServiceHelper.getGlobalInstances(INeutronPortAware.class, this, null);\r
459         if (instances != null) {\r
460             for (Object instance : instances) {\r
461                 INeutronPortAware service = (INeutronPortAware) instance;\r
462                 int status = service.canDeletePort(singleton);\r
463                 if (status < 200 || status > 299)\r
464                     return Response.status(status).build();\r
465             }\r
466         }\r
467         portInterface.removePort(portUUID);\r
468         if (instances != null) {\r
469             for (Object instance : instances) {\r
470                 INeutronPortAware service = (INeutronPortAware) instance;\r
471                 service.neutronPortDeleted(singleton);\r
472             }\r
473         }\r
474         return Response.status(204).build();\r
475     }\r
476 }\r