Statistics
| Branch: | Tag: | Revision:

root / snf-cyclades-app / synnefo / db / models.py @ 9541aab5

History | View | Annotate | Download (33.9 kB)

1
# Copyright 2011-2012 GRNET S.A. All rights reserved.
2
#
3
# Redistribution and use in source and binary forms, with or without
4
# modification, are permitted provided that the following conditions
5
# are met:
6
#
7
#   1. Redistributions of source code must retain the above copyright
8
#      notice, this list of conditions and the following disclaimer.
9
#
10
#  2. Redistributions in binary form must reproduce the above copyright
11
#     notice, this list of conditions and the following disclaimer in the
12
#     documentation and/or other materials provided with the distribution.
13
#
14
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
15
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17
# ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
18
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20
# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21
# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23
# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24
# SUCH DAMAGE.
25
#
26
# The views and conclusions contained in the software and documentation are
27
# those of the authors and should not be interpreted as representing official
28
# policies, either expressed or implied, of GRNET S.A.
29

    
30
import datetime
31

    
32
from copy import deepcopy
33
from django.conf import settings
34
from django.db import models
35

    
36
import utils
37
from contextlib import contextmanager
38
from hashlib import sha1
39
from snf_django.lib.api import faults
40
from django.conf import settings as snf_settings
41
from aes_encrypt import encrypt_db_charfield, decrypt_db_charfield
42

    
43
from synnefo.db import pools, fields
44

    
45
from synnefo.logic.rapi_pool import (get_rapi_client,
46
                                     put_rapi_client)
47

    
48
import logging
49
log = logging.getLogger(__name__)
50

    
51

    
52
class Flavor(models.Model):
53
    cpu = models.IntegerField('Number of CPUs', default=0)
54
    ram = models.IntegerField('RAM size in MiB', default=0)
55
    disk = models.IntegerField('Disk size in GiB', default=0)
56
    disk_template = models.CharField('Disk template', max_length=32)
57
    deleted = models.BooleanField('Deleted', default=False)
58

    
59
    class Meta:
60
        verbose_name = u'Virtual machine flavor'
61
        unique_together = ('cpu', 'ram', 'disk', 'disk_template')
62

    
63
    @property
64
    def name(self):
65
        """Returns flavor name (generated)"""
66
        return u'C%dR%dD%d%s' % (self.cpu, self.ram, self.disk,
67
                                 self.disk_template)
68

    
69
    def __unicode__(self):
70
        return "<%s:%s>" % (str(self.id), self.name)
71

    
72

    
73
class Backend(models.Model):
74
    clustername = models.CharField('Cluster Name', max_length=128, unique=True)
75
    port = models.PositiveIntegerField('Port', default=5080)
76
    username = models.CharField('Username', max_length=64, blank=True,
77
                                null=True)
78
    password_hash = models.CharField('Password', max_length=128, blank=True,
79
                                     null=True)
80
    # Sha1 is up to 40 characters long
81
    hash = models.CharField('Hash', max_length=40, editable=False, null=False)
82
    # Unique index of the Backend, used for the mac-prefixes of the
83
    # BackendNetworks
84
    index = models.PositiveIntegerField('Index', null=False, unique=True,
85
                                        default=0)
86
    drained = models.BooleanField('Drained', default=False, null=False)
87
    offline = models.BooleanField('Offline', default=False, null=False)
88
    # Type of hypervisor
89
    hypervisor = models.CharField('Hypervisor', max_length=32, default="kvm",
90
                                  null=False)
91
    disk_templates = fields.SeparatedValuesField("Disk Templates", null=True)
92
    # Last refresh of backend resources
93
    updated = models.DateTimeField(auto_now_add=True)
94
    # Backend resources
95
    mfree = models.PositiveIntegerField('Free Memory', default=0, null=False)
96
    mtotal = models.PositiveIntegerField('Total Memory', default=0, null=False)
97
    dfree = models.PositiveIntegerField('Free Disk', default=0, null=False)
98
    dtotal = models.PositiveIntegerField('Total Disk', default=0, null=False)
99
    pinst_cnt = models.PositiveIntegerField('Primary Instances', default=0,
100
                                            null=False)
101
    ctotal = models.PositiveIntegerField('Total number of logical processors',
102
                                         default=0, null=False)
103

    
104
    HYPERVISORS = (
105
        ("kvm", "Linux KVM hypervisor"),
106
        ("xen-pvm", "Xen PVM hypervisor"),
107
        ("xen-hvm", "Xen KVM hypervisor"),
108
    )
109

    
110
    class Meta:
111
        verbose_name = u'Backend'
112
        ordering = ["clustername"]
113

    
114
    def __unicode__(self):
115
        return self.clustername + "(id=" + str(self.id) + ")"
116

    
117
    @property
118
    def backend_id(self):
119
        return self.id
120

    
121
    def get_client(self):
122
        """Get or create a client. """
123
        if self.offline:
124
            raise faults.ServiceUnavailable
125
        return get_rapi_client(self.id, self.hash,
126
                               self.clustername,
127
                               self.port,
128
                               self.username,
129
                               self.password)
130

    
131
    @staticmethod
132
    def put_client(client):
133
            put_rapi_client(client)
134

    
135
    def create_hash(self):
136
        """Create a hash for this backend. """
137
        sha = sha1('%s%s%s%s' %
138
                   (self.clustername, self.port, self.username, self.password))
139
        return sha.hexdigest()
140

    
141
    @property
142
    def password(self):
143
        return decrypt_db_charfield(self.password_hash)
144

    
145
    @password.setter
146
    def password(self, value):
147
        self.password_hash = encrypt_db_charfield(value)
148

    
149
    def save(self, *args, **kwargs):
150
        # Create a new hash each time a Backend is saved
151
        old_hash = self.hash
152
        self.hash = self.create_hash()
153
        super(Backend, self).save(*args, **kwargs)
154
        if self.hash != old_hash:
155
            # Populate the new hash to the new instances
156
            self.virtual_machines.filter(deleted=False)\
157
                                 .update(backend_hash=self.hash)
158

    
159
    def __init__(self, *args, **kwargs):
160
        super(Backend, self).__init__(*args, **kwargs)
161
        if not self.pk:
162
            # Generate a unique index for the Backend
163
            indexes = Backend.objects.all().values_list('index', flat=True)
164
            try:
165
                first_free = [x for x in xrange(0, 16) if x not in indexes][0]
166
                self.index = first_free
167
            except IndexError:
168
                raise Exception("Can not create more than 16 backends")
169

    
170
    def use_hotplug(self):
171
        return self.hypervisor == "kvm" and snf_settings.GANETI_USE_HOTPLUG
172

    
173
    def get_create_params(self):
174
        params = deepcopy(snf_settings.GANETI_CREATEINSTANCE_KWARGS)
175
        params["hvparams"] = params.get("hvparams", {})\
176
                                   .get(self.hypervisor, {})
177
        return params
178

    
179

    
180
# A backend job may be in one of the following possible states
181
BACKEND_STATUSES = (
182
    ('queued', 'request queued'),
183
    ('waiting', 'request waiting for locks'),
184
    ('canceling', 'request being canceled'),
185
    ('running', 'request running'),
186
    ('canceled', 'request canceled'),
187
    ('success', 'request completed successfully'),
188
    ('error', 'request returned error')
189
)
190

    
191

    
192
class QuotaHolderSerial(models.Model):
193
    """Model representing a serial for a Quotaholder Commission.
194

195
    serial:   The serial that Quotaholder assigned to this commission
196
    pending:  Whether it has been decided to accept or reject this commission
197
    accept:   If pending is False, this attribute indicates whether to accept
198
              or reject this commission
199
    resolved: Whether this commission has been accepted or rejected to
200
              Quotaholder.
201

202
    """
203
    serial = models.BigIntegerField(null=False, primary_key=True,
204
                                    db_index=True)
205
    pending = models.BooleanField(default=True, db_index=True)
206
    accept = models.BooleanField(default=False)
207
    resolved = models.BooleanField(default=False)
208

    
209
    class Meta:
210
        verbose_name = u'Quota Serial'
211
        ordering = ["serial"]
212

    
213
    def __unicode__(self):
214
        return u"<serial: %s>" % self.serial
215

    
216

    
217
class VirtualMachine(models.Model):
218
    # The list of possible actions for a VM
219
    ACTIONS = (
220
        ('CREATE', 'Create VM'),
221
        ('START', 'Start VM'),
222
        ('STOP', 'Shutdown VM'),
223
        ('SUSPEND', 'Admin Suspend VM'),
224
        ('REBOOT', 'Reboot VM'),
225
        ('DESTROY', 'Destroy VM'),
226
        ('RESIZE', 'Resize a VM'),
227
        ('ADDFLOATINGIP', 'Add floating IP to VM'),
228
        ('REMOVEFLOATINGIP', 'Add floating IP to VM'),
229
    )
230

    
231
    # The internal operating state of a VM
232
    OPER_STATES = (
233
        ('BUILD', 'Queued for creation'),
234
        ('ERROR', 'Creation failed'),
235
        ('STOPPED', 'Stopped'),
236
        ('STARTED', 'Started'),
237
        ('DESTROYED', 'Destroyed'),
238
        ('RESIZE', 'Resizing')
239
    )
240

    
241
    # The list of possible operations on the backend
242
    BACKEND_OPCODES = (
243
        ('OP_INSTANCE_CREATE', 'Create Instance'),
244
        ('OP_INSTANCE_REMOVE', 'Remove Instance'),
245
        ('OP_INSTANCE_STARTUP', 'Startup Instance'),
246
        ('OP_INSTANCE_SHUTDOWN', 'Shutdown Instance'),
247
        ('OP_INSTANCE_REBOOT', 'Reboot Instance'),
248

    
249
        # These are listed here for completeness,
250
        # and are ignored for the time being
251
        ('OP_INSTANCE_SET_PARAMS', 'Set Instance Parameters'),
252
        ('OP_INSTANCE_QUERY_DATA', 'Query Instance Data'),
253
        ('OP_INSTANCE_REINSTALL', 'Reinstall Instance'),
254
        ('OP_INSTANCE_ACTIVATE_DISKS', 'Activate Disks'),
255
        ('OP_INSTANCE_DEACTIVATE_DISKS', 'Deactivate Disks'),
256
        ('OP_INSTANCE_REPLACE_DISKS', 'Replace Disks'),
257
        ('OP_INSTANCE_MIGRATE', 'Migrate Instance'),
258
        ('OP_INSTANCE_CONSOLE', 'Get Instance Console'),
259
        ('OP_INSTANCE_RECREATE_DISKS', 'Recreate Disks'),
260
        ('OP_INSTANCE_FAILOVER', 'Failover Instance')
261
    )
262

    
263
    # The operating state of a VM,
264
    # upon the successful completion of a backend operation.
265
    # IMPORTANT: Make sure all keys have a corresponding
266
    # entry in BACKEND_OPCODES if you update this field, see #1035, #1111.
267
    OPER_STATE_FROM_OPCODE = {
268
        'OP_INSTANCE_CREATE': 'STARTED',
269
        'OP_INSTANCE_REMOVE': 'DESTROYED',
270
        'OP_INSTANCE_STARTUP': 'STARTED',
271
        'OP_INSTANCE_SHUTDOWN': 'STOPPED',
272
        'OP_INSTANCE_REBOOT': 'STARTED',
273
        'OP_INSTANCE_SET_PARAMS': None,
274
        'OP_INSTANCE_QUERY_DATA': None,
275
        'OP_INSTANCE_REINSTALL': None,
276
        'OP_INSTANCE_ACTIVATE_DISKS': None,
277
        'OP_INSTANCE_DEACTIVATE_DISKS': None,
278
        'OP_INSTANCE_REPLACE_DISKS': None,
279
        'OP_INSTANCE_MIGRATE': None,
280
        'OP_INSTANCE_CONSOLE': None,
281
        'OP_INSTANCE_RECREATE_DISKS': None,
282
        'OP_INSTANCE_FAILOVER': None
283
    }
284

    
285
    # This dictionary contains the correspondence between
286
    # internal operating states and Server States as defined
287
    # by the Rackspace API.
288
    RSAPI_STATE_FROM_OPER_STATE = {
289
        "BUILD": "BUILD",
290
        "ERROR": "ERROR",
291
        "STOPPED": "STOPPED",
292
        "STARTED": "ACTIVE",
293
        'RESIZE': 'RESIZE',
294
        'DESTROYED': 'DELETED',
295
    }
296

    
297
    name = models.CharField('Virtual Machine Name', max_length=255)
298
    userid = models.CharField('User ID of the owner', max_length=100,
299
                              db_index=True, null=False)
300
    backend = models.ForeignKey(Backend, null=True,
301
                                related_name="virtual_machines",
302
                                on_delete=models.PROTECT)
303
    backend_hash = models.CharField(max_length=128, null=True, editable=False)
304
    created = models.DateTimeField(auto_now_add=True)
305
    updated = models.DateTimeField(auto_now=True)
306
    imageid = models.CharField(max_length=100, null=False)
307
    hostid = models.CharField(max_length=100)
308
    flavor = models.ForeignKey(Flavor, on_delete=models.PROTECT)
309
    deleted = models.BooleanField('Deleted', default=False, db_index=True)
310
    suspended = models.BooleanField('Administratively Suspended',
311
                                    default=False)
312
    serial = models.ForeignKey(QuotaHolderSerial,
313
                               related_name='virtual_machine', null=True,
314
                               on_delete=models.SET_NULL)
315

    
316
    # VM State
317
    # The following fields are volatile data, in the sense
318
    # that they need not be persistent in the DB, but rather
319
    # get generated at runtime by quering Ganeti and applying
320
    # updates received from Ganeti.
321

    
322
    # In the future they could be moved to a separate caching layer
323
    # and removed from the database.
324
    # [vkoukis] after discussion with [faidon].
325
    action = models.CharField(choices=ACTIONS, max_length=30, null=True,
326
                              default=None)
327
    operstate = models.CharField(choices=OPER_STATES, max_length=30,
328
                                 null=False, default="BUILD")
329
    backendjobid = models.PositiveIntegerField(null=True)
330
    backendopcode = models.CharField(choices=BACKEND_OPCODES, max_length=30,
331
                                     null=True)
332
    backendjobstatus = models.CharField(choices=BACKEND_STATUSES,
333
                                        max_length=30, null=True)
334
    backendlogmsg = models.TextField(null=True)
335
    buildpercentage = models.IntegerField(default=0)
336
    backendtime = models.DateTimeField(default=datetime.datetime.min)
337

    
338
    # Latest action and corresponding Ganeti job ID, for actions issued
339
    # by the API
340
    task = models.CharField(max_length=64, null=True)
341
    task_job_id = models.BigIntegerField(null=True)
342

    
343
    def get_client(self):
344
        if self.backend:
345
            return self.backend.get_client()
346
        else:
347
            raise faults.ServiceUnavailable
348

    
349
    def get_last_diagnostic(self, **filters):
350
        try:
351
            return self.diagnostics.filter()[0]
352
        except IndexError:
353
            return None
354

    
355
    @staticmethod
356
    def put_client(client):
357
            put_rapi_client(client)
358

    
359
    def save(self, *args, **kwargs):
360
        # Store hash for first time saved vm
361
        if (self.id is None or self.backend_hash == '') and self.backend:
362
            self.backend_hash = self.backend.hash
363
        super(VirtualMachine, self).save(*args, **kwargs)
364

    
365
    @property
366
    def backend_vm_id(self):
367
        """Returns the backend id for this VM by prepending backend-prefix."""
368
        if not self.id:
369
            raise VirtualMachine.InvalidBackendIdError("self.id is None")
370
        return "%s%s" % (settings.BACKEND_PREFIX_ID, str(self.id))
371

    
372
    class Meta:
373
        verbose_name = u'Virtual machine instance'
374
        get_latest_by = 'created'
375

    
376
    def __unicode__(self):
377
        return u"<vm:%s@backend:%s>" % (self.id, self.backend_id)
378

    
379
    # Error classes
380
    class InvalidBackendIdError(Exception):
381
        def __init__(self, value):
382
            self.value = value
383

    
384
        def __str__(self):
385
            return repr(self.value)
386

    
387
    class InvalidBackendMsgError(Exception):
388
        def __init__(self, opcode, status):
389
            self.opcode = opcode
390
            self.status = status
391

    
392
        def __str__(self):
393
            return repr('<opcode: %s, status: %s>' % (self.opcode,
394
                        self.status))
395

    
396
    class InvalidActionError(Exception):
397
        def __init__(self, action):
398
            self._action = action
399

    
400
        def __str__(self):
401
            return repr(str(self._action))
402

    
403

    
404
class VirtualMachineMetadata(models.Model):
405
    meta_key = models.CharField(max_length=50)
406
    meta_value = models.CharField(max_length=500)
407
    vm = models.ForeignKey(VirtualMachine, related_name='metadata',
408
                           on_delete=models.CASCADE)
409

    
410
    class Meta:
411
        unique_together = (('meta_key', 'vm'),)
412
        verbose_name = u'Key-value pair of metadata for a VM.'
413

    
414
    def __unicode__(self):
415
        return u'%s: %s' % (self.meta_key, self.meta_value)
416

    
417

    
418
class Network(models.Model):
419
    OPER_STATES = (
420
        ('PENDING', 'Pending'),  # Unused because of lazy networks
421
        ('ACTIVE', 'Active'),
422
        ('DELETED', 'Deleted'),
423
        ('ERROR', 'Error')
424
    )
425

    
426
    ACTIONS = (
427
        ('CREATE', 'Create Network'),
428
        ('DESTROY', 'Destroy Network'),
429
        ('ADD', 'Add server to Network'),
430
        ('REMOVE', 'Remove server from Network'),
431
    )
432

    
433
    RSAPI_STATE_FROM_OPER_STATE = {
434
        'PENDING': 'PENDING',
435
        'ACTIVE': 'ACTIVE',
436
        'DELETED': 'DELETED',
437
        'ERROR': 'ERROR'
438
    }
439

    
440
    FLAVORS = {
441
        'CUSTOM': {
442
            'mode': 'bridged',
443
            'link': settings.DEFAULT_BRIDGE,
444
            'mac_prefix': settings.DEFAULT_MAC_PREFIX,
445
            'tags': None,
446
            'desc': "Basic flavor used for a bridged network",
447
        },
448
        'IP_LESS_ROUTED': {
449
            'mode': 'routed',
450
            'link': settings.DEFAULT_ROUTING_TABLE,
451
            'mac_prefix': settings.DEFAULT_MAC_PREFIX,
452
            'tags': 'ip-less-routed',
453
            'desc': "Flavor used for an IP-less routed network using"
454
                    " Proxy ARP",
455
        },
456
        'MAC_FILTERED': {
457
            'mode': 'bridged',
458
            'link': settings.DEFAULT_MAC_FILTERED_BRIDGE,
459
            'mac_prefix': 'pool',
460
            'tags': 'private-filtered',
461
            'desc': "Flavor used for bridged networks that offer isolation"
462
                    " via filtering packets based on their src "
463
                    " MAC (ebtables)",
464
        },
465
        'PHYSICAL_VLAN': {
466
            'mode': 'bridged',
467
            'link': 'pool',
468
            'mac_prefix': settings.DEFAULT_MAC_PREFIX,
469
            'tags': 'physical-vlan',
470
            'desc': "Flavor used for bridged network that offer isolation"
471
                    " via dedicated physical vlan",
472
        },
473
    }
474

    
475
    NETWORK_NAME_LENGTH = 128
476

    
477
    name = models.CharField('Network Name', max_length=NETWORK_NAME_LENGTH)
478
    userid = models.CharField('User ID of the owner', max_length=128,
479
                              null=True, db_index=True)
480
    flavor = models.CharField('Flavor', max_length=32, null=False)
481
    mode = models.CharField('Network Mode', max_length=16, null=True)
482
    link = models.CharField('Network Link', max_length=32, null=True)
483
    mac_prefix = models.CharField('MAC Prefix', max_length=32, null=False)
484
    tags = models.CharField('Network Tags', max_length=128, null=True)
485
    public = models.BooleanField(default=False, db_index=True)
486
    created = models.DateTimeField(auto_now_add=True)
487
    updated = models.DateTimeField(auto_now=True)
488
    deleted = models.BooleanField('Deleted', default=False, db_index=True)
489
    state = models.CharField(choices=OPER_STATES, max_length=32,
490
                             default='PENDING')
491
    machines = models.ManyToManyField(VirtualMachine,
492
                                      through='NetworkInterface')
493
    action = models.CharField(choices=ACTIONS, max_length=32, null=True,
494
                              default=None)
495
    drained = models.BooleanField("Drained", default=False, null=False)
496
    floating_ip_pool = models.BooleanField('Floating IP Pool', null=False,
497
                                           default=False)
498
    external_router = models.BooleanField(default=False)
499
    serial = models.ForeignKey(QuotaHolderSerial, related_name='network',
500
                               null=True, on_delete=models.SET_NULL)
501

    
502
    def __unicode__(self):
503
        return "<Network: %s>" % str(self.id)
504

    
505
    @property
506
    def backend_id(self):
507
        """Return the backend id by prepending backend-prefix."""
508
        if not self.id:
509
            raise Network.InvalidBackendIdError("self.id is None")
510
        return "%snet-%s" % (settings.BACKEND_PREFIX_ID, str(self.id))
511

    
512
    @property
513
    def backend_tag(self):
514
        """Return the network tag to be used in backend
515

516
        """
517
        if self.tags:
518
            return self.tags.split(',')
519
        else:
520
            return []
521

    
522
    def create_backend_network(self, backend=None):
523
        """Create corresponding BackendNetwork entries."""
524

    
525
        backends = [backend] if backend else\
526
            Backend.objects.filter(offline=False)
527
        for backend in backends:
528
            backend_exists =\
529
                BackendNetwork.objects.filter(backend=backend, network=self)\
530
                                      .exists()
531
            if not backend_exists:
532
                BackendNetwork.objects.create(backend=backend, network=self)
533

    
534
    def get_pool(self, locked=True):
535
        try:
536
            subnet = self.subnets.get(ipversion=4, deleted=False)
537
        except Subnet.DoesNotExist:
538
            raise pools.EmptyPool
539
        return subnet.get_pool(locked=locked)
540

    
541
    def allocate_address(self, userid):
542
        try:
543
            subnet = self.subnets.get(ipversion=4, deleted=False)
544
        except Subnet.DoesNotExist:
545
            raise pools.EmptyPool
546
        return subnet.allocate_address(userid)
547

    
548
    def reserve_address(self, address):
549
        pool = self.get_pool()
550
        pool.reserve(address)
551
        pool.save()
552

    
553
    def release_address(self, address):
554
        pool = self.get_pool()
555
        pool.put(address)
556
        pool.save()
557

    
558
    @property
559
    def subnet4(self):
560
        return self.get_subnet(version=4)
561

    
562
    @property
563
    def subnet6(self):
564
        return self.get_subnet(version=6)
565

    
566
    def get_subnet(self, version=4):
567
        for subnet in self.subnets.all():
568
            if subnet.ipversion == version:
569
                return subnet.cidr
570

    
571
    class InvalidBackendIdError(Exception):
572
        def __init__(self, value):
573
            self.value = value
574

    
575
        def __str__(self):
576
            return repr(self.value)
577

    
578
    class InvalidBackendMsgError(Exception):
579
        def __init__(self, opcode, status):
580
            self.opcode = opcode
581
            self.status = status
582

    
583
        def __str__(self):
584
            return repr('<opcode: %s, status: %s>'
585
                        % (self.opcode, self.status))
586

    
587
    class InvalidActionError(Exception):
588
        def __init__(self, action):
589
            self._action = action
590

    
591
        def __str__(self):
592
            return repr(str(self._action))
593

    
594

    
595
class Subnet(models.Model):
596
    SUBNET_NAME_LENGTH = 128
597

    
598
    network = models.ForeignKey('Network', null=False, db_index=True,
599
                                related_name="subnets")
600
    name = models.CharField('Subnet Name', max_length=SUBNET_NAME_LENGTH,
601
                            null=True)
602
    ipversion = models.IntegerField('IP Version', default=4, null=False)
603
    cidr = models.CharField('Subnet', max_length=64, null=False)
604
    gateway = models.CharField('Gateway', max_length=64, null=True)
605
    dhcp = models.BooleanField('DHCP', default=True, null=False)
606
    deleted = models.BooleanField('Deleted', default=False, db_index=True,
607
                                  null=False)
608
    host_routes = fields.SeparatedValuesField('Host Routes', null=True)
609
    dns_nameservers = fields.SeparatedValuesField('DNS Nameservers', null=True)
610

    
611
    def __unicode__(self):
612
        msg = u"<Subnet %s, Network: %s, CIDR: %s>"
613
        return msg % (self.id, self.network_id, self.cidr)
614

    
615
    def get_pool(self, locked=True):
616
        if self.ipversion == 6:
617
            raise Exception("IPv6 Subnets have no IP Pool.")
618
        ip_pools = self.ip_pools
619
        if locked:
620
            ip_pools = ip_pools.select_for_update()
621
        return ip_pools.all()[0].pool
622

    
623
    def allocate_address(self, userid):
624
        pool = self.get_pool(locked=True)
625
        address = pool.get()
626
        pool.save()
627
        return IPAddress.objects.create(network=self.network, subnet=self,
628
                                        address=address, userid=userid)
629

    
630

    
631
class BackendNetwork(models.Model):
632
    OPER_STATES = (
633
        ('PENDING', 'Pending'),
634
        ('ACTIVE', 'Active'),
635
        ('DELETED', 'Deleted'),
636
        ('ERROR', 'Error')
637
    )
638

    
639
    # The list of possible operations on the backend
640
    BACKEND_OPCODES = (
641
        ('OP_NETWORK_ADD', 'Create Network'),
642
        ('OP_NETWORK_CONNECT', 'Activate Network'),
643
        ('OP_NETWORK_DISCONNECT', 'Deactivate Network'),
644
        ('OP_NETWORK_REMOVE', 'Remove Network'),
645
        # These are listed here for completeness,
646
        # and are ignored for the time being
647
        ('OP_NETWORK_SET_PARAMS', 'Set Network Parameters'),
648
        ('OP_NETWORK_QUERY_DATA', 'Query Network Data')
649
    )
650

    
651
    # The operating state of a Netowork,
652
    # upon the successful completion of a backend operation.
653
    # IMPORTANT: Make sure all keys have a corresponding
654
    # entry in BACKEND_OPCODES if you update this field, see #1035, #1111.
655
    OPER_STATE_FROM_OPCODE = {
656
        'OP_NETWORK_ADD': 'PENDING',
657
        'OP_NETWORK_CONNECT': 'ACTIVE',
658
        'OP_NETWORK_DISCONNECT': 'PENDING',
659
        'OP_NETWORK_REMOVE': 'DELETED',
660
        'OP_NETWORK_SET_PARAMS': None,
661
        'OP_NETWORK_QUERY_DATA': None
662
    }
663

    
664
    network = models.ForeignKey(Network, related_name='backend_networks',
665
                                on_delete=models.CASCADE)
666
    backend = models.ForeignKey(Backend, related_name='networks',
667
                                on_delete=models.PROTECT)
668
    created = models.DateTimeField(auto_now_add=True)
669
    updated = models.DateTimeField(auto_now=True)
670
    deleted = models.BooleanField('Deleted', default=False)
671
    mac_prefix = models.CharField('MAC Prefix', max_length=32, null=False)
672
    operstate = models.CharField(choices=OPER_STATES, max_length=30,
673
                                 default='PENDING')
674
    backendjobid = models.PositiveIntegerField(null=True)
675
    backendopcode = models.CharField(choices=BACKEND_OPCODES, max_length=30,
676
                                     null=True)
677
    backendjobstatus = models.CharField(choices=BACKEND_STATUSES,
678
                                        max_length=30, null=True)
679
    backendlogmsg = models.TextField(null=True)
680
    backendtime = models.DateTimeField(null=False,
681
                                       default=datetime.datetime.min)
682

    
683
    class Meta:
684
        # Ensure one entry for each network in each backend
685
        unique_together = (("network", "backend"))
686

    
687
    def __init__(self, *args, **kwargs):
688
        """Initialize state for just created BackendNetwork instances."""
689
        super(BackendNetwork, self).__init__(*args, **kwargs)
690
        if not self.mac_prefix:
691
            # Generate the MAC prefix of the BackendNetwork, by combining
692
            # the Network prefix with the index of the Backend
693
            net_prefix = self.network.mac_prefix
694
            backend_suffix = hex(self.backend.index).replace('0x', '')
695
            mac_prefix = net_prefix + backend_suffix
696
            try:
697
                utils.validate_mac(mac_prefix + ":00:00:00")
698
            except utils.InvalidMacAddress:
699
                raise utils.InvalidMacAddress("Invalid MAC prefix '%s'" %
700
                                              mac_prefix)
701
            self.mac_prefix = mac_prefix
702

    
703
    def __unicode__(self):
704
        return '<%s@%s>' % (self.network, self.backend)
705

    
706

    
707
class IPAddress(models.Model):
708
    subnet = models.ForeignKey("Subnet", related_name="ips", null=False,
709
                               on_delete=models.CASCADE)
710
    network = models.ForeignKey(Network, related_name="ips", null=False,
711
                                on_delete=models.CASCADE)
712
    nic = models.ForeignKey("NetworkInterface", related_name="ips", null=True,
713
                            on_delete=models.SET_NULL)
714
    userid = models.CharField("UUID of the owner", max_length=128, null=False,
715
                              db_index=True)
716
    address = models.CharField("IP Address", max_length=64, null=False)
717
    floating_ip = models.BooleanField("Floating IP", null=False, default=False)
718
    created = models.DateTimeField(auto_now_add=True)
719
    updated = models.DateTimeField(auto_now=True)
720
    deleted = models.BooleanField(default=False, null=False)
721

    
722
    serial = models.ForeignKey(QuotaHolderSerial,
723
                               related_name="ips", null=True,
724
                               on_delete=models.SET_NULL)
725

    
726
    def __unicode__(self):
727
        ip_type = "floating" if self.floating_ip else "static"
728
        return u"<IPAddress: %s, Network: %s, Subnet: %s, Type: %s>"\
729
               % (self.address, self.network_id, self.subnet_id, ip_type)
730

    
731
    def in_use(self):
732
        if self.machine is None:
733
            return False
734
        else:
735
            return (not self.machine.deleted)
736

    
737
    class Meta:
738
        unique_together = ("network", "address")
739

    
740
    @property
741
    def ipversion(self):
742
        return self.subnet.ipversion
743

    
744
    @property
745
    def public(self):
746
        return self.network.public
747

    
748

    
749
class NetworkInterface(models.Model):
750
    FIREWALL_PROFILES = (
751
        ('ENABLED', 'Enabled'),
752
        ('DISABLED', 'Disabled'),
753
        ('PROTECTED', 'Protected')
754
    )
755

    
756
    STATES = (
757
        ("ACTIVE", "Active"),
758
        ("BUILDING", "Building"),
759
        ("ERROR", "Error"),
760
    )
761

    
762
    NETWORK_IFACE_NAME_LENGTH = 128
763

    
764
    name = models.CharField('NIC name', max_length=128, null=True)
765
    userid = models.CharField("UUID of the owner",
766
                              max_length=NETWORK_IFACE_NAME_LENGTH,
767
                              null=True, db_index=True)
768
    machine = models.ForeignKey(VirtualMachine, related_name='nics',
769
                                on_delete=models.CASCADE)
770
    network = models.ForeignKey(Network, related_name='nics',
771
                                on_delete=models.CASCADE)
772
    created = models.DateTimeField(auto_now_add=True)
773
    updated = models.DateTimeField(auto_now=True)
774
    index = models.IntegerField(null=True)
775
    mac = models.CharField(max_length=32, null=True, unique=True)
776
    firewall_profile = models.CharField(choices=FIREWALL_PROFILES,
777
                                        max_length=30, null=True)
778
    security_groups = models.ManyToManyField("SecurityGroup", null=True)
779
    state = models.CharField(max_length=32, null=False, default="ACTIVE",
780
                             choices=STATES)
781
    device_owner = models.CharField('Device owner', max_length=128, null=True)
782

    
783
    def __unicode__(self):
784
        return "<%s:vm:%s network:%s>" % (self.id, self.machine_id,
785
                                          self.network_id)
786

    
787
    @property
788
    def backend_uuid(self):
789
        """Return the backend id by prepending backend-prefix."""
790
        return "%snic-%s" % (settings.BACKEND_PREFIX_ID, str(self.id))
791

    
792
    @property
793
    def ipv4_address(self):
794
        return self.get_ip_address(version=4)
795

    
796
    @property
797
    def ipv6_address(self):
798
        return self.get_ip_address(version=6)
799

    
800
    def get_ip_address(self, version=4):
801
        for ip in self.ips.all():
802
            if ip.subnet.ipversion == version:
803
                return ip.address
804
        return None
805

    
806
    def get_ip_addresses_subnets(self):
807
        return self.ips.values_list("address", "subnet__id")
808

    
809

    
810
class SecurityGroup(models.Model):
811
    SECURITY_GROUP_NAME_LENGTH = 128
812
    name = models.CharField('group name',
813
                            max_length=SECURITY_GROUP_NAME_LENGTH)
814

    
815

    
816
class PoolTable(models.Model):
817
    available_map = models.TextField(default="", null=False)
818
    reserved_map = models.TextField(default="", null=False)
819
    size = models.IntegerField(null=False)
820

    
821
    # Optional Fields
822
    base = models.CharField(null=True, max_length=32)
823
    offset = models.IntegerField(null=True)
824

    
825
    class Meta:
826
        abstract = True
827

    
828
    @classmethod
829
    def get_pool(cls):
830
        try:
831
            pool_row = cls.objects.select_for_update().get()
832
            return pool_row.pool
833
        except cls.DoesNotExist:
834
            raise pools.EmptyPool
835

    
836
    @property
837
    def pool(self):
838
        return self.manager(self)
839

    
840

    
841
class BridgePoolTable(PoolTable):
842
    manager = pools.BridgePool
843

    
844
    def __unicode__(self):
845
        return u"<BridgePool id:%s>" % self.id
846

    
847

    
848
class MacPrefixPoolTable(PoolTable):
849
    manager = pools.MacPrefixPool
850

    
851
    def __unicode__(self):
852
        return u"<MACPrefixPool id:%s>" % self.id
853

    
854

    
855
class IPPoolTable(PoolTable):
856
    manager = pools.IPPool
857

    
858
    subnet = models.ForeignKey('Subnet', related_name="ip_pools",
859
                               db_index=True, null=True)
860

    
861
    def __unicode__(self):
862
        return u"<IPv4AdressPool, Subnet: %s>" % self.subnet_id
863

    
864

    
865
@contextmanager
866
def pooled_rapi_client(obj):
867
        if isinstance(obj, (VirtualMachine, BackendNetwork)):
868
            backend = obj.backend
869
        else:
870
            backend = obj
871

    
872
        if backend.offline:
873
            log.warning("Trying to connect with offline backend: %s", backend)
874
            raise faults.ServiceUnavailable("Can not connect to offline"
875
                                            " backend: %s" % backend)
876

    
877
        b = backend
878
        client = get_rapi_client(b.id, b.hash, b.clustername, b.port,
879
                                 b.username, b.password)
880
        try:
881
            yield client
882
        finally:
883
            put_rapi_client(client)
884

    
885

    
886
class VirtualMachineDiagnosticManager(models.Manager):
887
    """
888
    Custom manager for :class:`VirtualMachineDiagnostic` model.
889
    """
890

    
891
    # diagnostic creation helpers
892
    def create_for_vm(self, vm, level, message, **kwargs):
893
        attrs = {'machine': vm, 'level': level, 'message': message}
894
        attrs.update(kwargs)
895
        # update instance updated time
896
        self.create(**attrs)
897
        vm.save()
898

    
899
    def create_error(self, vm, **kwargs):
900
        self.create_for_vm(vm, 'ERROR', **kwargs)
901

    
902
    def create_debug(self, vm, **kwargs):
903
        self.create_for_vm(vm, 'DEBUG', **kwargs)
904

    
905
    def since(self, vm, created_since, **kwargs):
906
        return self.get_query_set().filter(vm=vm, created__gt=created_since,
907
                                           **kwargs)
908

    
909

    
910
class VirtualMachineDiagnostic(models.Model):
911
    """
912
    Model to store backend information messages that relate to the state of
913
    the virtual machine.
914
    """
915

    
916
    TYPES = (
917
        ('ERROR', 'Error'),
918
        ('WARNING', 'Warning'),
919
        ('INFO', 'Info'),
920
        ('DEBUG', 'Debug'),
921
    )
922

    
923
    objects = VirtualMachineDiagnosticManager()
924

    
925
    created = models.DateTimeField(auto_now_add=True)
926
    machine = models.ForeignKey('VirtualMachine', related_name="diagnostics",
927
                                on_delete=models.CASCADE)
928
    level = models.CharField(max_length=20, choices=TYPES)
929
    source = models.CharField(max_length=100)
930
    source_date = models.DateTimeField(null=True)
931
    message = models.CharField(max_length=255)
932
    details = models.TextField(null=True)
933

    
934
    class Meta:
935
        ordering = ['-created']