Statistics
| Branch: | Tag: | Revision:

root / snf-cyclades-app / synnefo / db / models.py @ 0e0a6ef9

History | View | Annotate | Download (34.7 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("Backend '%s' is offline" %
125
                                            self)
126
        return get_rapi_client(self.id, self.hash,
127
                               self.clustername,
128
                               self.port,
129
                               self.username,
130
                               self.password)
131

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

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

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

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

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

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

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

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

    
180

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

    
192

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

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

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

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

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

    
217

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

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

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

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

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

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

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

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

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

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

    
344
    def get_client(self):
345
        if self.backend:
346
            return self.backend.get_client()
347
        else:
348
            raise faults.ServiceUnavailable("VirtualMachine without backend")
349

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

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

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

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

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

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

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

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

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

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

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

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

    
404

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

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

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

    
418

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

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

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

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

    
476
    NETWORK_NAME_LENGTH = 128
477

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

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

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

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

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

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

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

    
535
    def get_ip_pools(self, locked=True):
536
        subnets = self.subnets.filter(ipversion=4, deleted=False)\
537
                              .prefetch_related("ip_pools")
538
        return [ip_pool for subnet in subnets
539
                for ip_pool in subnet.get_ip_pools(locked=locked)]
540

    
541
    def reserve_address(self, address, external=False):
542
        for ip_pool in self.get_ip_pools():
543
            if ip_pool.contains(address):
544
                ip_pool.reserve(address, external=external)
545
                ip_pool.save()
546
                return
547
        raise pools.InvalidValue("Network %s does not have an IP pool that"
548
                                 " contains address %s" % (self, address))
549

    
550
    def release_address(self, address, external=True):
551
        for ip_pool in self.get_ip_pools():
552
            if ip_pool.contains(address):
553
                ip_pool.release(address, external=external)
554
                ip_pool.save()
555
                return
556
        raise pools.InvalidValue("Network %s does not have an IP pool that"
557
                                 " contains address %s" % (self, address))
558

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

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

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

    
572
    def ip_count(self):
573
        """Return the total and free IPv4 addresses of the network."""
574
        total, free = 0, 0
575
        ip_pools = self.get_ip_pools(locked=False)
576
        for ip_pool in ip_pools:
577
            total += ip_pool.pool_size
578
            free += ip_pool.count_available()
579
        return total, free
580

    
581
    class InvalidBackendIdError(Exception):
582
        def __init__(self, value):
583
            self.value = value
584

    
585
        def __str__(self):
586
            return repr(self.value)
587

    
588
    class InvalidBackendMsgError(Exception):
589
        def __init__(self, opcode, status):
590
            self.opcode = opcode
591
            self.status = status
592

    
593
        def __str__(self):
594
            return repr('<opcode: %s, status: %s>'
595
                        % (self.opcode, self.status))
596

    
597
    class InvalidActionError(Exception):
598
        def __init__(self, action):
599
            self._action = action
600

    
601
        def __str__(self):
602
            return repr(str(self._action))
603

    
604

    
605
class Subnet(models.Model):
606
    SUBNET_NAME_LENGTH = 128
607

    
608
    network = models.ForeignKey('Network', null=False, db_index=True,
609
                                related_name="subnets")
610
    name = models.CharField('Subnet Name', max_length=SUBNET_NAME_LENGTH,
611
                            null=True, default="")
612
    ipversion = models.IntegerField('IP Version', default=4, null=False)
613
    cidr = models.CharField('Subnet', max_length=64, null=False)
614
    gateway = models.CharField('Gateway', max_length=64, null=True)
615
    dhcp = models.BooleanField('DHCP', default=True, null=False)
616
    deleted = models.BooleanField('Deleted', default=False, db_index=True,
617
                                  null=False)
618
    host_routes = fields.SeparatedValuesField('Host Routes', null=True)
619
    dns_nameservers = fields.SeparatedValuesField('DNS Nameservers', null=True)
620

    
621
    def __unicode__(self):
622
        msg = u"<Subnet %s, Network: %s, CIDR: %s>"
623
        return msg % (self.id, self.network_id, self.cidr)
624

    
625
    def get_ip_pools(self, locked=True):
626
        ip_pools = self.ip_pools
627
        if locked:
628
            ip_pools = ip_pools.select_for_update()
629
        return map(lambda ip_pool: ip_pool.pool, ip_pools.all())
630

    
631

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

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

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

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

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

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

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

    
707

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

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

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

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

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

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

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

    
749
    def release_address(self):
750
        """Release the IPv4 address."""
751
        if self.ipversion == 4:
752
            for pool_row in self.subnet.ip_pools.all():
753
                ip_pool = pool_row.pool
754
                if ip_pool.contains(self.address):
755
                    ip_pool.put(self.address)
756
                    ip_pool.save()
757

    
758

    
759
class NetworkInterface(models.Model):
760
    FIREWALL_PROFILES = (
761
        ('ENABLED', 'Enabled'),
762
        ('DISABLED', 'Disabled'),
763
        ('PROTECTED', 'Protected')
764
    )
765

    
766
    STATES = (
767
        ("ACTIVE", "Active"),
768
        ("BUILDING", "Building"),
769
        ("ERROR", "Error"),
770
    )
771

    
772
    NETWORK_IFACE_NAME_LENGTH = 128
773

    
774
    name = models.CharField('NIC name', max_length=128, null=True, default="")
775
    userid = models.CharField("UUID of the owner",
776
                              max_length=NETWORK_IFACE_NAME_LENGTH,
777
                              null=True, db_index=True)
778
    machine = models.ForeignKey(VirtualMachine, related_name='nics',
779
                                on_delete=models.CASCADE)
780
    network = models.ForeignKey(Network, related_name='nics',
781
                                on_delete=models.CASCADE)
782
    created = models.DateTimeField(auto_now_add=True)
783
    updated = models.DateTimeField(auto_now=True)
784
    index = models.IntegerField(null=True)
785
    mac = models.CharField(max_length=32, null=True, unique=True)
786
    firewall_profile = models.CharField(choices=FIREWALL_PROFILES,
787
                                        max_length=30, null=True)
788
    security_groups = models.ManyToManyField("SecurityGroup", null=True)
789
    state = models.CharField(max_length=32, null=False, default="ACTIVE",
790
                             choices=STATES)
791
    device_owner = models.CharField('Device owner', max_length=128, null=True)
792

    
793
    def __unicode__(self):
794
        return "<%s:vm:%s network:%s>" % (self.id, self.machine_id,
795
                                          self.network_id)
796

    
797
    @property
798
    def backend_uuid(self):
799
        """Return the backend id by prepending backend-prefix."""
800
        return "%snic-%s" % (settings.BACKEND_PREFIX_ID, str(self.id))
801

    
802
    @property
803
    def ipv4_address(self):
804
        return self.get_ip_address(version=4)
805

    
806
    @property
807
    def ipv6_address(self):
808
        return self.get_ip_address(version=6)
809

    
810
    def get_ip_address(self, version=4):
811
        for ip in self.ips.all():
812
            if ip.subnet.ipversion == version:
813
                return ip.address
814
        return None
815

    
816
    def get_ip_addresses_subnets(self):
817
        return self.ips.values_list("address", "subnet__id")
818

    
819

    
820
class SecurityGroup(models.Model):
821
    SECURITY_GROUP_NAME_LENGTH = 128
822
    name = models.CharField('group name',
823
                            max_length=SECURITY_GROUP_NAME_LENGTH)
824

    
825

    
826
class PoolTable(models.Model):
827
    available_map = models.TextField(default="", null=False)
828
    reserved_map = models.TextField(default="", null=False)
829
    size = models.IntegerField(null=False)
830

    
831
    # Optional Fields
832
    base = models.CharField(null=True, max_length=32)
833
    offset = models.IntegerField(null=True)
834

    
835
    class Meta:
836
        abstract = True
837

    
838
    @classmethod
839
    def get_pool(cls):
840
        try:
841
            pool_row = cls.objects.select_for_update().get()
842
            return pool_row.pool
843
        except cls.DoesNotExist:
844
            raise pools.EmptyPool
845

    
846
    @property
847
    def pool(self):
848
        return self.manager(self)
849

    
850

    
851
class BridgePoolTable(PoolTable):
852
    manager = pools.BridgePool
853

    
854
    def __unicode__(self):
855
        return u"<BridgePool id:%s>" % self.id
856

    
857

    
858
class MacPrefixPoolTable(PoolTable):
859
    manager = pools.MacPrefixPool
860

    
861
    def __unicode__(self):
862
        return u"<MACPrefixPool id:%s>" % self.id
863

    
864

    
865
class IPPoolTable(PoolTable):
866
    manager = pools.IPPool
867

    
868
    subnet = models.ForeignKey('Subnet', related_name="ip_pools",
869
                               db_index=True, null=True)
870

    
871
    def __unicode__(self):
872
        return u"<IPv4AdressPool, Subnet: %s>" % self.subnet_id
873

    
874

    
875
@contextmanager
876
def pooled_rapi_client(obj):
877
        if isinstance(obj, (VirtualMachine, BackendNetwork)):
878
            backend = obj.backend
879
        else:
880
            backend = obj
881

    
882
        if backend.offline:
883
            log.warning("Trying to connect with offline backend: %s", backend)
884
            raise faults.ServiceUnavailable("Can not connect to offline"
885
                                            " backend: %s" % backend)
886

    
887
        b = backend
888
        client = get_rapi_client(b.id, b.hash, b.clustername, b.port,
889
                                 b.username, b.password)
890
        try:
891
            yield client
892
        finally:
893
            put_rapi_client(client)
894

    
895

    
896
class VirtualMachineDiagnosticManager(models.Manager):
897
    """
898
    Custom manager for :class:`VirtualMachineDiagnostic` model.
899
    """
900

    
901
    # diagnostic creation helpers
902
    def create_for_vm(self, vm, level, message, **kwargs):
903
        attrs = {'machine': vm, 'level': level, 'message': message}
904
        attrs.update(kwargs)
905
        # update instance updated time
906
        self.create(**attrs)
907
        vm.save()
908

    
909
    def create_error(self, vm, **kwargs):
910
        self.create_for_vm(vm, 'ERROR', **kwargs)
911

    
912
    def create_debug(self, vm, **kwargs):
913
        self.create_for_vm(vm, 'DEBUG', **kwargs)
914

    
915
    def since(self, vm, created_since, **kwargs):
916
        return self.get_query_set().filter(vm=vm, created__gt=created_since,
917
                                           **kwargs)
918

    
919

    
920
class VirtualMachineDiagnostic(models.Model):
921
    """
922
    Model to store backend information messages that relate to the state of
923
    the virtual machine.
924
    """
925

    
926
    TYPES = (
927
        ('ERROR', 'Error'),
928
        ('WARNING', 'Warning'),
929
        ('INFO', 'Info'),
930
        ('DEBUG', 'Debug'),
931
    )
932

    
933
    objects = VirtualMachineDiagnosticManager()
934

    
935
    created = models.DateTimeField(auto_now_add=True)
936
    machine = models.ForeignKey('VirtualMachine', related_name="diagnostics",
937
                                on_delete=models.CASCADE)
938
    level = models.CharField(max_length=20, choices=TYPES)
939
    source = models.CharField(max_length=100)
940
    source_date = models.DateTimeField(null=True)
941
    message = models.CharField(max_length=255)
942
    details = models.TextField(null=True)
943

    
944
    class Meta:
945
        ordering = ['-created']