Statistics
| Branch: | Tag: | Revision:

root / snf-cyclades-app / synnefo / api / networks.py @ e221ade2

History | View | Annotate | Download (10.8 kB)

1
# Copyright 2011-2012 GRNET S.A. All rights reserved.
2
#
3
# Redistribution and use in source and binary forms, with or
4
# without modification, are permitted provided that the following
5
# conditions are met:
6
#
7
#   1. Redistributions of source code must retain the above
8
#      copyright notice, this list of conditions and the following
9
#      disclaimer.
10
#
11
#   2. Redistributions in binary form must reproduce the above
12
#      copyright notice, this list of conditions and the following
13
#      disclaimer in the documentation and/or other materials
14
#      provided with the distribution.
15
#
16
# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
17
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
20
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
23
# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
24
# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
26
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27
# POSSIBILITY OF SUCH DAMAGE.
28
#
29
# The views and conclusions contained in the software and
30
# documentation are those of the authors and should not be
31
# interpreted as representing official policies, either expressed
32
# or implied, of GRNET S.A.
33

    
34
from logging import getLogger
35

    
36
from django.conf.urls.defaults import patterns
37
from django.conf import settings
38
from django.db.models import Q
39
from django.db import transaction
40
from django.http import HttpResponse
41
from django.template.loader import render_to_string
42
from django.utils import simplejson as json
43

    
44
from synnefo.api import util
45
from synnefo.api.actions import network_actions
46
from synnefo.api.common import method_not_allowed
47
from synnefo.api.faults import (ServiceUnavailable, BadRequest, Unauthorized,
48
                                NetworkInUse, OverLimit)
49
from synnefo.db.models import Network
50
from synnefo.db.pools import EmptyPool
51
from synnefo.logic import backend
52

    
53

    
54
log = getLogger('synnefo.api')
55

    
56
urlpatterns = patterns('synnefo.api.networks',
57
    (r'^(?:/|.json|.xml)?$', 'demux'),
58
    (r'^/detail(?:.json|.xml)?$', 'list_networks', {'detail': True}),
59
    (r'^/(\w+)(?:.json|.xml)?$', 'network_demux'),
60
    (r'^/(\w+)/action(?:.json|.xml)?$', 'network_action'),
61
)
62

    
63

    
64
def demux(request):
65
    if request.method == 'GET':
66
        return list_networks(request)
67
    elif request.method == 'POST':
68
        return create_network(request)
69
    else:
70
        return method_not_allowed(request)
71

    
72

    
73
def network_demux(request, network_id):
74
    if request.method == 'GET':
75
        return get_network_details(request, network_id)
76
    elif request.method == 'PUT':
77
        return update_network_name(request, network_id)
78
    elif request.method == 'DELETE':
79
        return delete_network(request, network_id)
80
    else:
81
        return method_not_allowed(request)
82

    
83

    
84
def network_to_dict(network, user_id, detail=True):
85
    d = {'id': str(network.id), 'name': network.name}
86
    if detail:
87
        d['cidr'] = network.subnet
88
        d['cidr6'] = network.subnet6
89
        d['gateway'] = network.gateway
90
        d['gateway6'] = network.gateway6
91
        d['dhcp'] = network.dhcp
92
        d['type'] = network.type
93
        d['updated'] = util.isoformat(network.updated)
94
        d['created'] = util.isoformat(network.created)
95
        d['status'] = network.state
96
        d['public'] = network.public
97

    
98
        attachments = [util.construct_nic_id(nic)
99
                       for nic in network.nics.filter(machine__userid=user_id)]
100
        d['attachments'] = {'values': attachments}
101
    return d
102

    
103

    
104
def render_network(request, networkdict, status=200):
105
    if request.serialization == 'xml':
106
        data = render_to_string('network.xml', {'network': networkdict})
107
    else:
108
        data = json.dumps({'network': networkdict})
109
    return HttpResponse(data, status=status)
110

    
111

    
112
@util.api_method('GET')
113
def list_networks(request, detail=False):
114
    # Normal Response Codes: 200, 203
115
    # Error Response Codes: computeFault (400, 500),
116
    #                       serviceUnavailable (503),
117
    #                       unauthorized (401),
118
    #                       badRequest (400),
119
    #                       overLimit (413)
120

    
121
    log.debug('list_networks detail=%s', detail)
122
    since = util.isoparse(request.GET.get('changes-since'))
123
    user_networks = Network.objects.filter(Q(userid=request.user_uniq) |
124
                                           Q(public=True))
125

    
126
    if since:
127
        user_networks = user_networks.filter(updated__gte=since)
128
        if not user_networks:
129
            return HttpResponse(status=304)
130
    else:
131
        user_networks = user_networks.filter(deleted=False)
132

    
133
    networks = [network_to_dict(network, request.user_uniq, detail)
134
                for network in user_networks]
135

    
136
    if request.serialization == 'xml':
137
        data = render_to_string('list_networks.xml', {
138
            'networks': networks,
139
            'detail': detail})
140
    else:
141
        data = json.dumps({'networks': {'values': networks}})
142

    
143
    return HttpResponse(data, status=200)
144

    
145

    
146
@util.api_method('POST')
147
@transaction.commit_on_success
148
def create_network(request):
149
    # Normal Response Code: 202
150
    # Error Response Codes: computeFault (400, 500),
151
    #                       serviceUnavailable (503),
152
    #                       unauthorized (401),
153
    #                       badMediaType(415),
154
    #                       badRequest (400),
155
    #                       overLimit (413)
156

    
157
    req = util.get_request_dict(request)
158
    log.info('create_network %s', req)
159

    
160
    try:
161
        d = req['network']
162
        name = d['name']
163
        # TODO: Fix this temp values:
164
        subnet = d.get('cidr', '192.168.1.0/24')
165
        subnet6 = d.get('cidr6', None)
166
        gateway = d.get('gateway', None)
167
        gateway6 = d.get('gateway6', None)
168
        net_type = d.get('type', 'PRIVATE_MAC_FILTERED')
169
        dhcp = d.get('dhcp', True)
170
    except (KeyError, ValueError):
171
        raise BadRequest('Malformed request.')
172

    
173
    if net_type == 'PUBLIC_ROUTED':
174
        raise Unauthorized('Can not create a public network.')
175

    
176
    user_networks = len(Network.objects.filter(userid=request.user_uniq,
177
                                               deleted=False))
178

    
179
    if user_networks >= settings.MAX_NETWORKS_PER_USER:
180
        raise OverLimit('Network count limit exceeded for your account.')
181

    
182
    cidr_block = int(subnet.split('/')[1])
183
    if not util.validate_network_size(cidr_block):
184
        raise OverLimit("Unsupported network size.")
185

    
186
    try:
187
        link, mac_prefix = util.net_resources(net_type)
188
        if not link:
189
            raise Exception("Can not create network. No connectivity link.")
190

    
191
        network = Network.objects.create(
192
                name=name,
193
                userid=request.user_uniq,
194
                subnet=subnet,
195
                subnet6=subnet6,
196
                gateway=gateway,
197
                gateway6=gateway6,
198
                dhcp=dhcp,
199
                type=net_type,
200
                link=link,
201
                mac_prefix=mac_prefix,
202
                action='CREATE',
203
                state='PENDING')
204
    except EmptyPool:
205
        log.error("Failed to allocate resources for network of type: %s",
206
                  net_type)
207
        raise ServiceUnavailable("Failed to allocate resources for network")
208

    
209
    # Create BackendNetwork entries for each Backend
210
    network.create_backend_network()
211

    
212
    # Create the network in the actual backends
213
    backend.create_network(network)
214

    
215
    networkdict = network_to_dict(network, request.user_uniq)
216
    return render_network(request, networkdict, status=202)
217

    
218

    
219
@util.api_method('GET')
220
def get_network_details(request, network_id):
221
    # Normal Response Codes: 200, 203
222
    # Error Response Codes: computeFault (400, 500),
223
    #                       serviceUnavailable (503),
224
    #                       unauthorized (401),
225
    #                       badRequest (400),
226
    #                       itemNotFound (404),
227
    #                       overLimit (413)
228

    
229
    log.debug('get_network_details %s', network_id)
230
    net = util.get_network(network_id, request.user_uniq)
231
    netdict = network_to_dict(net, request.user_uniq)
232
    return render_network(request, netdict)
233

    
234

    
235
@util.api_method('PUT')
236
def update_network_name(request, network_id):
237
    # Normal Response Code: 204
238
    # Error Response Codes: computeFault (400, 500),
239
    #                       serviceUnavailable (503),
240
    #                       unauthorized (401),
241
    #                       badRequest (400),
242
    #                       badMediaType(415),
243
    #                       itemNotFound (404),
244
    #                       overLimit (413)
245

    
246
    req = util.get_request_dict(request)
247
    log.info('update_network_name %s', network_id)
248

    
249
    try:
250
        name = req['network']['name']
251
    except (TypeError, KeyError):
252
        raise BadRequest('Malformed request.')
253

    
254
    net = util.get_network(network_id, request.user_uniq)
255
    if net.public:
256
        raise Unauthorized('Can not rename the public network.')
257
    if net.deleted:
258
        raise Network.DeletedError
259
    net.name = name
260
    net.save()
261
    return HttpResponse(status=204)
262

    
263

    
264
@util.api_method('DELETE')
265
@transaction.commit_on_success
266
def delete_network(request, network_id):
267
    # Normal Response Code: 204
268
    # Error Response Codes: computeFault (400, 500),
269
    #                       serviceUnavailable (503),
270
    #                       unauthorized (401),
271
    #                       itemNotFound (404),
272
    #                       unauthorized (401),
273
    #                       overLimit (413)
274

    
275
    log.info('delete_network %s', network_id)
276
    net = util.get_network(network_id, request.user_uniq, for_update=True)
277
    if net.public:
278
        raise Unauthorized('Can not delete the public network.')
279

    
280
    if net.deleted:
281
        raise Network.DeletedError
282

    
283
    if net.machines.all():  # Nics attached on network
284
        raise NetworkInUse('Machines are connected to network.')
285

    
286

    
287
    net.action = 'DESTROY'
288
    net.save()
289

    
290
    backend.delete_network(net)
291
    return HttpResponse(status=204)
292

    
293

    
294
@util.api_method('POST')
295
def network_action(request, network_id):
296
    req = util.get_request_dict(request)
297
    log.debug('network_action %s %s', network_id, req)
298
    if len(req) != 1:
299
        raise BadRequest('Malformed request.')
300

    
301
    net = util.get_network(network_id, request.user_uniq)
302
    if net.public:
303
        raise Unauthorized('Can not modify the public network.')
304
    if net.deleted:
305
        raise Network.DeletedError
306

    
307
    try:
308
        key = req.keys()[0]
309
        val = req[key]
310
        assert isinstance(val, dict)
311
        return network_actions[key](request, net, req[key])
312
    except KeyError:
313
        raise BadRequest('Unknown action.')
314
    except AssertionError:
315
        raise BadRequest('Invalid argument.')