/ - Diff - Synnefo - Greek Research and Technology Network's projects

Revision 22ee6892

     from django.db import transaction
     from datetime import datetime
     from synnefo.db.models import (Backend, VirtualMachine, Network, NetworkLink,
                                    BACKEND_STATUSES)
     from synnefo.db.models import (Backend, VirtualMachine, Network,
                                    BackendNetwork, BACKEND_STATUSES)
     from synnefo.logic import utils
     from synnefo.util.rapi import GanetiRapiClient
     log = getLogger('synnefo.logic')
-...
     def create_client(hostname, port=5080, username=None, password=None):
         return GanetiRapiClient(hostname, port, username, password)
     @transaction.commit_on_success
     def process_op_status(vm, etime, jobid, opcode, status, logmsg):
         """Process a job progress notification from the backend
-...
         vm.nics.all().delete()
         for i, nic in enumerate(nics):
             if i == 0:
             network = nic.get('network', '')
             n = str(network)
             if n == settings.GANETI_PUBLIC_NETWORK:
                 net = Network.objects.get(public=True)
             else:
                 try:
                     link = NetworkLink.objects.get(name=nic['link'])
                 except NetworkLink.DoesNotExist:
                     # Cannot find an instance of NetworkLink for
                     # the link attribute specified in the notification
                     raise NetworkLink.DoesNotExist("Cannot find a NetworkLink "
                         "object for link='%s'" % nic['link'])
                 net = link.network
                 if net is None:
                     raise Network.DoesNotExist("NetworkLink for link='%s' not "
                         "associated with an existing Network instance." %
                         nic['link'])
                 pk = utils.id_from_network_name(n)
                 net = Network.objects.get(id=pk)
             firewall = nic.get('firewall', '')
             firewall_profile = _reverse_tags.get(firewall, '')
-...
                 ipv6=nic.get('ipv6', ''),
                 firewall_profile=firewall_profile)
             # network nics modified, update network object
             net.save()
         vm.backendtime = etime
         vm.save()
         net.save()
     @transaction.commit_on_success
     def process_network_status(back_network, etime, jobid, opcode, status, logmsg):
         if status not in [x[0] for x in BACKEND_STATUSES]:
             return
             #raise Network.InvalidBackendMsgError(opcode, status)
         back_network.backendjobid = jobid
         back_network.backendjobstatus = status
         back_network.backendopcode = opcode
         back_network.backendlogmsg = logmsg
         # Notifications of success change the operating state
         state_for_success = BackendNetwork.OPER_STATE_FROM_OPCODE.get(opcode, None)
         if status == 'success' and state_for_success is not None:
             back_network.operstate = state_for_success
             if opcode == 'OP_NETWORK_REMOVE':
                 back_network.deleted = True
         if status in ('canceled', 'error'):
             utils.update_state(back_network, 'ERROR')
         if (status == 'error' and opcode == 'OP_NETWORK_REMOVE' and
             back_network.operstate == 'ERROR'):
             back_network.deleted = True
             back_network.operstate = 'DELETED'
         back_network.save()
     @transaction.commit_on_success
-...
         utils.update_state(vm, status)
     def create_network_link():
         try:
             last = NetworkLink.objects.order_by('-index')[0]
             index = last.index + 1
         except IndexError:
             index = 1
     def create_network(network, backends=None):
         """ Add and connect a network to backends.
         if index <= settings.GANETI_MAX_LINK_NUMBER:
             name = '%s%d' % (settings.GANETI_LINK_PREFIX, index)
             return NetworkLink.objects.create(index=index, name=name,
                                                 available=True)
         return None     # All link slots are filled
         @param network: Network object
         @param backends: List of Backend objects. None defaults to all.
         """
         backend_jobs = _create_network(network, backends)
         connect_network(network, backend_jobs)
         return network
     @transaction.commit_on_success
     def create_network(name, user_id):
         try:
             link = NetworkLink.objects.filter(available=True)[0]
         except IndexError:
             link = create_network_link()
             if not link:
                 raise NetworkLink.NotAvailable
         network = Network.objects.create(
             name=name,
             userid=user_id,
             state='ACTIVE',
             link=link)
         link.network = network
         link.available = False
         link.save()
         return network
     def _create_network(network, backends=None):
         """Add a network to backends.
         @param network: Network object
         @param backends: List of Backend objects. None defaults to all.
         """
     @transaction.commit_on_success
     def delete_network(net):
         link = net.link
         if link.name != settings.GANETI_NULL_LINK:
             link.available = True
             link.network = None
             link.save()
         for vm in net.machines.all():
             disconnect_from_network(vm, net)
             vm.save()
         net.state = 'DELETED'
         net.save()
         network_type = network.public and 'public' or 'private'
         if not backends:
             backends = Backend.objects.exclude(offline=True)
         tags = network.backend_tag
         if network.dhcp:
             tags.append('nfdhcpd')
         tags = ','.join(tags)
         backend_jobs = []
         for backend in backends:
             job = backend.client.CreateNetwork(
                     network_name=network.backend_id,
                     network=network.subnet,
                     gateway=network.gateway,
                     network_type=network_type,
                     mac_prefix=network.mac_prefix,
                     tags=tags)
             backend_jobs.append((backend, job))
         return backend_jobs
     def connect_network(network, backend_jobs=None):
         """Connect a network to all nodegroups.
         @param network: Network object
         @param backend_jobs: List of tuples of the form (Backend, jobs) which are
                              the backends to connect the network and the jobs on
                              which the connect job depends.
         """
         mode = network.public and 'routed' or 'bridged'
     def connect_to_network(vm, net):
         nic = {'mode': 'bridged', 'link': net.link.name}
         vm.client.ModifyInstance(vm.backend_vm_id, nics=[('add', -1, nic)],
                             hotplug=True, dry_run=settings.TEST)
         if not backend_jobs:
             backend_jobs = [(backend, []) for backend in
                             Backend.objects.exclude(offline=True)]
         for backend, job in backend_jobs:
             client = backend.client
             for group in client.GetGroups():
                 client.ConnectNetwork(network.backend_id, group, mode,
                                       network.link, [job])
     def connect_network_group(backend, network, group):
         """Connect a network to a specific nodegroup of a backend.
         """
         mode = network.public and 'routed' or 'bridged'
         return backend.client.ConnectNetwork(network.backend_id, group, mode,
                                              network.link)
     def delete_network(network, backends=None):
         """ Disconnect and a remove a network from backends.
         @param network: Network object
         @param backends: List of Backend objects. None defaults to all.
         """
         backend_jobs = disconnect_network(network, backends)
         _delete_network(network, backend_jobs)
     def disconnect_network(network, backends=None):
         """Disconnect a network from virtualmachines and nodegroups.
         @param network: Network object
         @param backends: List of Backend objects. None defaults to all.
         """
         if not backends:
             backends = Backend.objects.exclude(offline=True)
         backend_jobs = []
         for backend in backends:
             client = backend.client
             jobs = []
             for vm in network.machines.filter(backend=backend):
                 job = disconnect_from_network(vm, network)
                 jobs.append(job)
             jobs2 = []
             for group in client.GetGroups():
                 job = client.DisconnectNetwork(network.backend_id, group, jobs)
                 jobs2.append(job)
             backend_jobs.append((backend, jobs2))
         return backend_jobs
     def disconnect_from_network(vm, network):
         """Disconnect a virtual machine from a network by removing it's nic.
         @param vm: VirtualMachine object
         @param network: Network object
         """
     def disconnect_from_network(vm, net):
         nics = vm.nics.filter(network__public=False).order_by('index')
         ops = [('remove', nic.index, {}) for nic in nics if nic.network == net]
         ops = [('remove', nic.index, {}) for nic in nics if nic.network == network]
         if not ops:  # Vm not connected to network
             return
         vm.client.ModifyInstance(vm.backend_vm_id, nics=ops[::-1],
                             hotplug=True, dry_run=settings.TEST)
         job = vm.client.ModifyInstance(vm.backend_vm_id, nics=ops[::-1],
                                         hotplug=True, dry_run=settings.TEST)
         return job
     def _delete_network(network, backend_jobs=None):
         if not backend_jobs:
             backend_jobs = [(backend, []) for backend in
                     Backend.objects.exclude(offline=True)]
         for backend, jobs in backend_jobs:
             backend.client.DeleteNetwork(network.backend_id, jobs)
     def connect_to_network(vm, network):
         """Connect a virtual machine to a network.
         @param vm: VirtualMachine object
         @param network: Network object
         """
         ip = network.dhcp and 'pool' or None
         nic = {'ip': ip, 'network': network.backend_id}
         vm.client.ModifyInstance(vm.backend_vm_id, nics=[('add',  nic)],
                                  hotplug=True, dry_run=settings.TEST)
     def set_firewall_profile(vm, profile):

     import logging
     import json
     from functools import wraps
     from datetime import datetime
     from synnefo.db.models import VirtualMachine
     from synnefo.db.models import Backend, VirtualMachine, Network, BackendNetwork
     from synnefo.logic import utils, backend
     from synnefo.lib.utils import merge_time
-...
                 msg = json.loads(message['body'])
                 func(msg)
                 client.basic_ack(message)
             except ValueError:
                 log.error("Incoming message not in JSON format: %s", message)
             except ValueError as e:
                 log.error("Incoming message not in JSON format %s: %s", e, message)
                 client.basic_ack(message)
             except KeyError:
                 log.error("Malformed incoming JSON, missing attributes: %s",
                           message)
             except KeyError as e:
                 log.error("Malformed incoming JSON, missing attribute %s: %s",
                           e, message)
                 client.basic_ack(message)
             except Exception as e:
                 log.exception("Unexpected error: %s, msg: %s", e, msg)
         return wrapper
     def instance_from_msg(func):
         """ Decorator for getting the VirtualMachine object of the msg.
-...
                           msg['instance'], vm_id)
         return wrapper
     def network_from_msg(func):
         """ Decorator for getting the Network object of the msg.
         """ Decorator for getting the BackendNetwork object of the msg.
         """
         @handle_message_delivery
-...
             try:
                 network_id = utils.id_from_network_name(msg["network"])
                 network = Network.objects.get(id=network_id)
                 func(network, msg)
                 backend = Backend.objects.get(clustername=msg['cluster'])
                 backend_network = BackendNetwork.objects.get(network=network,
                                                              backend=backend)
                 func(backend_network, msg)
             except Network.InvalidBackendIdError:
                 log.debug("Ignoring msg for unknown network %s.", msg['network'])
             except Network.DoesNotExist:
                 log.error("Network %s with id %d not found in DB.",
                           msg['network'], vm_id)
                 log.error("Network %s not found in DB.", msg['network'])
             except Backend.DoesNotExist:
                 log.error("Backend %s not found in DB.", msg['cluster'])
             except BackendNetwork.DoesNotExist:
                 log.error("Network %s on backend %s not found in DB.",
                           msg['network'], msg['cluster'])
         return wrapper
     def if_update_required(func):
         """
         Decorator for checking if an incoming message needs to update the db.
-...
         - The message has been redelivered and the action has already been
           completed. In this case the event_time will be equal with the one
           in the database.
         - The message describes a previous state in the ganeti, from the one that is
           described in the db. In this case the event_time will be smaller from the
           one in the database.
         - The message describes a previous state in the ganeti, from the one that
           is described in the db. In this case the event_time will be smaller from
           the one in the database.
         """
         @wraps(func)
-...
             event_time = merge_time(msg['event_time'])
             db_time = target.backendtime
             if event_time <= db_time:
             if db_time and event_time <= db_time:
                 format_ = "%d/%m/%y %H:%M:%S:%f"
                 log.debug("Ignoring message %s.\nevent_timestamp: %s db_timestamp: %s",
                           msg,
-...
             log.error("Message is of unknown type %s.", msg['type'])
             return
         backend.process_network_status(network, event_time,
                                        msg['jobId'], msg['operation'],
                                        msg['status'], msg['logmsg'])
         log.debug("Done processing ganeti-network-status msg for vm %s.",
                   msg['instance'])
         log.debug("Done processing ganeti-network-status msg for network %s.",
                   msg['network'])
     @instance_from_msg
-...
             log.debug("Msg: %s", message['body'])
             client.basic_ack(message)
         except Exception as e:
             log.exception("Could not receive message")
             log.exception("Could not receive message %s" % e)

     # Utility functions
     from synnefo.db.models import VirtualMachine
     from synnefo.db.models import VirtualMachine, Network
     from django.conf import settings
-...
         return int(ns)
     def id_from_network_name(name):
         """Returns Network's Django id, given a ganeti machine name.
         Strips the ganeti prefix atm. Needs a better name!
         """
         if not str(name).startswith(settings.BACKEND_PREFIX_ID):
             raise Network.InvalidBackendIdError(str(name))
         ns = str(name).replace(settings.BACKEND_PREFIX_ID, "", 1)
         if not ns.isdigit():
             raise Network.InvalidBackendIdError(str(name))
         return int(ns)
     def get_rsapi_state(vm):
         """Returns the API state for a virtual machine

         """
         nics = {}
         key_to_attr = { 'IP': 'ip', 'MAC': 'mac', 'BRIDGE': 'link' }
         key_to_attr = { 'IP': 'ip', 'MAC': 'mac', 'BRIDGE': 'link', 'NETWORK' : 'network' }
         for env in environ.keys():
             if env.startswith("GANETI_INSTANCE_NIC"):
                 s = env.replace("GANETI_INSTANCE_NIC", "").split('_', 1)
                 if len(s) == 2 and s[0].isdigit() and s[1] in ('MAC', 'IP', 'BRIDGE'):
                 if len(s) == 2 and s[0].isdigit() and s[1] in ('MAC', 'IP', 'BRIDGE', 'NETWORK'):
                     index = int(s[0])
                     key = key_to_attr[s[1]]

Also available in: Unified diff