1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
# Copyright 2015, Hewlett-Packard Development Company, L.P.
# Copyright 2016 IBM Corp.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""API for the network abstraction APIs."""
from django.views import generic
from openstack_dashboard import api
from openstack_dashboard.api.rest import urls
from openstack_dashboard.api.rest import utils as rest_utils
@urls.register
class SecurityGroups(generic.View):
"""API for Network Abstraction
Handles differences between Nova and Neutron.
"""
url_regex = r'network/securitygroups/$'
@rest_utils.ajax()
def get(self, request):
"""Get a list of security groups.
The listing result is an object with property "items". Each item is
a security group.
Example GET:
http://localhost/api/network/securitygroups
"""
security_groups = api.neutron.security_group_list(request)
return {'items': [sg.to_dict() for sg in security_groups]}
@urls.register
class FloatingIP(generic.View):
"""API for a single floating IP address."""
url_regex = r'network/floatingip/$'
@rest_utils.ajax(data_required=True)
def post(self, request):
"""Allocate a new floating IP address.
:param pool_id: The ID of the floating IP address pool in which to
allocate the new address.
:return: JSON representation of the new floating IP address
"""
pool = request.DATA['pool_id']
params = {}
if 'dns_domain' in request.DATA:
params['dns_domain'] = request.DATA['dns_domain']
if 'dns_name' in request.DATA:
params['dns_name'] = request.DATA['dns_name']
result = api.neutron.tenant_floating_ip_allocate(request, pool,
None, **params)
return result.to_dict()
@rest_utils.ajax(data_required=True)
def patch(self, request):
"""Associate or disassociate a floating IP address.
:param address_id: The ID of the floating IP address to associate
or disassociate.
:param port_id: The ID of the port to associate.
"""
address = request.DATA['address_id']
port = request.DATA.get('port_id')
if port is None:
api.neutron.floating_ip_disassociate(request, address)
else:
api.neutron.floating_ip_associate(request, address, port)
@urls.register
class FloatingIPs(generic.View):
"""API for floating IP addresses."""
url_regex = r'network/floatingips/$'
@rest_utils.ajax()
def get(self, request):
"""Get a list of floating IP addresses.
The listing result is an object with property "items". Each item is
an extension.
Example:
http://localhost/api/network/floatingips
"""
result = api.neutron.tenant_floating_ip_list(request)
return {'items': [ip.to_dict() for ip in result]}
@urls.register
class FloatingIPPools(generic.View):
"""API for floating IP pools."""
url_regex = r'network/floatingippools/$'
@rest_utils.ajax()
def get(self, request):
"""Get a list of floating IP pools.
The listing result is an object with property "items". Each item is
an extension.
Example:
http://localhost/api/network/floatingippools
"""
result = api.neutron.floating_ip_pools_list(request)
return {'items': [p.to_dict() for p in result]}
|
