Statistics
| Branch: | Tag: | Revision:

root / snf-cyclades-app / synnefo / api / floating_ips.py @ 24ea227b

History | View | Annotate | Download (8.8 kB)

1
# Copyright 2013 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 django.conf.urls.defaults import patterns
35
from django.db import transaction
36
from django.http import HttpResponse
37
from django.utils import simplejson as json
38

    
39
from snf_django.lib import api
40
from snf_django.lib.api import faults, utils
41
from synnefo.api import util
42
from synnefo.logic import ips
43
from synnefo.db.models import Network, IPAddress
44

    
45
from logging import getLogger
46
log = getLogger(__name__)
47

    
48
'''
49
ips_urlpatterns = patterns(
50
    'synnefo.api.floating_ips',
51
    (r'^(?:/|.json|.xml)?$', 'demux'),
52
    (r'^/(\w+)(?:.json|.xml)?$', 'floating_ip_demux'),
53
)
54

55
pools_urlpatterns = patterns(
56
    "synnefo.api.floating_ips",
57
    (r'^(?:/|.json|.xml)?$', 'list_floating_ip_pools'),
58
)
59
'''
60

    
61
ips_urlpatterns = patterns(
62
    'synnefo.api.floating_ips',
63
    (r'^(?:/|.json|.xml)?$', 'demux'),
64
    (r'^/detail(?:.json|.xml)?$', 'list_floating_ips', {'detail': True}),
65
    (r'^/(\w+)(?:/|.json|.xml)?$', 'floating_ip_demux'))
66

    
67

    
68
def demux(request):
69
    if request.method == 'GET':
70
        return list_floating_ips(request)
71
    elif request.method == 'POST':
72
        return allocate_floating_ip(request)
73
    else:
74
        return api.api_method_not_allowed(request)
75

    
76

    
77
def floating_ip_demux(request, floating_ip_id):
78
    if request.method == 'GET':
79
        return get_floating_ip(request, floating_ip_id)
80
    elif request.method == 'DELETE':
81
        return release_floating_ip(request, floating_ip_id)
82
    elif request.method == 'PUT':
83
        return update_floating_ip(request, floating_ip_id)
84
    else:
85
        return api.api_method_not_allowed(request)
86

    
87

    
88
def ip_to_dict(floating_ip):
89
    machine_id = None
90
    port_id = None
91
    if floating_ip.nic is not None:
92
        machine_id = floating_ip.nic.machine_id
93
        port_id = floating_ip.nic.id
94
    return {"fixed_ip_address": None,
95
            "id": str(floating_ip.id),
96
            "instance_id": str(machine_id) if machine_id else None,
97
            "floating_ip_address": floating_ip.address,
98
            "port_id": str(floating_ip.nic.id) if port_id else None,
99
            "floating_network_id": str(floating_ip.network_id)}
100

    
101

    
102
@api.api_method(http_method="GET", user_required=True, logger=log,
103
                serializations=["json"])
104
def list_floating_ips(request):
105
    """Return user reserved floating IPs"""
106
    log.debug("list_floating_ips")
107

    
108
    userid = request.user_uniq
109
    floating_ips = IPAddress.objects.filter(userid=userid, deleted=False,
110
                                            floating_ip=True).order_by("id")\
111
                                    .select_related("nic")
112
    floating_ips = utils.filter_modified_since(request, objects=floating_ips)
113

    
114
    floating_ips = map(ip_to_dict, floating_ips)
115

    
116
    request.serialization = "json"
117
    data = json.dumps({"floatingips": floating_ips})
118

    
119
    return HttpResponse(data, status=200)
120

    
121

    
122
@api.api_method(http_method="GET", user_required=True, logger=log,
123
                serializations=["json"])
124
def get_floating_ip(request, floating_ip_id):
125
    """Return information for a floating IP."""
126
    userid = request.user_uniq
127
    floating_ip = util.get_floating_ip_by_id(userid, floating_ip_id)
128
    request.serialization = "json"
129
    data = json.dumps({"floatingip": ip_to_dict(floating_ip)})
130
    return HttpResponse(data, status=200)
131

    
132

    
133
@api.api_method(http_method='POST', user_required=True, logger=log,
134
                serializations=["json"])
135
@transaction.commit_on_success
136
def allocate_floating_ip(request):
137
    """Allocate a floating IP."""
138
    req = utils.get_request_dict(request)
139
    floating_ip_dict = api.utils.get_attribute(req, "floatingip",
140
                                               required=True)
141
    log.info('allocate_floating_ip %s', req)
142

    
143
    userid = request.user_uniq
144

    
145
    # the network_pool is a mandatory field
146
    network_id = api.utils.get_attribute(floating_ip_dict,
147
                                         "floating_network_id",
148
                                         required=False)
149
    if network_id is None:
150
        floating_ip = ips.create_floating_ip(userid)
151
    else:
152
        try:
153
            network_id = int(network_id)
154
        except ValueError:
155
            raise faults.BadRequest("Invalid networkd ID.")
156

    
157
        network = util.get_network(network_id, userid, for_update=True,
158
                                   non_deleted=True)
159
        address = api.utils.get_attribute(floating_ip_dict,
160
                                          "floating_ip_address",
161
                                          required=False)
162
        floating_ip = ips.create_floating_ip(userid, network, address)
163

    
164
    log.info("User '%s' allocated floating IP '%s'", userid, floating_ip)
165
    request.serialization = "json"
166
    data = json.dumps({"floatingip": ip_to_dict(floating_ip)})
167
    return HttpResponse(data, status=200)
168

    
169

    
170
@api.api_method(http_method='DELETE', user_required=True, logger=log,
171
                serializations=["json"])
172
@transaction.commit_on_success
173
def release_floating_ip(request, floating_ip_id):
174
    """Release a floating IP."""
175
    userid = request.user_uniq
176
    log.info("release_floating_ip '%s'. User '%s'.", floating_ip_id, userid)
177

    
178
    floating_ip = util.get_floating_ip_by_id(userid, floating_ip_id,
179
                                             for_update=True)
180
    ips.delete_floating_ip(floating_ip)
181
    log.info("User '%s' released IP '%s", userid, floating_ip)
182

    
183
    return HttpResponse(status=204)
184

    
185

    
186
@api.api_method(http_method='PUT', user_required=True, logger=log,
187
                serializations=["json"])
188
@transaction.commit_on_success
189
def update_floating_ip(request, floating_ip_id):
190
    """Update a floating IP."""
191
    raise faults.NotImplemented("Updating a floating IP is not supported.")
192
    #userid = request.user_uniq
193
    #log.info("update_floating_ip '%s'. User '%s'.", floating_ip_id, userid)
194

    
195
    #req = utils.get_request_dict(request)
196
    #info = api.utils.get_attribute(req, "floatingip", required=True)
197

    
198
    #device_id = api.utils.get_attribute(info, "device_id", required=False)
199

    
200
    #floating_ip = util.get_floating_ip_by_id(userid, floating_ip_id,
201
    #                                         for_update=True)
202
    #if device_id:
203
    #    # attach
204
    #    vm = util.get_vm(device_id, userid)
205
    #    nic, floating_ip = servers.create_nic(vm, ipaddress=floating_ip)
206
    #    backend.connect_to_network(vm, nic)
207
    #else:
208
    #    # dettach
209
    #    nic = floating_ip.nic
210
    #    if not nic:
211
    #        raise faults.BadRequest("The floating IP is not associated\
212
    #                                with any device")
213
    #    vm = nic.machine
214
    #    servers.disconnect(vm, nic)
215
    #return HttpResponse(status=202)
216

    
217

    
218
# Floating IP pools
219
@api.api_method(http_method='GET', user_required=True, logger=log,
220
                serializations=["json"])
221
def list_floating_ip_pools(request):
222
    networks = Network.objects.filter(public=True, floating_ip_pool=True,
223
                                      deleted=False)
224
    networks = utils.filter_modified_since(request, objects=networks)
225
    floating_ip_pools = map(network_to_floating_ip_pool, networks)
226
    request.serialization = "json"
227
    data = json.dumps({"floating_ip_pools": floating_ip_pools})
228
    request.serialization = "json"
229
    return HttpResponse(data, status=200)
230

    
231

    
232
def network_to_floating_ip_pool(network):
233
    """Convert a 'Network' object to a floating IP pool dict."""
234
    total, free = network.ip_count()
235
    return {"name": str(network.id),
236
            "size": total,
237
            "free": free}