Statistics
| Branch: | Tag: | Revision:

root / snf-cyclades-app / synnefo / api / util.py @ 9d1e6480

History | View | Annotate | Download (18.5 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 base64 import b64encode, b64decode
35
from hashlib import sha256
36
from logging import getLogger
37
from random import choice
38
from string import digits, lowercase, uppercase
39

    
40
from Crypto.Cipher import AES
41

    
42
from django.conf import settings
43
from django.http import HttpResponse
44
from django.template.loader import render_to_string
45
from django.utils import simplejson as json
46
from django.db.models import Q
47

    
48
from snf_django.lib.api import faults
49
from synnefo.db.models import (Flavor, VirtualMachine, VirtualMachineMetadata,
50
                               Network, NetworkInterface, SecurityGroup,
51
                               BridgePoolTable, MacPrefixPoolTable, IPAddress,
52
                               IPPoolTable)
53
from synnefo.db import pools
54

    
55
from synnefo.plankton.utils import image_backend
56

    
57
from synnefo.cyclades_settings import cyclades_services, BASE_HOST
58
from synnefo.lib.services import get_service_path
59
from synnefo.lib import join_urls
60

    
61
COMPUTE_URL = \
62
    join_urls(BASE_HOST,
63
              get_service_path(cyclades_services, "compute", version="v2.0"))
64
SERVERS_URL = join_urls(COMPUTE_URL, "servers/")
65
NETWORKS_URL = join_urls(COMPUTE_URL, "networks/")
66
FLAVORS_URL = join_urls(COMPUTE_URL, "flavors/")
67
IMAGES_URL = join_urls(COMPUTE_URL, "images/")
68
PLANKTON_URL = \
69
    join_urls(BASE_HOST,
70
              get_service_path(cyclades_services, "image", version="v1.0"))
71
IMAGES_PLANKTON_URL = join_urls(PLANKTON_URL, "images/")
72

    
73
PITHOSMAP_PREFIX = "pithosmap://"
74

    
75
log = getLogger('synnefo.api')
76

    
77

    
78
def random_password():
79
    """Generates a random password
80

81
    We generate a windows compliant password: it must contain at least
82
    one charachter from each of the groups: upper case, lower case, digits.
83
    """
84

    
85
    pool = lowercase + uppercase + digits
86
    lowerset = set(lowercase)
87
    upperset = set(uppercase)
88
    digitset = set(digits)
89
    length = 10
90

    
91
    password = ''.join(choice(pool) for i in range(length - 2))
92

    
93
    # Make sure the password is compliant
94
    chars = set(password)
95
    if not chars & lowerset:
96
        password += choice(lowercase)
97
    if not chars & upperset:
98
        password += choice(uppercase)
99
    if not chars & digitset:
100
        password += choice(digits)
101

    
102
    # Pad if necessary to reach required length
103
    password += ''.join(choice(pool) for i in range(length - len(password)))
104

    
105
    return password
106

    
107

    
108
def zeropad(s):
109
    """Add zeros at the end of a string in order to make its length
110
       a multiple of 16."""
111

    
112
    npad = 16 - len(s) % 16
113
    return s + '\x00' * npad
114

    
115

    
116
def encrypt(plaintext):
117
    # Make sure key is 32 bytes long
118
    key = sha256(settings.SECRET_KEY).digest()
119

    
120
    aes = AES.new(key)
121
    enc = aes.encrypt(zeropad(plaintext))
122
    return b64encode(enc)
123

    
124

    
125
def get_vm(server_id, user_id, for_update=False, non_deleted=False,
126
           non_suspended=False, prefetch_related=None):
127
    """Find a VirtualMachine instance based on ID and owner."""
128

    
129
    try:
130
        server_id = int(server_id)
131
        servers = VirtualMachine.objects
132
        if for_update:
133
            servers = servers.select_for_update()
134
        if prefetch_related is not None:
135
            servers = servers.prefetch_related(prefetch_related)
136
        vm = servers.get(id=server_id, userid=user_id)
137
        if non_deleted and vm.deleted:
138
            raise faults.BadRequest("Server has been deleted.")
139
        if non_suspended and vm.suspended:
140
            raise faults.Forbidden("Administratively Suspended VM")
141
        return vm
142
    except ValueError:
143
        raise faults.BadRequest('Invalid server ID.')
144
    except VirtualMachine.DoesNotExist:
145
        raise faults.ItemNotFound('Server not found.')
146

    
147

    
148
def get_vm_meta(vm, key):
149
    """Return a VirtualMachineMetadata instance or raise ItemNotFound."""
150

    
151
    try:
152
        return VirtualMachineMetadata.objects.get(meta_key=key, vm=vm)
153
    except VirtualMachineMetadata.DoesNotExist:
154
        raise faults.ItemNotFound('Metadata key not found.')
155

    
156

    
157
def get_image(image_id, user_id):
158
    """Return an Image instance or raise ItemNotFound."""
159

    
160
    with image_backend(user_id) as backend:
161
        return backend.get_image(image_id)
162

    
163

    
164
def get_image_dict(image_id, user_id):
165
    image = {}
166
    img = get_image(image_id, user_id)
167
    image["id"] = img["id"]
168
    image["name"] = img["name"]
169
    image["format"] = img["disk_format"]
170
    image["checksum"] = img["checksum"]
171
    image["location"] = img["location"]
172

    
173
    checksum = image["checksum"] = img["checksum"]
174
    size = image["size"] = img["size"]
175
    image["backend_id"] = PITHOSMAP_PREFIX + "/".join([checksum, str(size)])
176

    
177
    properties = img.get("properties", {})
178
    image["metadata"] = dict((key.upper(), val)
179
                             for key, val in properties.items())
180

    
181
    return image
182

    
183

    
184
def get_flavor(flavor_id, include_deleted=False):
185
    """Return a Flavor instance or raise ItemNotFound."""
186

    
187
    try:
188
        flavor_id = int(flavor_id)
189
        if include_deleted:
190
            return Flavor.objects.get(id=flavor_id)
191
        else:
192
            return Flavor.objects.get(id=flavor_id, deleted=include_deleted)
193
    except (ValueError, Flavor.DoesNotExist):
194
        raise faults.ItemNotFound('Flavor not found.')
195

    
196

    
197
def get_flavor_provider(flavor):
198
    """Extract provider from disk template.
199

200
    Provider for `ext` disk_template is encoded in the disk template
201
    name, which is formed `ext_<provider_name>`. Provider is None
202
    for all other disk templates.
203

204
    """
205
    disk_template = flavor.disk_template
206
    provider = None
207
    if disk_template.startswith("ext"):
208
        disk_template, provider = disk_template.split("_", 1)
209
    return disk_template, provider
210

    
211

    
212
def get_network(network_id, user_id, for_update=False, non_deleted=False):
213
    """Return a Network instance or raise ItemNotFound."""
214

    
215
    try:
216
        network_id = int(network_id)
217
        objects = Network.objects.prefetch_related("subnets")
218
        if for_update:
219
            objects = objects.select_for_update()
220
        network = objects.get(Q(userid=user_id) | Q(public=True),
221
                              id=network_id)
222
        if non_deleted and network.deleted:
223
            raise faults.BadRequest("Network has been deleted.")
224
        return network
225
    except (ValueError, Network.DoesNotExist):
226
        raise faults.ItemNotFound('Network %s not found.' % network_id)
227

    
228

    
229
def get_port(port_id, user_id, for_update=False):
230
    """
231
    Return a NetworkInteface instance or raise ItemNotFound.
232
    """
233
    try:
234
        objects = NetworkInterface.objects
235
        if for_update:
236
            objects = objects.select_for_update()
237

    
238
        if not user_id:
239
            port = objects.get(id=port_id)
240
        else:
241
            port = objects.get(network__userid=user_id, id=port_id)
242

    
243
        if (port.device_owner != "vm") and for_update:
244
            raise faults.BadRequest('Can not update non vm port')
245

    
246
        return port
247
    except (ValueError, NetworkInterface.DoesNotExist):
248
        raise faults.ItemNotFound('Port not found.')
249

    
250
def get_security_group(sg_id):
251
    try:
252
        sg = SecurityGroup.objects.get(id=sg_id)
253
        return sg
254
    except (ValueError, SecurityGroup.DoesNotExist):
255
        raise faults.ItemNotFound("Not valid security group")
256

    
257
def get_floating_ip_by_address(userid, address, for_update=False):
258
    try:
259
        objects = IPAddress.objects
260
        if for_update:
261
            objects = objects.select_for_update()
262
        return objects.get(userid=userid, floating_ip=True,
263
                           address=address, deleted=False)
264
    except IPAddress.DoesNotExist:
265
        raise faults.ItemNotFound("Floating IP does not exist.")
266

    
267

    
268
def get_floating_ip_by_id(userid, floating_ip_id, for_update=False):
269
    try:
270
        objects = IPAddress.objects
271
        if for_update:
272
            objects = objects.select_for_update()
273
        if not userid:
274
            return objects.get(id=floating_ip_id, floating_ip=True,
275
                               deleted=False)
276
        else:
277
            return objects.get(id=floating_ip_id, floating_ip=True,
278
                               userid=userid, deleted=False)
279
    except IPAddress.DoesNotExist:
280
        raise faults.ItemNotFound("Floating IP %s does not exist." %
281
                                  floating_ip_id)
282

    
283

    
284
def allocate_ip_from_pools(pool_rows, userid, address=None, floating_ip=False):
285
    """Try to allocate a value from a number of pools.
286

287
    This function takes as argument a number of PoolTable objects and tries to
288
    allocate a value from them. If all pools are empty EmptyPool is raised.
289

290
    """
291
    for pool_row in pool_rows:
292
        pool = pool_row.pool
293
        try:
294
            value = pool.get(value=address)
295
            pool.save()
296
            subnet = pool_row.subnet
297
            ipaddress = IPAddress.objects.create(subnet=subnet,
298
                                                 network=subnet.network,
299
                                                 userid=userid,
300
                                                 address=value,
301
                                                 floating_ip=floating_ip)
302
            return ipaddress
303
        except pools.EmptyPool:
304
            pass
305
    raise pools.EmptyPool("No more IP addresses available on pools %s" %
306
                          pool_rows)
307

    
308

    
309
def allocate_ip(network, userid, address=None, floating_ip=False):
310
    """Try to allocate an IP from networks IP pools."""
311
    ip_pools = IPPoolTable.objects.select_for_update()\
312
        .filter(subnet__network=network)
313
    try:
314
        return allocate_ip_from_pools(ip_pools, userid, address=address,
315
                                      floating_ip=floating_ip)
316
    except pools.EmptyPool:
317
        raise faults.Conflict("No more IP addresses available on network %s"
318
                              % network.id)
319
    except pools.ValueNotAvailable:
320
        raise faults.Conflict("IP address %s is already used." % address)
321
    except pools.InvalidValue:
322
        raise faults.BadRequest("Address %s does not belong to network %s" %
323
                                (address, network.id))
324

    
325

    
326
def allocate_public_ip(userid, floating_ip=False, backend=None):
327
    """Try to allocate a public or floating IP address.
328

329
    Try to allocate a a public IPv4 address from one of the available networks.
330
    If 'floating_ip' is set, only networks which are floating IP pools will be
331
    used and the IPAddress that will be created will be marked as a floating
332
    IP. If 'backend' is set, only the networks that exist in this backend will
333
    be used.
334

335
    """
336

    
337
    ip_pool_rows = IPPoolTable.objects.select_for_update()\
338
        .prefetch_related("subnet__network")\
339
        .filter(subnet__deleted=False)\
340
        .filter(subnet__network__public=True)\
341
        .filter(subnet__network__drained=False)
342
    if floating_ip:
343
        ip_pool_rows = ip_pool_rows\
344
            .filter(subnet__network__floating_ip_pool=True)
345
    if backend is not None:
346
        ip_pool_rows = ip_pool_rows\
347
            .filter(subnet__network__backend_networks__backend=backend)
348

    
349
    try:
350
        return allocate_ip_from_pools(ip_pool_rows, userid,
351
                                      floating_ip=floating_ip)
352
    except pools.EmptyPool:
353
        ip_type = "floating" if floating_ip else "public"
354
        log_msg = "Failed to allocate a %s IP. Reason:" % ip_type
355
        if ip_pool_rows:
356
            log_msg += " No network exists."
357
        else:
358
            log_msg += " All network are full."
359
        if backend is not None:
360
            log_msg += " Backend: %s" % backend
361
        log.error(log_msg)
362
        exception_msg = "Can not allocate a %s IP address." % ip_type
363
        raise faults.ServiceUnavailable(exception_msg)
364

    
365

    
366
def backend_has_free_public_ip(backend):
367
    """Check if a backend has a free public IPv4 address."""
368
    ip_pool_rows = IPPoolTable.objects.select_for_update()\
369
        .filter(subnet__network__public=True)\
370
        .filter(subnet__network__drained=False)\
371
        .filter(subnet__deleted=False)\
372
        .filter(subnet__network__backend_networks__backend=backend)
373
    for pool_row in ip_pool_rows:
374
        pool = pool_row.pool
375
        if pool.empty():
376
            continue
377
        else:
378
            return True
379

    
380

    
381
def backend_public_networks(backend):
382
    return Network.objects.filter(deleted=False, public=True,
383
                                  backend_networks__backend=backend)
384

    
385

    
386
def get_vm_nic(vm, nic_id):
387
    """Get a VMs NIC by its ID."""
388
    try:
389
        return vm.nics.get(id=nic_id)
390
    except NetworkInterface.DoesNotExist:
391
        raise faults.ItemNotFound("NIC '%s' not found" % nic_id)
392

    
393

    
394
def get_nic(nic_id):
395
    try:
396
        return NetworkInterface.objects.get(id=nic_id)
397
    except NetworkInterface.DoesNotExist:
398
        raise faults.ItemNotFound("NIC '%s' not found" % nic_id)
399

    
400

    
401
def render_metadata(request, metadata, use_values=False, status=200):
402
    if request.serialization == 'xml':
403
        data = render_to_string('metadata.xml', {'metadata': metadata})
404
    else:
405
        if use_values:
406
            d = {'metadata': {'values': metadata}}
407
        else:
408
            d = {'metadata': metadata}
409
        data = json.dumps(d)
410
    return HttpResponse(data, status=status)
411

    
412

    
413
def render_meta(request, meta, status=200):
414
    if request.serialization == 'xml':
415
        key, val = meta.items()[0]
416
        data = render_to_string('meta.xml', dict(key=key, val=val))
417
    else:
418
        data = json.dumps(dict(meta=meta))
419
    return HttpResponse(data, status=status)
420

    
421

    
422
def verify_personality(personality):
423
    """Verify that a a list of personalities is well formed"""
424
    if len(personality) > settings.MAX_PERSONALITY:
425
        raise faults.OverLimit("Maximum number of personalities"
426
                               " exceeded")
427
    for p in personality:
428
        # Verify that personalities are well-formed
429
        try:
430
            assert isinstance(p, dict)
431
            keys = set(p.keys())
432
            allowed = set(['contents', 'group', 'mode', 'owner', 'path'])
433
            assert keys.issubset(allowed)
434
            contents = p['contents']
435
            if len(contents) > settings.MAX_PERSONALITY_SIZE:
436
                # No need to decode if contents already exceed limit
437
                raise faults.OverLimit("Maximum size of personality exceeded")
438
            if len(b64decode(contents)) > settings.MAX_PERSONALITY_SIZE:
439
                raise faults.OverLimit("Maximum size of personality exceeded")
440
        except AssertionError:
441
            raise faults.BadRequest("Malformed personality in request")
442

    
443

    
444
def values_from_flavor(flavor):
445
    """Get Ganeti connectivity info from flavor type.
446

447
    If link or mac_prefix equals to "pool", then the resources
448
    are allocated from the corresponding Pools.
449

450
    """
451
    try:
452
        flavor = Network.FLAVORS[flavor]
453
    except KeyError:
454
        raise faults.BadRequest("Unknown network flavor")
455

    
456
    mode = flavor.get("mode")
457

    
458
    link = flavor.get("link")
459
    if link == "pool":
460
        link = allocate_resource("bridge")
461

    
462
    mac_prefix = flavor.get("mac_prefix")
463
    if mac_prefix == "pool":
464
        mac_prefix = allocate_resource("mac_prefix")
465

    
466
    tags = flavor.get("tags")
467

    
468
    return mode, link, mac_prefix, tags
469

    
470

    
471
def allocate_resource(res_type):
472
    table = get_pool_table(res_type)
473
    pool = table.get_pool()
474
    value = pool.get()
475
    pool.save()
476
    return value
477

    
478

    
479
def release_resource(res_type, value):
480
    table = get_pool_table(res_type)
481
    pool = table.get_pool()
482
    pool.put(value)
483
    pool.save()
484

    
485

    
486
def get_pool_table(res_type):
487
    if res_type == "bridge":
488
        return BridgePoolTable
489
    elif res_type == "mac_prefix":
490
        return MacPrefixPoolTable
491
    else:
492
        raise Exception("Unknown resource type")
493

    
494

    
495
def get_existing_users():
496
    """
497
    Retrieve user ids stored in cyclades user agnostic models.
498
    """
499
    # also check PublicKeys a user with no servers/networks exist
500
    from synnefo.userdata.models import PublicKeyPair
501
    from synnefo.db.models import VirtualMachine, Network
502

    
503
    keypairusernames = PublicKeyPair.objects.filter().values_list('user',
504
                                                                  flat=True)
505
    serverusernames = VirtualMachine.objects.filter().values_list('userid',
506
                                                                  flat=True)
507
    networkusernames = Network.objects.filter().values_list('userid',
508
                                                            flat=True)
509

    
510
    return set(list(keypairusernames) + list(serverusernames) +
511
               list(networkusernames))
512

    
513

    
514
def vm_to_links(vm_id):
515
    href = join_urls(SERVERS_URL, str(vm_id))
516
    return [{"rel": rel, "href": href} for rel in ("self", "bookmark")]
517

    
518

    
519
def network_to_links(network_id):
520
    href = join_urls(NETWORKS_URL, str(network_id))
521
    return [{"rel": rel, "href": href} for rel in ("self", "bookmark")]
522

    
523

    
524
def flavor_to_links(flavor_id):
525
    href = join_urls(FLAVORS_URL, str(flavor_id))
526
    return [{"rel": rel, "href": href} for rel in ("self", "bookmark")]
527

    
528

    
529
def image_to_links(image_id):
530
    href = join_urls(IMAGES_URL, str(image_id))
531
    links = [{"rel": rel, "href": href} for rel in ("self", "bookmark")]
532
    links.append({"rel": "alternate",
533
                  "href": join_urls(IMAGES_PLANKTON_URL, str(image_id))})
534
    return links
535

    
536

    
537
def start_action(vm, action, jobId):
538
    vm.action = action
539
    vm.backendjobid = jobId
540
    vm.backendopcode = None
541
    vm.backendjobstatus = None
542
    vm.backendlogmsg = None
543
    vm.save()