Statistics
| Branch: | Tag: | Revision:

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

History | View | Annotate | Download (14.4 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, BackendNetwork, NetworkInterface,
51
                               BridgePoolTable, MacPrefixPoolTable, Backend,
52
                               FloatingIP)
53
from synnefo.db.pools import EmptyPool
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):
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
        vm = servers.get(id=server_id, userid=user_id)
135
        if non_deleted and vm.deleted:
136
            raise faults.BadRequest("Server has been deleted.")
137
        if non_suspended and vm.suspended:
138
            raise faults.Forbidden("Administratively Suspended VM")
139
        return vm
140
    except ValueError:
141
        raise faults.BadRequest('Invalid server ID.')
142
    except VirtualMachine.DoesNotExist:
143
        raise faults.ItemNotFound('Server not found.')
144

    
145

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

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

    
154

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

    
158
    with image_backend(user_id) as backend:
159
        return backend.get_image(image_id)
160

    
161

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

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

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

    
179
    return image
180

    
181

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

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

    
194

    
195
def get_flavor_provider(flavor):
196
    """Extract provider from disk template.
197

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

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

    
209

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

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

    
226

    
227
def get_floating_ip(user_id, ipv4, for_update=False):
228
    try:
229
        objects = FloatingIP.objects
230
        if for_update:
231
            objects = objects.select_for_update()
232
        return objects.get(userid=user_id, ipv4=ipv4, deleted=False)
233
    except FloatingIP.DoesNotExist:
234
        raise faults.ItemNotFound("Floating IP does not exist.")
235

    
236

    
237
def allocate_public_address(backend):
238
    """Get a public IP for any available network of a backend."""
239
    # Guarantee exclusive access to backend, because accessing the IP pools of
240
    # the backend networks may result in a deadlock with backend allocator
241
    # which also checks that backend networks have a free IP.
242
    backend = Backend.objects.select_for_update().get(id=backend.id)
243
    public_networks = backend_public_networks(backend)
244
    return get_free_ip(public_networks)
245

    
246

    
247
def backend_public_networks(backend):
248
    """Return available public networks of the backend.
249

250
    Iterator for non-deleted public networks that are available
251
    to the specified backend.
252

253
    """
254
    bnets = BackendNetwork.objects.filter(backend=backend,
255
                                          network__public=True,
256
                                          network__deleted=False,
257
                                          network__floating_ip_pool=False,
258
                                          network__subnet__isnull=False,
259
                                          network__drained=False)
260
    return [b.network for b in bnets]
261

    
262

    
263
def get_free_ip(networks):
264
    for network in networks:
265
        try:
266
            address = get_network_free_address(network)
267
            return network, address
268
        except faults.OverLimit:
269
            pass
270
    msg = "Can not allocate public IP. Public networks are full."
271
    log.error(msg)
272
    raise faults.OverLimit(msg)
273

    
274

    
275
def get_network_free_address(network):
276
    """Reserve an IP address from the IP Pool of the network."""
277

    
278
    pool = network.get_pool()
279
    try:
280
        address = pool.get()
281
    except EmptyPool:
282
        raise faults.OverLimit("Network %s is full." % network.backend_id)
283
    pool.save()
284
    return address
285

    
286

    
287
def get_nic(vm, nic_id):
288
    """Get a VMs NIC by its ID."""
289
    try:
290
        return vm.nics.get(id=nic_id)
291
    except NetworkInterface.DoesNotExist:
292
        raise faults.ItemNotFound("NIC '%s' not found" % nic_id)
293

    
294

    
295
def render_metadata(request, metadata, use_values=False, status=200):
296
    if request.serialization == 'xml':
297
        data = render_to_string('metadata.xml', {'metadata': metadata})
298
    else:
299
        if use_values:
300
            d = {'metadata': {'values': metadata}}
301
        else:
302
            d = {'metadata': metadata}
303
        data = json.dumps(d)
304
    return HttpResponse(data, status=status)
305

    
306

    
307
def render_meta(request, meta, status=200):
308
    if request.serialization == 'xml':
309
        key, val = meta.items()[0]
310
        data = render_to_string('meta.xml', dict(key=key, val=val))
311
    else:
312
        data = json.dumps(dict(meta=meta))
313
    return HttpResponse(data, status=status)
314

    
315

    
316
def construct_nic_id(nic):
317
    return "-".join(["nic", unicode(nic.machine.id), unicode(nic.id)])
318

    
319

    
320
def verify_personality(personality):
321
    """Verify that a a list of personalities is well formed"""
322
    if len(personality) > settings.MAX_PERSONALITY:
323
        raise faults.OverLimit("Maximum number of personalities"
324
                               " exceeded")
325
    for p in personality:
326
        # Verify that personalities are well-formed
327
        try:
328
            assert isinstance(p, dict)
329
            keys = set(p.keys())
330
            allowed = set(['contents', 'group', 'mode', 'owner', 'path'])
331
            assert keys.issubset(allowed)
332
            contents = p['contents']
333
            if len(contents) > settings.MAX_PERSONALITY_SIZE:
334
                # No need to decode if contents already exceed limit
335
                raise faults.OverLimit("Maximum size of personality exceeded")
336
            if len(b64decode(contents)) > settings.MAX_PERSONALITY_SIZE:
337
                raise faults.OverLimit("Maximum size of personality exceeded")
338
        except AssertionError:
339
            raise faults.BadRequest("Malformed personality in request")
340

    
341

    
342
def values_from_flavor(flavor):
343
    """Get Ganeti connectivity info from flavor type.
344

345
    If link or mac_prefix equals to "pool", then the resources
346
    are allocated from the corresponding Pools.
347

348
    """
349
    try:
350
        flavor = Network.FLAVORS[flavor]
351
    except KeyError:
352
        raise faults.BadRequest("Unknown network flavor")
353

    
354
    mode = flavor.get("mode")
355

    
356
    link = flavor.get("link")
357
    if link == "pool":
358
        link = allocate_resource("bridge")
359

    
360
    mac_prefix = flavor.get("mac_prefix")
361
    if mac_prefix == "pool":
362
        mac_prefix = allocate_resource("mac_prefix")
363

    
364
    tags = flavor.get("tags")
365

    
366
    return mode, link, mac_prefix, tags
367

    
368

    
369
def allocate_resource(res_type):
370
    table = get_pool_table(res_type)
371
    pool = table.get_pool()
372
    value = pool.get()
373
    pool.save()
374
    return value
375

    
376

    
377
def release_resource(res_type, value):
378
    table = get_pool_table(res_type)
379
    pool = table.get_pool()
380
    pool.put(value)
381
    pool.save()
382

    
383

    
384
def get_pool_table(res_type):
385
    if res_type == "bridge":
386
        return BridgePoolTable
387
    elif res_type == "mac_prefix":
388
        return MacPrefixPoolTable
389
    else:
390
        raise Exception("Unknown resource type")
391

    
392

    
393
def get_existing_users():
394
    """
395
    Retrieve user ids stored in cyclades user agnostic models.
396
    """
397
    # also check PublicKeys a user with no servers/networks exist
398
    from synnefo.userdata.models import PublicKeyPair
399
    from synnefo.db.models import VirtualMachine, Network
400

    
401
    keypairusernames = PublicKeyPair.objects.filter().values_list('user',
402
                                                                  flat=True)
403
    serverusernames = VirtualMachine.objects.filter().values_list('userid',
404
                                                                  flat=True)
405
    networkusernames = Network.objects.filter().values_list('userid',
406
                                                            flat=True)
407

    
408
    return set(list(keypairusernames) + list(serverusernames) +
409
               list(networkusernames))
410

    
411

    
412
def vm_to_links(vm_id):
413
    href = join_urls(SERVERS_URL, str(vm_id))
414
    return [{"rel": rel, "href": href} for rel in ("self", "bookmark")]
415

    
416

    
417
def network_to_links(network_id):
418
    href = join_urls(NETWORKS_URL, str(network_id))
419
    return [{"rel": rel, "href": href} for rel in ("self", "bookmark")]
420

    
421

    
422
def flavor_to_links(flavor_id):
423
    href = join_urls(FLAVORS_URL, str(flavor_id))
424
    return [{"rel": rel, "href": href} for rel in ("self", "bookmark")]
425

    
426

    
427
def image_to_links(image_id):
428
    href = join_urls(IMAGES_URL, str(image_id))
429
    links = [{"rel": rel, "href": href} for rel in ("self", "bookmark")]
430
    links.append({"rel": "alternate",
431
                  "href": join_urls(IMAGES_PLANKTON_URL, str(image_id))})
432
    return links
433

    
434

    
435
def start_action(vm, action, jobId):
436
    vm.action = action
437
    vm.backendjobid = jobId
438
    vm.backendopcode = None
439
    vm.backendjobstatus = None
440
    vm.backendlogmsg = None
441
    vm.save()