Statistics
| Branch: | Tag: | Revision:

root / snf-cyclades-app / synnefo / logic / servers.py @ ff5edb80

History | View | Annotate | Download (28.9 kB)

1
# Copyright 2011-2014 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 logging
31

    
32
from socket import getfqdn
33
from functools import wraps
34
from django import dispatch
35
from django.db import transaction
36
from django.utils import simplejson as json
37

    
38
from snf_django.lib.api import faults
39
from django.conf import settings
40
from synnefo import quotas
41
from synnefo.api import util
42
from synnefo.logic import backend, ips, utils
43
from synnefo.logic.backend_allocator import BackendAllocator
44
from synnefo.db.models import (NetworkInterface, VirtualMachine,
45
                               VirtualMachineMetadata, IPAddressLog, Network)
46
from vncauthproxy.client import request_forwarding as request_vnc_forwarding
47
from synnefo.logic import rapi
48

    
49
log = logging.getLogger(__name__)
50

    
51
# server creation signal
52
server_created = dispatch.Signal(providing_args=["created_vm_params"])
53

    
54

    
55
def validate_server_action(vm, action):
56
    if vm.deleted:
57
        raise faults.BadRequest("Server '%s' has been deleted." % vm.id)
58

    
59
    # Destroyin a server should always be permitted
60
    if action == "DESTROY":
61
        return
62

    
63
    # Check that there is no pending action
64
    pending_action = vm.task
65
    if pending_action:
66
        if pending_action == "BUILD":
67
            raise faults.BuildInProgress("Server '%s' is being build." % vm.id)
68
        raise faults.BadRequest("Cannot perform '%s' action while there is a"
69
                                " pending '%s'." % (action, pending_action))
70

    
71
    # Check if action can be performed to VM's operstate
72
    operstate = vm.operstate
73
    if operstate == "ERROR":
74
        raise faults.BadRequest("Cannot perform '%s' action while server is"
75
                                " in 'ERROR' state." % action)
76
    elif operstate == "BUILD" and action != "BUILD":
77
        raise faults.BuildInProgress("Server '%s' is being build." % vm.id)
78
    elif (action == "START" and operstate != "STOPPED") or\
79
         (action == "STOP" and operstate != "STARTED") or\
80
         (action == "RESIZE" and operstate != "STOPPED") or\
81
         (action in ["CONNECT", "DISCONNECT"] and operstate != "STOPPED"
82
          and not settings.GANETI_USE_HOTPLUG):
83
        raise faults.BadRequest("Cannot perform '%s' action while server is"
84
                                " in '%s' state." % (action, operstate))
85
    return
86

    
87

    
88
def server_command(action, action_fields=None):
89
    """Handle execution of a server action.
90

91
    Helper function to validate and execute a server action, handle quota
92
    commission and update the 'task' of the VM in the DB.
93

94
    1) Check if action can be performed. If it can, then there must be no
95
       pending task (with the exception of DESTROY).
96
    2) Handle previous commission if unresolved:
97
       * If it is not pending and it to accept, then accept
98
       * If it is not pending and to reject or is pending then reject it. Since
99
       the action can be performed only if there is no pending task, then there
100
       can be no pending commission. The exception is DESTROY, but in this case
101
       the commission can safely be rejected, and the dispatcher will generate
102
       the correct ones!
103
    3) Issue new commission and associate it with the VM. Also clear the task.
104
    4) Send job to ganeti
105
    5) Update task and commit
106
    """
107
    def decorator(func):
108
        @wraps(func)
109
        @transaction.commit_on_success
110
        def wrapper(vm, *args, **kwargs):
111
            user_id = vm.userid
112
            validate_server_action(vm, action)
113
            vm.action = action
114

    
115
            commission_name = "client: api, resource: %s" % vm
116
            quotas.handle_resource_commission(vm, action=action,
117
                                              action_fields=action_fields,
118
                                              commission_name=commission_name)
119
            vm.save()
120

    
121
            # XXX: Special case for server creation!
122
            if action == "BUILD":
123
                # Perform a commit, because the VirtualMachine must be saved to
124
                # DB before the OP_INSTANCE_CREATE job in enqueued in Ganeti.
125
                # Otherwise, messages will arrive from snf-dispatcher about
126
                # this instance, before the VM is stored in DB.
127
                transaction.commit()
128
                # After committing the locks are released. Refetch the instance
129
                # to guarantee x-lock.
130
                vm = VirtualMachine.objects.select_for_update().get(id=vm.id)
131

    
132
            # Send the job to Ganeti and get the associated jobID
133
            try:
134
                job_id = func(vm, *args, **kwargs)
135
            except Exception as e:
136
                if vm.serial is not None:
137
                    # Since the job never reached Ganeti, reject the commission
138
                    log.debug("Rejecting commission: '%s', could not perform"
139
                              " action '%s': %s" % (vm.serial,  action, e))
140
                    transaction.rollback()
141
                    quotas.reject_resource_serial(vm)
142
                    transaction.commit()
143
                raise
144

    
145
            if action == "BUILD" and vm.serial is not None:
146
                # XXX: Special case for server creation: we must accept the
147
                # commission because the VM has been stored in DB. Also, if
148
                # communication with Ganeti fails, the job will never reach
149
                # Ganeti, and the commission will never be resolved.
150
                quotas.accept_resource_serial(vm)
151

    
152
            log.info("user: %s, vm: %s, action: %s, job_id: %s, serial: %s",
153
                     user_id, vm.id, action, job_id, vm.serial)
154

    
155
            # store the new task in the VM
156
            if job_id is not None:
157
                vm.task = action
158
                vm.task_job_id = job_id
159
            vm.save()
160

    
161
            return vm
162
        return wrapper
163
    return decorator
164

    
165

    
166
@transaction.commit_on_success
167
def create(userid, name, password, flavor, image, metadata={},
168
           personality=[], networks=None, use_backend=None, project=None):
169
    if use_backend is None:
170
        # Allocate server to a Ganeti backend
171
        use_backend = allocate_new_server(userid, flavor)
172

    
173
    utils.check_name_length(name, VirtualMachine.VIRTUAL_MACHINE_NAME_LENGTH,
174
                            "Server name is too long")
175

    
176
    # Create the ports for the server
177
    ports = create_instance_ports(userid, networks)
178

    
179
    # Fix flavor for archipelago
180
    disk_template, provider = util.get_flavor_provider(flavor)
181
    if provider:
182
        flavor.disk_template = disk_template
183
        flavor.disk_provider = provider
184
        flavor.disk_origin = None
185
        if provider in settings.GANETI_CLONE_PROVIDERS:
186
            flavor.disk_origin = image['checksum']
187
            image['backend_id'] = 'null'
188
    else:
189
        flavor.disk_provider = None
190

    
191
    if project is None:
192
        project = userid
193

    
194
    # We must save the VM instance now, so that it gets a valid
195
    # vm.backend_vm_id.
196
    vm = VirtualMachine.objects.create(name=name,
197
                                       backend=use_backend,
198
                                       userid=userid,
199
                                       project=project,
200
                                       imageid=image["id"],
201
                                       flavor=flavor,
202
                                       operstate="BUILD")
203
    log.info("Created entry in DB for VM '%s'", vm)
204

    
205
    # Associate the ports with the server
206
    for index, port in enumerate(ports):
207
        associate_port_with_machine(port, vm)
208
        port.index = index
209
        port.save()
210

    
211
    for key, val in metadata.items():
212
        VirtualMachineMetadata.objects.create(
213
            meta_key=key,
214
            meta_value=val,
215
            vm=vm)
216

    
217
    # Create the server in Ganeti.
218
    vm = create_server(vm, ports, flavor, image, personality, password)
219

    
220
    return vm
221

    
222

    
223
@transaction.commit_on_success
224
def allocate_new_server(userid, flavor):
225
    """Allocate a new server to a Ganeti backend.
226

227
    Allocation is performed based on the owner of the server and the specified
228
    flavor. Also, backends that do not have a public IPv4 address are excluded
229
    from server allocation.
230

231
    This function runs inside a transaction, because after allocating the
232
    instance a commit must be performed in order to release all locks.
233

234
    """
235
    backend_allocator = BackendAllocator()
236
    use_backend = backend_allocator.allocate(userid, flavor)
237
    if use_backend is None:
238
        log.error("No available backend for VM with flavor %s", flavor)
239
        raise faults.ServiceUnavailable("No available backends")
240
    return use_backend
241

    
242

    
243
@server_command("BUILD")
244
def create_server(vm, nics, flavor, image, personality, password):
245
    # dispatch server created signal needed to trigger the 'vmapi', which
246
    # enriches the vm object with the 'config_url' attribute which must be
247
    # passed to the Ganeti job.
248
    server_created.send(sender=vm, created_vm_params={
249
        'img_id': image['backend_id'],
250
        'img_passwd': password,
251
        'img_format': str(image['format']),
252
        'img_personality': json.dumps(personality),
253
        'img_properties': json.dumps(image['metadata']),
254
    })
255
    # send job to Ganeti
256
    try:
257
        jobID = backend.create_instance(vm, nics, flavor, image)
258
    except:
259
        log.exception("Failed create instance '%s'", vm)
260
        jobID = None
261
        vm.operstate = "ERROR"
262
        vm.backendlogmsg = "Failed to send job to Ganeti."
263
        vm.save()
264
        vm.nics.all().update(state="ERROR")
265

    
266
    # At this point the job is enqueued in the Ganeti backend
267
    vm.backendopcode = "OP_INSTANCE_CREATE"
268
    vm.backendjobid = jobID
269
    vm.save()
270
    log.info("User %s created VM %s, NICs %s, Backend %s, JobID %s",
271
             vm.userid, vm, nics, vm.backend, str(jobID))
272

    
273
    return jobID
274

    
275

    
276
@server_command("DESTROY")
277
def destroy(vm, shutdown_timeout=None):
278
    # XXX: Workaround for race where OP_INSTANCE_REMOVE starts executing on
279
    # Ganeti before OP_INSTANCE_CREATE. This will be fixed when
280
    # OP_INSTANCE_REMOVE supports the 'depends' request attribute.
281
    if (vm.backendopcode == "OP_INSTANCE_CREATE" and
282
       vm.backendjobstatus not in rapi.JOB_STATUS_FINALIZED and
283
       backend.job_is_still_running(vm) and
284
       not backend.vm_exists_in_backend(vm)):
285
            raise faults.BuildInProgress("Server is being build")
286
    log.info("Deleting VM %s", vm)
287
    return backend.delete_instance(vm, shutdown_timeout=shutdown_timeout)
288

    
289

    
290
@server_command("START")
291
def start(vm):
292
    log.info("Starting VM %s", vm)
293
    return backend.startup_instance(vm)
294

    
295

    
296
@server_command("STOP")
297
def stop(vm, shutdown_timeout=None):
298
    log.info("Stopping VM %s", vm)
299
    return backend.shutdown_instance(vm, shutdown_timeout=shutdown_timeout)
300

    
301

    
302
@server_command("REBOOT")
303
def reboot(vm, reboot_type, shutdown_timeout=None):
304
    if reboot_type not in ("SOFT", "HARD"):
305
        raise faults.BadRequest("Malformed request. Invalid reboot"
306
                                " type %s" % reboot_type)
307
    log.info("Rebooting VM %s. Type %s", vm, reboot_type)
308

    
309
    return backend.reboot_instance(vm, reboot_type.lower(),
310
                                   shutdown_timeout=shutdown_timeout)
311

    
312

    
313
def resize(vm, flavor):
314
    action_fields = {"beparams": {"vcpus": flavor.cpu,
315
                                  "maxmem": flavor.ram}}
316
    comm = server_command("RESIZE", action_fields=action_fields)
317
    return comm(_resize)(vm, flavor)
318

    
319

    
320
def _resize(vm, flavor):
321
    old_flavor = vm.flavor
322
    # User requested the same flavor
323
    if old_flavor.id == flavor.id:
324
        raise faults.BadRequest("Server '%s' flavor is already '%s'."
325
                                % (vm, flavor))
326
    # Check that resize can be performed
327
    if old_flavor.disk != flavor.disk:
328
        raise faults.BadRequest("Cannot resize instance disk.")
329
    if old_flavor.disk_template != flavor.disk_template:
330
        raise faults.BadRequest("Cannot change instance disk template.")
331

    
332
    log.info("Resizing VM from flavor '%s' to '%s", old_flavor, flavor)
333
    return backend.resize_instance(vm, vcpus=flavor.cpu, memory=flavor.ram)
334

    
335

    
336
@transaction.commit_on_success
337
def reassign(vm, project):
338
    action_fields = {"to_project": project, "from_project": vm.project}
339
    vm.project = project
340
    vm.save()
341
    quotas.issue_and_accept_commission(vm, action="REASSIGN",
342
                                       action_fields=action_fields)
343

    
344

    
345
@server_command("SET_FIREWALL_PROFILE")
346
def set_firewall_profile(vm, profile, nic):
347
    log.info("Setting VM %s, NIC %s, firewall %s", vm, nic, profile)
348

    
349
    if profile not in [x[0] for x in NetworkInterface.FIREWALL_PROFILES]:
350
        raise faults.BadRequest("Unsupported firewall profile")
351
    backend.set_firewall_profile(vm, profile=profile, nic=nic)
352
    return None
353

    
354

    
355
@server_command("CONNECT")
356
def connect(vm, network, port=None):
357
    if port is None:
358
        port = _create_port(vm.userid, network)
359
    associate_port_with_machine(port, vm)
360

    
361
    log.info("Creating NIC %s with IPv4 Address %s", port, port.ipv4_address)
362

    
363
    return backend.connect_to_network(vm, port)
364

    
365

    
366
@server_command("DISCONNECT")
367
def disconnect(vm, nic):
368
    log.info("Removing NIC %s from VM %s", nic, vm)
369
    return backend.disconnect_from_network(vm, nic)
370

    
371

    
372
def console(vm, console_type):
373
    """Arrange for an OOB console of the specified type
374

375
    This method arranges for an OOB console of the specified type.
376
    Only consoles of type "vnc" are supported for now.
377

378
    It uses a running instance of vncauthproxy to setup proper
379
    VNC forwarding with a random password, then returns the necessary
380
    VNC connection info to the caller.
381

382
    """
383
    log.info("Get console  VM %s, type %s", vm, console_type)
384

    
385
    # Use RAPI to get VNC console information for this instance
386
    if vm.operstate != "STARTED":
387
        raise faults.BadRequest('Server not in ACTIVE state.')
388

    
389
    if settings.TEST:
390
        console_data = {'kind': 'vnc', 'host': 'ganeti_node', 'port': 1000}
391
    else:
392
        console_data = backend.get_instance_console(vm)
393

    
394
    if console_data['kind'] != 'vnc':
395
        message = 'got console of kind %s, not "vnc"' % console_data['kind']
396
        raise faults.ServiceUnavailable(message)
397

    
398
    # Let vncauthproxy decide on the source port.
399
    # The alternative: static allocation, e.g.
400
    # sport = console_data['port'] - 1000
401
    sport = 0
402
    daddr = console_data['host']
403
    dport = console_data['port']
404
    password = util.random_password()
405

    
406
    if settings.TEST:
407
        fwd = {'source_port': 1234, 'status': 'OK'}
408
    else:
409
        vnc_extra_opts = settings.CYCLADES_VNCAUTHPROXY_OPTS
410
        fwd = request_vnc_forwarding(sport, daddr, dport, password,
411
                                     **vnc_extra_opts)
412

    
413
    if fwd['status'] != "OK":
414
        raise faults.ServiceUnavailable('vncauthproxy returned error status')
415

    
416
    # Verify that the VNC server settings haven't changed
417
    if not settings.TEST:
418
        if console_data != backend.get_instance_console(vm):
419
            raise faults.ServiceUnavailable('VNC Server settings changed.')
420

    
421
    console = {
422
        'type': 'vnc',
423
        'host': getfqdn(),
424
        'port': fwd['source_port'],
425
        'password': password}
426

    
427
    return console
428

    
429

    
430
def rename(server, new_name):
431
    """Rename a VirtualMachine."""
432
    old_name = server.name
433
    server.name = new_name
434
    server.save()
435
    log.info("Renamed server '%s' from '%s' to '%s'", server, old_name,
436
             new_name)
437
    return server
438

    
439

    
440
@transaction.commit_on_success
441
def create_port(*args, **kwargs):
442
    vm = kwargs.get("machine", None)
443
    if vm is None and len(args) >= 3:
444
        vm = args[2]
445
    if vm is not None:
446
        if vm.nics.count() == settings.GANETI_MAX_NICS_PER_INSTANCE:
447
            raise faults.BadRequest("Maximum ports per server limit reached")
448
    return _create_port(*args, **kwargs)
449

    
450

    
451
def _create_port(userid, network, machine=None, use_ipaddress=None,
452
                 address=None, name="", security_groups=None,
453
                 device_owner=None):
454
    """Create a new port on the specified network.
455

456
    Create a new Port(NetworkInterface model) on the specified Network. If
457
    'machine' is specified, the machine will be connected to the network using
458
    this port. If 'use_ipaddress' argument is specified, the port will be
459
    assigned this IPAddress. Otherwise, an IPv4 address from the IPv4 subnet
460
    will be allocated.
461

462
    """
463
    if network.state != "ACTIVE":
464
        raise faults.Conflict("Cannot create port while network '%s' is in"
465
                              " '%s' status" % (network.id, network.state))
466
    elif network.action == "DESTROY":
467
        msg = "Cannot create port. Network %s is being deleted."
468
        raise faults.Conflict(msg % network.id)
469
    elif network.drained:
470
        raise faults.Conflict("Cannot create port while network %s is in"
471
                              " 'SNF:DRAINED' status" % network.id)
472

    
473
    utils.check_name_length(name, NetworkInterface.NETWORK_IFACE_NAME_LENGTH,
474
                            "Port name is too long")
475

    
476
    ipaddress = None
477
    if use_ipaddress is not None:
478
        # Use an existing IPAddress object.
479
        ipaddress = use_ipaddress
480
        if ipaddress and (ipaddress.network_id != network.id):
481
            msg = "IP Address %s does not belong to network %s"
482
            raise faults.Conflict(msg % (ipaddress.address, network.id))
483
    else:
484
        # If network has IPv4 subnets, try to allocate the address that the
485
        # the user specified or a random one.
486
        if network.subnets.filter(ipversion=4).exists():
487
            ipaddress = ips.allocate_ip(network, userid=userid,
488
                                        address=address)
489
        elif address is not None:
490
            raise faults.BadRequest("Address %s is not a valid IP for the"
491
                                    " defined network subnets" % address)
492

    
493
    if ipaddress is not None and ipaddress.nic is not None:
494
        raise faults.Conflict("IP address '%s' is already in use" %
495
                              ipaddress.address)
496

    
497
    port = NetworkInterface.objects.create(network=network,
498
                                           state="DOWN",
499
                                           userid=userid,
500
                                           device_owner=None,
501
                                           public=network.public,
502
                                           name=name)
503

    
504
    # add the security groups if any
505
    if security_groups:
506
        port.security_groups.add(*security_groups)
507

    
508
    if ipaddress is not None:
509
        # Associate IPAddress with the Port
510
        ipaddress.nic = port
511
        ipaddress.save()
512

    
513
    if machine is not None:
514
        # Connect port to the instance.
515
        machine = connect(machine, network, port)
516
        jobID = machine.task_job_id
517
        log.info("Created Port %s with IP %s. Ganeti Job: %s",
518
                 port, ipaddress, jobID)
519
    else:
520
        log.info("Created Port %s with IP %s not attached to any instance",
521
                 port, ipaddress)
522

    
523
    return port
524

    
525

    
526
def associate_port_with_machine(port, machine):
527
    """Associate a Port with a VirtualMachine.
528

529
    Associate the port with the VirtualMachine and add an entry to the
530
    IPAddressLog if the port has a public IPv4 address from a public network.
531

532
    """
533
    if port.machine is not None:
534
        raise faults.Conflict("Port %s is already in use." % port.id)
535
    if port.network.public:
536
        ipv4_address = port.ipv4_address
537
        if ipv4_address is not None:
538
            ip_log = IPAddressLog.objects.create(server_id=machine.id,
539
                                                 network_id=port.network_id,
540
                                                 address=ipv4_address,
541
                                                 active=True)
542
            log.debug("Created IP log entry %s", ip_log)
543
    port.machine = machine
544
    port.state = "BUILD"
545
    port.device_owner = "vm"
546
    port.save()
547
    return port
548

    
549

    
550
@transaction.commit_on_success
551
def delete_port(port):
552
    """Delete a port by removing the NIC card from the instance.
553

554
    Send a Job to remove the NIC card from the instance. The port
555
    will be deleted and the associated IPv4 addressess will be released
556
    when the job completes successfully.
557

558
    """
559

    
560
    vm = port.machine
561
    if vm is not None and not vm.deleted:
562
        vm = disconnect(port.machine, port)
563
        log.info("Removing port %s, Job: %s", port, vm.task_job_id)
564
    else:
565
        backend.remove_nic_ips(port)
566
        port.delete()
567
        log.info("Removed port %s", port)
568

    
569
    return port
570

    
571

    
572
def create_instance_ports(user_id, networks=None):
573
    # First connect the instance to the networks defined by the admin
574
    forced_ports = create_ports_for_setting(user_id, category="admin")
575
    if networks is None:
576
        # If the user did not asked for any networks, connect instance to
577
        # default networks as defined by the admin
578
        ports = create_ports_for_setting(user_id, category="default")
579
    else:
580
        # Else just connect to the networks that the user defined
581
        ports = create_ports_for_request(user_id, networks)
582
    total_ports = forced_ports + ports
583
    if len(total_ports) > settings.GANETI_MAX_NICS_PER_INSTANCE:
584
        raise faults.BadRequest("Maximum ports per server limit reached")
585
    return total_ports
586

    
587

    
588
def create_ports_for_setting(user_id, category):
589
    if category == "admin":
590
        network_setting = settings.CYCLADES_FORCED_SERVER_NETWORKS
591
        exception = faults.ServiceUnavailable
592
    elif category == "default":
593
        network_setting = settings.CYCLADES_DEFAULT_SERVER_NETWORKS
594
        exception = faults.Conflict
595
    else:
596
        raise ValueError("Unknown category: %s" % category)
597

    
598
    ports = []
599
    for network_ids in network_setting:
600
        # Treat even simple network IDs as group of networks with one network
601
        if type(network_ids) not in (list, tuple):
602
            network_ids = [network_ids]
603

    
604
        error_msgs = []
605
        for network_id in network_ids:
606
            success = False
607
            try:
608
                ports.append(_port_from_setting(user_id, network_id, category))
609
                # Port successfully created in one of the networks. Skip the
610
                # the rest.
611
                success = True
612
                break
613
            except faults.Conflict as e:
614
                if len(network_ids) == 1:
615
                    raise exception(e.message)
616
                else:
617
                    error_msgs.append(e.message)
618

    
619
        if not success:
620
            if category == "admin":
621
                log.error("Cannot connect server to forced networks '%s': %s",
622
                          network_ids, error_msgs)
623
                raise exception("Cannot connect server to forced server"
624
                                " networks.")
625
            else:
626
                log.debug("Cannot connect server to default networks '%s': %s",
627
                          network_ids, error_msgs)
628
                raise exception("Cannot connect server to default server"
629
                                " networks.")
630

    
631
    return ports
632

    
633

    
634
def _port_from_setting(user_id, network_id, category):
635
    # TODO: Fix this..you need only IPv4 and only IPv6 network
636
    if network_id == "SNF:ANY_PUBLIC_IPV4":
637
        return create_public_ipv4_port(user_id, category=category)
638
    elif network_id == "SNF:ANY_PUBLIC_IPV6":
639
        return create_public_ipv6_port(user_id, category=category)
640
    elif network_id == "SNF:ANY_PUBLIC":
641
        try:
642
            return create_public_ipv4_port(user_id, category=category)
643
        except faults.Conflict as e1:
644
            try:
645
                return create_public_ipv6_port(user_id, category=category)
646
            except faults.Conflict as e2:
647
                log.error("Failed to connect server to a public IPv4 or IPv6"
648
                          " network. IPv4: %s, IPv6: %s", e1, e2)
649
                msg = ("Cannot connect server to a public IPv4 or IPv6"
650
                       " network.")
651
                raise faults.Conflict(msg)
652
    else:  # Case of network ID
653
        if category in ["user", "default"]:
654
            return _port_for_request(user_id, {"uuid": network_id})
655
        elif category == "admin":
656
            network = util.get_network(network_id, user_id, non_deleted=True)
657
            return _create_port(user_id, network)
658
        else:
659
            raise ValueError("Unknown category: %s" % category)
660

    
661

    
662
def create_public_ipv4_port(user_id, network=None, address=None,
663
                            category="user"):
664
    """Create a port in a public IPv4 network.
665

666
    Create a port in a public IPv4 network (that may also have an IPv6
667
    subnet). If the category is 'user' or 'default' this will try to use
668
    one of the users floating IPs. If the category is 'admin' will
669
    create a port to the public network (without floating IPs or quotas).
670

671
    """
672
    if category in ["user", "default"]:
673
        if address is None:
674
            ipaddress = ips.get_free_floating_ip(user_id, network)
675
        else:
676
            ipaddress = util.get_floating_ip_by_address(user_id, address,
677
                                                        for_update=True)
678
    elif category == "admin":
679
        if network is None:
680
            ipaddress = ips.allocate_public_ip(user_id)
681
        else:
682
            ipaddress = ips.allocate_ip(network, user_id)
683
    else:
684
        raise ValueError("Unknown category: %s" % category)
685
    if network is None:
686
        network = ipaddress.network
687
    return _create_port(user_id, network, use_ipaddress=ipaddress)
688

    
689

    
690
def create_public_ipv6_port(user_id, category=None):
691
    """Create a port in a public IPv6 only network."""
692
    networks = Network.objects.filter(public=True, deleted=False,
693
                                      drained=False, subnets__ipversion=6)\
694
                              .exclude(subnets__ipversion=4)
695
    if networks:
696
        return _create_port(user_id, networks[0])
697
    else:
698
        msg = "No available IPv6 only network!"
699
        log.error(msg)
700
        raise faults.Conflict(msg)
701

    
702

    
703
def create_ports_for_request(user_id, networks):
704
    """Create the server ports requested by the user.
705

706
    Create the ports for the new servers as requested in the 'networks'
707
    attribute. The networks attribute contains either a list of network IDs
708
    ('uuid') or a list of ports IDs ('port'). In case of network IDs, the user
709
    can also specify an IPv4 address ('fixed_ip'). In order to connect to a
710
    public network, the 'fixed_ip' attribute must contain the IPv4 address of a
711
    floating IP. If the network is public but the 'fixed_ip' attribute is not
712
    specified, the system will automatically reserve one of the users floating
713
    IPs.
714

715
    """
716
    if not isinstance(networks, list):
717
        raise faults.BadRequest("Malformed request. Invalid 'networks' field")
718
    return [_port_for_request(user_id, network) for network in networks]
719

    
720

    
721
def _port_for_request(user_id, network_dict):
722
    if not isinstance(network_dict, dict):
723
        raise faults.BadRequest("Malformed request. Invalid 'networks' field")
724
    port_id = network_dict.get("port")
725
    network_id = network_dict.get("uuid")
726
    if port_id is not None:
727
        return util.get_port(port_id, user_id, for_update=True)
728
    elif network_id is not None:
729
        address = network_dict.get("fixed_ip")
730
        network = util.get_network(network_id, user_id, non_deleted=True)
731
        if network.public:
732
            if network.subnet4 is not None:
733
                if not "fixed_ip" in network_dict:
734
                    return create_public_ipv4_port(user_id, network)
735
                elif address is None:
736
                    msg = "Cannot connect to public network"
737
                    raise faults.BadRequest(msg % network.id)
738
                else:
739
                    return create_public_ipv4_port(user_id, network, address)
740
            else:
741
                raise faults.Forbidden("Cannot connect to IPv6 only public"
742
                                       " network %" % network.id)
743
        else:
744
            return _create_port(user_id, network, address=address)
745
    else:
746
        raise faults.BadRequest("Network 'uuid' or 'port' attribute"
747
                                " is required.")