floating_ips.py 19.5 KB
Newer Older
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
# Copyright 2012 GRNET S.A. All rights reserved.
#
# Redistribution and use in source and binary forms, with or
# without modification, are permitted provided that the following
# conditions are met:
#
#   1. Redistributions of source code must retain the above
#      copyright notice, this list of conditions and the following
#      disclaimer.
#
#   2. Redistributions in binary form must reproduce the above
#      copyright notice, this list of conditions and the following
#      disclaimer in the documentation and/or other materials
#      provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# The views and conclusions contained in the software and
# documentation are those of the authors and should not be
# interpreted as representing official policies, either expressed
# or implied, of GRNET S.A.

34
from django.utils import simplejson as json
35
from snf_django.utils.testing import BaseAPITest, mocked_quotaholder
36
from synnefo.db.models import IPAddress, Network
37
from synnefo.db import models_factory as mf
38

39
from mock import patch, Mock
40

Christos Stavrakakis's avatar
Christos Stavrakakis committed
41
42
43
from synnefo.cyclades_settings import cyclades_services
from synnefo.lib.services import get_service_path
from synnefo.lib import join_urls
44

Christos Stavrakakis's avatar
Christos Stavrakakis committed
45
46

compute_path = get_service_path(cyclades_services, "compute", version="v2.0")
47
URL = join_urls(compute_path, "floatingips")
Christos Stavrakakis's avatar
Christos Stavrakakis committed
48
49
NETWORKS_URL = join_urls(compute_path, "networks")
SERVERS_URL = join_urls(compute_path, "servers")
50

51
52

floating_ips = IPAddress.objects.filter(floating_ip=True)
53

54

55
class FloatingIPAPITest(BaseAPITest):
56
57
58
59
60
61
    def setUp(self):
        self.pool = mf.NetworkWithSubnetFactory(floating_ip_pool=True,
                                                public=True,
                                                subnet__cidr="192.168.2.0/24",
                                                subnet__gateway="192.168.2.1")

62
63
64
    def test_no_floating_ip(self):
        response = self.get(URL)
        self.assertSuccess(response)
65
        self.assertEqual(json.loads(response.content)["floatingips"], [])
66
67

    def test_list_ips(self):
68
        ip = mf.IPv4AddressFactory(userid="user1", floating_ip=True)
69
70
71
        with mocked_quotaholder():
            response = self.get(URL, "user1")
        self.assertSuccess(response)
72
        api_ip = json.loads(response.content)["floatingips"][0]
73
        self.assertEqual(api_ip,
74
                         {"instance_id": str(ip.nic.machine_id),
75
76
                          "floating_ip_address": ip.address,
                          "fixed_ip_address": None,
77
                          "id": str(ip.id),
78
79
                          "port_id": str(ip.nic.id),
                          "floating_network_id": str(ip.network_id)})
80
81

    def test_get_ip(self):
82
        ip = mf.IPv4AddressFactory(userid="user1", floating_ip=True)
83
84
85
        with mocked_quotaholder():
            response = self.get(URL + "/%s" % ip.id, "user1")
        self.assertSuccess(response)
86
        api_ip = json.loads(response.content)["floatingip"]
87
        self.assertEqual(api_ip,
88
                         {"instance_id": str(ip.nic.machine_id),
89
90
                          "floating_ip_address": ip.address,
                          "fixed_ip_address": None,
91
                          "id": str(ip.id),
92
93
                          "port_id": str(ip.nic.id),
                          "floating_network_id": str(ip.network_id)})
94
95

    def test_wrong_user(self):
96
97
        ip = mf.IPv4AddressFactory(userid="user1", floating_ip=True)
        response = self.delete(URL + "/%s" % ip.id, "user2")
98
99
100
        self.assertItemNotFound(response)

    def test_deleted_ip(self):
101
102
103
        ip = mf.IPv4AddressFactory(userid="user1", floating_ip=True,
                                   deleted=True)
        response = self.delete(URL + "/%s" % ip.id, "user1")
104
105
106
        self.assertItemNotFound(response)

    def test_reserve(self):
107
108
109
        request = {"floatingip": {
            "floating_network_id": self.pool.id}
            }
110
111
112
        with mocked_quotaholder():
            response = self.post(URL, "test_user", json.dumps(request), "json")
        self.assertSuccess(response)
113
        api_ip = json.loads(response.content, encoding="utf-8")["floatingip"]
114
        ip = floating_ips.get()
115
116
117
        self.assertEqual(ip.address, "192.168.2.2")
        self.assertEqual(ip.nic, None)
        self.assertEqual(ip.network, self.pool)
118
119
120
121
122
123
124
        self.assertEqual(api_ip,
                         {"instance_id": None,
                          "floating_ip_address": "192.168.2.2",
                          "fixed_ip_address": None,
                          "id": str(ip.id),
                          "port_id": None,
                          "floating_network_id": str(self.pool.id)})
125

126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
    def test_reserve_empty_body(self):
        """Test reserve FIP without specifying network."""
        request = {"floatingip": {}}
        # delete all pools..
        Network.objects.all().delete()
        # CASE: no floating IP pool
        with mocked_quotaholder():
            response = self.post(URL, "test_user", json.dumps(request), "json")
        self.assertConflict(response)
        # CASE: Full floating IP pool
        mf.NetworkWithSubnetFactory(floating_ip_pool=True, public=True,
                                    subnet__pool__size=0)
        with mocked_quotaholder():
            response = self.post(URL, "test_user", json.dumps(request), "json")
        self.assertConflict(response)
        # CASE: Available floating IP pool
        p1 = mf.NetworkWithSubnetFactory(floating_ip_pool=True, public=True,
                                         subnet__cidr="192.168.2.0/30",
                                         subnet__pool__size=1)
        with mocked_quotaholder():
            response = self.post(URL, "test_user", json.dumps(request), "json")
        self.assertSuccess(response)
        floating_ip = json.loads(response.content)["floatingip"]
        db_fip = IPAddress.objects.get(id=floating_ip["id"])
        self.assertEqual(db_fip.address, floating_ip["floating_ip_address"])
        self.assertTrue(db_fip.floating_ip)
        # Test that address is reserved
        ip_pool = p1.get_ip_pools()[0]
        self.assertFalse(ip_pool.is_available(db_fip.address))

156
    def test_reserve_no_pool(self):
157
158
159
160
161
162
163
164
165
166
        # Network is not a floating IP pool
        pool2 = mf.NetworkWithSubnetFactory(floating_ip_pool=False,
                                            public=True,
                                            subnet__cidr="192.168.2.0/24",
                                            subnet__gateway="192.168.2.1")
        request = {"floatingip": {
            'floating_network_id': pool2.id}
            }
        response = self.post(URL, "test_user", json.dumps(request), "json")
        self.assertEqual(response.status_code, 404)
167

168
        # Full network
169
170
171
172
173
        net = mf.NetworkWithSubnetFactory(floating_ip_pool=True,
                                          public=True,
                                          subnet__cidr="192.168.2.0/31",
                                          subnet__gateway="192.168.2.1",
                                          subnet__pool__size=0)
174
175
176
        request = {"floatingip": {
            'floating_network_id': net.id}
            }
177
178
        response = self.post(URL, "test_user", json.dumps(request), "json")
        self.assertConflict(response)
179

180
    def test_reserve_with_address(self):
181
182
183
184
        request = {"floatingip": {
            "floating_network_id": self.pool.id,
            "floating_ip_address": "192.168.2.10"}
            }
185
186
187
        with mocked_quotaholder():
            response = self.post(URL, "test_user", json.dumps(request), "json")
        self.assertSuccess(response)
188
        ip = floating_ips.get()
189
        self.assertEqual(json.loads(response.content)["floatingip"],
190
191
192
193
194
195
                         {"instance_id": None,
                          "floating_ip_address": "192.168.2.10",
                          "fixed_ip_address": None,
                          "id": str(ip.id),
                          "port_id": None,
                          "floating_network_id": str(self.pool.id)})
196
197
198
199
200
201

        # Already reserved
        with mocked_quotaholder():
            response = self.post(URL, "test_user", json.dumps(request), "json")
        self.assertFault(response, 409, "conflict")

202
203
        # Used by instance
        self.pool.reserve_address("192.168.2.20")
204
205
206
207
        request = {"floatingip": {
            "floating_network_id": self.pool.id,
            "floating_ip_address": "192.168.2.20"}
            }
208
209
210
211
212
        with mocked_quotaholder():
            response = self.post(URL, "test_user", json.dumps(request), "json")
        self.assertFault(response, 409, "conflict")

        # Address out of pool
213
214
215
216
        request = {"floatingip": {
            "floating_network_id": self.pool.id,
            "floating_ip_address": "192.168.3.5"}
            }
217
218
219
220
        with mocked_quotaholder():
            response = self.post(URL, "test_user", json.dumps(request), "json")
        self.assertBadRequest(response)

221
    '''
222
223
224
225
226
227
228
229
230
231
    @patch("synnefo.db.models.get_rapi_client")
    def test_reserve_and_connect(self, mrapi):
        vm = mf.VirtualMachineFactory(userid="test_user")
        request = {"floatingip": {
            "floating_network_id": self.pool.id,
            "floating_ip_address": "192.168.2.12",
            "device_id": vm.id}
            }
        response = self.post(URL, "test_user", json.dumps(request), "json")
        ip = floating_ips.get()
232
        api_ip = json.loads(response.content, "utf-8")["floatingip"]
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
        self.assertEqual(api_ip,
                         {"instance_id": str(vm.id),
                          "floating_ip_address": "192.168.2.12",
                          "fixed_ip_address": None,
                          "id": str(ip.id),
                          "port_id": str(vm.nics.all()[0].id),
                          "floating_network_id": str(self.pool.id)})

    @patch("synnefo.db.models.get_rapi_client")
    def test_update_attach(self, mrapi):
        ip = mf.IPv4AddressFactory(userid="user1", floating_ip=True, nic=None)
        vm = mf.VirtualMachineFactory(userid="user1")
        request = {"floatingip": {
            "device_id": vm.id}
            }
        with mocked_quotaholder():
            response = self.put(URL + "/%s" % ip.id, "user1",
                                json.dumps(request), "json")
        self.assertEqual(response.status_code, 202)

    def test_update_attach_conflict(self):
        ip = mf.IPv4AddressFactory(userid="user1", floating_ip=True)
        vm = mf.VirtualMachineFactory(userid="user1")
        request = {"floatingip": {
            "device_id": vm.id}
            }
        with mocked_quotaholder():
            response = self.put(URL + "/%s" % ip.id, "user1",
                                json.dumps(request), "json")
        self.assertEqual(response.status_code, 409)

    @patch("synnefo.db.models.get_rapi_client")
    def test_update_dettach(self, mrapi):
        ip = mf.IPv4AddressFactory(userid="user1", floating_ip=True)
        request = {"floatingip": {
            "device_id": None}
            }
        mrapi().ModifyInstance.return_value = 42
        with mocked_quotaholder():
            response = self.put(URL + "/%s" % ip.id, "user1",
                                json.dumps(request), "json")
        self.assertEqual(response.status_code, 202)

    def test_update_dettach_unassociated(self):
        ip = mf.IPv4AddressFactory(userid="user1", floating_ip=True, nic=None)
        request = {"floatingip": {}}
        with mocked_quotaholder():
            response = self.put(URL + "/%s" % ip.id, "user1",
                                json.dumps(request), "json")
        self.assertEqual(response.status_code, 400)

284
    def test_release_in_use(self):
285
        ip = mf.IPv4AddressFactory(userid="user1", floating_ip=True)
286
287
288
289
        vm = mf.VirtualMachineFactory(userid="user1")
        request = {"floatingip": {
            "device_id": vm.id}
            }
290
        with mocked_quotaholder():
291
292
293
294
295
296
297
298
299
300
301
302
303
304
            response = self.put(URL + "/%s" % ip.id, "user1",
                                json.dumps(request), "json")
        self.assertEqual(response.status_code, 409)

    @patch("synnefo.db.models.get_rapi_client")
    def test_update_dettach(self, mrapi):
        ip = mf.IPv4AddressFactory(userid="user1", floating_ip=True)
        request = {"floatingip": {
            "device_id": None}
            }
        mrapi().ModifyInstance.return_value = 42
        with mocked_quotaholder():
            response = self.put(URL + "/%s" % ip.id, "user1",
                                json.dumps(request), "json")
305
        self.assertEqual(response.status_code, 202)
306
307
308
309
310
311
312
313
314
315
316
317

    def test_update_dettach_unassociated(self):
        ip = mf.IPv4AddressFactory(userid="user1", floating_ip=True, nic=None)
        request = {"floatingip": {}}
        with mocked_quotaholder():
            response = self.put(URL + "/%s" % ip.id, "user1",
                                json.dumps(request), "json")
        self.assertEqual(response.status_code, 400)

    def test_release_in_use(self):
        ip = mf.IPv4AddressFactory(userid="user1", floating_ip=True)
        vm = ip.nic.machine
318
319
320
        with mocked_quotaholder():
            response = self.delete(URL + "/%s" % ip.id, ip.userid)
        self.assertFault(response, 409, "conflict")
321
322
323
324
325
326
327
    '''

    def test_update(self):
        ip = mf.IPv4AddressFactory(userid="user1", floating_ip=True, nic=None)
        with mocked_quotaholder():
            response = self.put(URL + "/%s" % ip.id, ip.userid)
        self.assertEqual(response.status_code, 501)
328
329

    def test_release(self):
330
        ip = mf.IPv4AddressFactory(userid="user1", floating_ip=True, nic=None)
331
332
333
        with mocked_quotaholder():
            response = self.delete(URL + "/%s" % ip.id, ip.userid)
        self.assertSuccess(response)
334
        ips_after = floating_ips.filter(id=ip.id)
335
        self.assertEqual(len(ips_after), 0)
336

337
338
    @patch("synnefo.logic.backend", Mock())
    def test_delete_network_with_floating_ips(self):
339
340
341
342
343
344
        ip = mf.IPv4AddressFactory(userid="user1", floating_ip=True,
                                   network=self.pool, nic=None)
        # Mark the network as non-pubic to not get 403
        network = ip.network
        network.public = False
        network.save()
345
346
        # Can not remove network with floating IPs
        with mocked_quotaholder():
347
348
349
            response = self.delete(NETWORKS_URL + "/%s" % self.pool.id,
                                   self.pool.userid)
        self.assertConflict(response)
350
351
352
353
        # But we can with only deleted Floating Ips
        ip.deleted = True
        ip.save()
        with mocked_quotaholder():
354
355
            response = self.delete(NETWORKS_URL + "/%s" % self.pool.id,
                                   self.pool.userid)
356
357
        self.assertSuccess(response)

358
'''
Christos Stavrakakis's avatar
Christos Stavrakakis committed
359
POOLS_URL = join_urls(compute_path, "os-floating-ip-pools")
360
361


362
class FloatingIPPoolsAPITest(BaseAPITest):
363
364
365
366
367
368
    def test_no_pool(self):
        response = self.get(POOLS_URL)
        self.assertSuccess(response)
        self.assertEqual(json.loads(response.content)["floating_ip_pools"], [])

    def test_list_pools(self):
369
370
371
        net = mf.NetworkWithSubnetFactory(floating_ip_pool=True,
                                          public=True,
                                          subnet__cidr="192.168.2.0/30",
372
373
374
                                          subnet__gateway="192.168.2.1",
                                          subnet__pool__size=1,
                                          subnet__pool__offset=1)
375
376
377
        mf.NetworkWithSubnetFactory(public=True, deleted=True)
        mf.NetworkWithSubnetFactory(public=False, deleted=False)
        mf.NetworkWithSubnetFactory(public=True, floating_ip_pool=False)
378
379
380
        response = self.get(POOLS_URL)
        self.assertSuccess(response)
        self.assertEqual(json.loads(response.content)["floating_ip_pools"],
381
                         [{"name": str(net.id), "size": 1, "free": 1}])
382
383


384
class FloatingIPActionsTest(BaseAPITest):
385
    def setUp(self):
386
387
388
        self.vm = VirtualMachineFactory()
        self.vm.operstate = "ACTIVE"
        self.vm.save()
389
390

    def test_bad_request(self):
Christos Stavrakakis's avatar
Christos Stavrakakis committed
391
        url = SERVERS_URL + "/%s/action" % self.vm.id
392
393
394
395
396
397
398
399
400
401
        response = self.post(url, self.vm.userid, json.dumps({}), "json")
        self.assertBadRequest(response)
        response = self.post(url, self.vm.userid,
                             json.dumps({"addFloatingIp": {}}),
                             "json")
        self.assertBadRequest(response)

    @patch('synnefo.logic.rapi_pool.GanetiRapiClient')
    def test_add_floating_ip(self, mock):
        # Not exists
Christos Stavrakakis's avatar
Christos Stavrakakis committed
402
        url = SERVERS_URL + "/%s/action" % self.vm.id
403
404
405
406
        request = {"addFloatingIp": {"address": "10.0.0.1"}}
        response = self.post(url, self.vm.userid, json.dumps(request), "json")
        self.assertItemNotFound(response)
        # In use
407
408
        ip = mf.IPv4AddressFactory(floating_ip=True, userid=self.vm.userid)
        request = {"addFloatingIp": {"address": ip.address}}
409
        response = self.post(url, self.vm.userid, json.dumps(request), "json")
410
        self.assertConflict(response)
411
        # Success
412
413
414
        ip = mf.IPv4AddressFactory(floating_ip=True, nic=None,
                                   userid=self.vm.userid)
        request = {"addFloatingIp": {"address": ip.address}}
415
        mock().ModifyInstance.return_value = 1
416
417
        response = self.post(url, self.vm.userid, json.dumps(request), "json")
        self.assertEqual(response.status_code, 202)
418
419
420
        ip_after = floating_ips.get(id=ip.id)
        self.assertEqual(ip_after.nic.machine, self.vm)
        nic = self.vm.nics.get()
421
422
        nic.state = "ACTIVE"
        nic.save()
423
424
425
426
427
        response = self.get(SERVERS_URL + "/%s" % self.vm.id,
                            self.vm.userid)
        self.assertSuccess(response)
        nic = json.loads(response.content)["server"]["attachments"][0]
        self.assertEqual(nic["OS-EXT-IPS:type"], "floating")
428
429
430
431

    @patch('synnefo.logic.rapi_pool.GanetiRapiClient')
    def test_remove_floating_ip(self, mock):
        # Not exists
Christos Stavrakakis's avatar
Christos Stavrakakis committed
432
        url = SERVERS_URL + "/%s/action" % self.vm.id
433
434
        request = {"removeFloatingIp": {"address": "10.0.0.1"}}
        response = self.post(url, self.vm.userid, json.dumps(request), "json")
435
        self.assertBadRequest(response)
436
        # Not In Use
437
438
439
        ip = mf.IPv4AddressFactory(floating_ip=True, nic=None,
                                   userid=self.vm.userid)
        request = {"removeFloatingIp": {"address": ip.address}}
440
        response = self.post(url, self.vm.userid, json.dumps(request), "json")
441
        self.assertBadRequest(response)
442
        # Success
443
444
445
        ip = mf.IPv4AddressFactory(floating_ip=True,
                                   userid=self.vm.userid, nic__machine=self.vm)
        request = {"removeFloatingIp": {"address": ip.address}}
446
        mock().ModifyInstance.return_value = 2
447
448
449
        response = self.post(url, self.vm.userid, json.dumps(request), "json")
        self.assertEqual(response.status_code, 202)
        # Yet used. Wait for the callbacks
450
451
        ip_after = floating_ips.get(id=ip.id)
        self.assertEqual(ip_after.nic.machine, self.vm)
452
'''