Statistics
| Branch: | Tag: | Revision:

root / snf-cyclades-app / synnefo / api / util.py @ 0069a20c

History | View | Annotate | Download (18.3 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
        return objects.get(id=floating_ip_id, floating_ip=True, userid=userid,
274
                           deleted=False)
275
    except IPAddress.DoesNotExist:
276
        raise faults.ItemNotFound("Floating IP %s does not exist." %
277
                                  floating_ip_id)
278

    
279

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

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

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

    
304

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

    
321

    
322
def allocate_public_ip(userid, floating_ip=False, backend=None):
323
    """Try to allocate a public or floating IP address.
324

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

331
    """
332

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

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

    
361

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

    
376

    
377
def backend_public_networks(backend):
378
    return Network.objects.filter(deleted=False, public=True,
379
                                  backend_networks__backend=backend)
380

    
381

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

    
389

    
390
def get_nic(nic_id):
391
    try:
392
        return NetworkInterface.objects.get(id=nic_id)
393
    except NetworkInterface.DoesNotExist:
394
        raise faults.ItemNotFound("NIC '%s' not found" % nic_id)
395

    
396

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

    
408

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

    
417

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

    
439

    
440
def values_from_flavor(flavor):
441
    """Get Ganeti connectivity info from flavor type.
442

443
    If link or mac_prefix equals to "pool", then the resources
444
    are allocated from the corresponding Pools.
445

446
    """
447
    try:
448
        flavor = Network.FLAVORS[flavor]
449
    except KeyError:
450
        raise faults.BadRequest("Unknown network flavor")
451

    
452
    mode = flavor.get("mode")
453

    
454
    link = flavor.get("link")
455
    if link == "pool":
456
        link = allocate_resource("bridge")
457

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

    
462
    tags = flavor.get("tags")
463

    
464
    return mode, link, mac_prefix, tags
465

    
466

    
467
def allocate_resource(res_type):
468
    table = get_pool_table(res_type)
469
    pool = table.get_pool()
470
    value = pool.get()
471
    pool.save()
472
    return value
473

    
474

    
475
def release_resource(res_type, value):
476
    table = get_pool_table(res_type)
477
    pool = table.get_pool()
478
    pool.put(value)
479
    pool.save()
480

    
481

    
482
def get_pool_table(res_type):
483
    if res_type == "bridge":
484
        return BridgePoolTable
485
    elif res_type == "mac_prefix":
486
        return MacPrefixPoolTable
487
    else:
488
        raise Exception("Unknown resource type")
489

    
490

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

    
499
    keypairusernames = PublicKeyPair.objects.filter().values_list('user',
500
                                                                  flat=True)
501
    serverusernames = VirtualMachine.objects.filter().values_list('userid',
502
                                                                  flat=True)
503
    networkusernames = Network.objects.filter().values_list('userid',
504
                                                            flat=True)
505

    
506
    return set(list(keypairusernames) + list(serverusernames) +
507
               list(networkusernames))
508

    
509

    
510
def vm_to_links(vm_id):
511
    href = join_urls(SERVERS_URL, str(vm_id))
512
    return [{"rel": rel, "href": href} for rel in ("self", "bookmark")]
513

    
514

    
515
def network_to_links(network_id):
516
    href = join_urls(NETWORKS_URL, str(network_id))
517
    return [{"rel": rel, "href": href} for rel in ("self", "bookmark")]
518

    
519

    
520
def flavor_to_links(flavor_id):
521
    href = join_urls(FLAVORS_URL, str(flavor_id))
522
    return [{"rel": rel, "href": href} for rel in ("self", "bookmark")]
523

    
524

    
525
def image_to_links(image_id):
526
    href = join_urls(IMAGES_URL, str(image_id))
527
    links = [{"rel": rel, "href": href} for rel in ("self", "bookmark")]
528
    links.append({"rel": "alternate",
529
                  "href": join_urls(IMAGES_PLANKTON_URL, str(image_id))})
530
    return links
531

    
532

    
533
def start_action(vm, action, jobId):
534
    vm.action = action
535
    vm.backendjobid = jobId
536
    vm.backendopcode = None
537
    vm.backendjobstatus = None
538
    vm.backendlogmsg = None
539
    vm.save()