/snf-cyclades-app/synnefo/logic/backend.py - Diff - Synnefo - Greek Research and Technology Network's projects

Revision 3524241a snf-cyclades-app/synnefo/logic/backend.py

     import json
     from logging import getLogger
     from django.conf import settings
     from django.db import transaction
     from datetime import datetime
     from synnefo.db.models import (Backend, VirtualMachine, Network,
                                    BackendNetwork, BACKEND_STATUSES)
                                    BackendNetwork, BACKEND_STATUSES,
                                    pooled_rapi_client)
     from synnefo.logic import utils
     from synnefo.util.rapi import GanetiRapiClient
     log = getLogger('synnefo.logic')
     from logging import getLogger
     log = getLogger(__name__)
     _firewall_tags = {
-...
     _reverse_tags = dict((v.split(':')[3], k) for k, v in _firewall_tags.items())
     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
-...
         # Defined in settings.GANETI_CREATEINSTANCE_KWARGS
         # kw['hvparams'] = dict(serial_console=False)
         return vm.client.CreateInstance(**kw)
         with pooled_rapi_client(vm) as client:
             return client.CreateInstance(**kw)
     def delete_instance(vm):
         start_action(vm, 'DESTROY')
         vm.client.DeleteInstance(vm.backend_vm_id, dry_run=settings.TEST)
         with pooled_rapi_client(vm) as client:
             return client.DeleteInstance(vm.backend_vm_id, dry_run=settings.TEST)
     def reboot_instance(vm, reboot_type):
         assert reboot_type in ('soft', 'hard')
         vm.client.RebootInstance(vm.backend_vm_id, reboot_type, dry_run=settings.TEST)
         log.info('Rebooting instance %s', vm.backend_vm_id)
         with pooled_rapi_client(vm) as client:
             return client.RebootInstance(vm.backend_vm_id, reboot_type, dry_run=settings.TEST)
     def startup_instance(vm):
         start_action(vm, 'START')
         vm.client.StartupInstance(vm.backend_vm_id, dry_run=settings.TEST)
         with pooled_rapi_client(vm) as client:
             return client.StartupInstance(vm.backend_vm_id, dry_run=settings.TEST)
     def shutdown_instance(vm):
         start_action(vm, 'STOP')
         vm.client.ShutdownInstance(vm.backend_vm_id, dry_run=settings.TEST)
         with pooled_rapi_client(vm) as client:
             return client.ShutdownInstance(vm.backend_vm_id, dry_run=settings.TEST)
     def get_instance_console(vm):
-...
+        #
         console = {}
         console['kind'] = 'vnc'
         i = vm.client.GetInstance(vm.backend_vm_id)
         with pooled_rapi_client(vm) as client:
             i = client.GetInstance(vm.backend_vm_id)
         if i['hvparams']['serial_console']:
             raise Exception("hv parameter serial_console cannot be true")
         console['host'] = i['pnode']
         console['port'] = i['network_port']
         return console
         # return rapi.GetInstanceConsole(vm.backend_vm_id)
     def request_status_update(vm):
         return vm.client.GetInstanceInfo(vm.backend_vm_id)
     def update_status(vm, status):
         utils.update_state(vm, status)
     def get_instance_info(vm):
         with pooled_rapi_client(vm) as client:
             return client.GetInstanceInfo(vm.backend_vm_id)
     def create_network(network, backends=None):
         """ Add and connect a network to backends.
         @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
     def create_network(network, backends=None, connect=True):
         """Create and connect a network."""
         if not backends:
             backends = Backend.objects.exclude(offline=True)
         for backend in backends:
             create_jobID = _create_network(network, backend)
             if connect:
                 connect_network(network, backend, create_jobID)
     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.
         """
     def _create_network(network, backend):
         """Create a network."""
         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:
             try:
                 backend_network = BackendNetwork.objects.get(network=network,
                                                              backend=backend)
             except BackendNetwork.DoesNotExist:
                 raise Exception("BackendNetwork for network '%s' in backend '%s'"\
                                 " does not exist" % (network.id, backend.id))
             job = backend.client.CreateNetwork(
                     network_name=network.backend_id,
                     network=network.subnet,
                     gateway=network.gateway,
                     network_type=network_type,
                     mac_prefix=backend_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.
         """
         if network.type in ('PUBLIC_ROUTED', 'CUSTOM_ROUTED'):
             mode = 'routed'
         else:
             mode = 'bridged'
         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():
         try:
             bn = BackendNetwork.objects.get(network=network, backend=backend)
             mac_prefix = bn.mac_prefix
         except BackendNetwork.DoesNotExist:
             raise Exception("BackendNetwork for network '%s' in backend '%s'"\
                             " does not exist" % (network.id, backend.id))
         with pooled_rapi_client(backend) as client:
             return client.CreateNetwork(network_name=network.backend_id,
                                         network=network.subnet,
                                         gateway=network.gateway,
                                         network_type=network_type,
                                         mac_prefix=mac_prefix,
                                         tags=tags)
     def connect_network(network, backend, depend_job=None, group=None):
         """Connect a network to nodegroups."""
         mode = "routed" if "ROUTED" in network.type else "bridged"
         with pooled_rapi_client(backend) as client:
             if group:
                 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.
         """
         if network.type in ('PUBLIC_ROUTED', 'CUSTOM_ROUTED'):
             mode = 'routed'
         else:
             mode = '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 all nodegroups.
                                       network.link, [depend_job])
             else:
                 for group in client.GetGroups():
                     client.ConnectNetwork(network.backend_id, group, mode,
                                           network.link, [depend_job])
         @param network: Network object
         @param backends: List of Backend objects. None defaults to all.
         """
     def delete_network(network, backends=None, disconnect=True):
         if not backends:
             backends = Backend.objects.exclude(offline=True)
         backend_jobs = []
         for backend in backends:
             client = backend.client
             jobs = []
             for group in client.GetGroups():
                 job = client.DisconnectNetwork(network.backend_id, group)
                 jobs.append(job)
             backend_jobs.append((backend, jobs))
         return backend_jobs
     def disconnect_from_network(vm, nic):
         """Disconnect a virtual machine from a network by removing it's nic.
             disconnect_jobIDs = []
             if disconnect:
                 disconnect_jobIDs = disconnect_network(network, backend)
             _delete_network(network, backend, disconnect_jobIDs)
         @param vm: VirtualMachine object
         @param network: Network object
         """
         op = [('remove', nic.index, {})]
         return vm.client.ModifyInstance(vm.backend_vm_id, nics=op,
                                         hotplug=settings.GANETI_USE_HOTPLUG,
                                         dry_run=settings.TEST)
     def _delete_network(network, backend, depend_jobs=[]):
         with pooled_rapi_client(backend) as client:
             return client.DeleteNetwork(network.backend_id, depend_jobs)
     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 disconnect_network(network, backend, group=None):
         with pooled_rapi_client(backend) as client:
             if group:
                 return [client.DisconnectNetwork(network.backend_id, group)]
             else:
                 jobs = []
                 for group in client.GetGroups():
                     job = client.DisconnectNetwork(network.backend_id, group)
                     jobs.append(job)
                 return jobs
     def connect_to_network(vm, network, address):
         """Connect a virtual machine to a network.
         @param vm: VirtualMachine object
         @param network: Network object
         nic = {'ip': address, 'network': network.backend_id}
         """
         with pooled_rapi_client(vm) as client:
             return client.ModifyInstance(vm.backend_vm_id, nics=[('add',  nic)],
                                          hotplug=settings.GANETI_USE_HOTPLUG,
                                          dry_run=settings.TEST)
         # ip = network.dhcp and 'pool' or None
         nic = {'ip': address, 'network': network.backend_id}
         vm.client.ModifyInstance(vm.backend_vm_id, nics=[('add',  nic)],
                                  hotplug=settings.GANETI_USE_HOTPLUG,
                                  dry_run=settings.TEST)
     def disconnect_from_network(vm, nic):
         op = [('remove', nic.index, {})]
         with pooled_rapi_client(vm) as client:
             return client.ModifyInstance(vm.backend_vm_id, nics=op,
                                          hotplug=settings.GANETI_USE_HOTPLUG,
                                          dry_run=settings.TEST)
     def set_firewall_profile(vm, profile):
-...
         except KeyError:
             raise ValueError("Unsopported Firewall Profile: %s" % profile)
         client = vm.client
         # Delete all firewall tags
         for t in _firewall_tags.values():
             client.DeleteInstanceTags(vm.backend_vm_id, [t], dry_run=settings.TEST)
         with pooled_rapi_client(vm) as client:
             # Delete all firewall tags
             for t in _firewall_tags.values():
                 client.DeleteInstanceTags(vm.backend_vm_id, [t],
                                           dry_run=settings.TEST)
         client.AddInstanceTags(vm.backend_vm_id, [tag], dry_run=settings.TEST)
             client.AddInstanceTags(vm.backend_vm_id, [tag], dry_run=settings.TEST)
         # XXX NOP ModifyInstance call to force process_net_status to run
         # on the dispatcher
         vm.client.ModifyInstance(vm.backend_vm_id,
                             os_name=settings.GANETI_CREATEINSTANCE_KWARGS['os'])
             # XXX NOP ModifyInstance call to force process_net_status to run
             # on the dispatcher
             client.ModifyInstance(vm.backend_vm_id,
                              os_name=settings.GANETI_CREATEINSTANCE_KWARGS['os'])
     def get_ganeti_instances(backend=None, bulk=False):
         Instances = [c.client.GetInstances(bulk=bulk)\
                      for c in get_backends(backend)]
         return reduce(list.__add__, Instances, [])
         instances = []
         for backend in get_backends(backend):
             with pooled_rapi_client(backend) as client:
                 instances.append(client.GetInstances(bulk=bulk))
         return reduce(list.__add__, instances, [])
     def get_ganeti_nodes(backend=None, bulk=False):
         Nodes = [c.client.GetNodes(bulk=bulk) for c in get_backends(backend)]
         return reduce(list.__add__, Nodes, [])
         nodes = []
         for backend in get_backends(backend):
             with pooled_rapi_client(backend) as client:
                 nodes.append(client.GetNodes(bulk=bulk))
         return reduce(list.__add__, nodes, [])
     def get_ganeti_jobs(backend=None, bulk=False):
         Jobs = [c.client.GetJobs(bulk=bulk) for c in get_backends(backend)]
         return reduce(list.__add__, Jobs, [])
         jobs = []
         for backend in get_backends(backend):
             with pooled_rapi_client(backend) as client:
                 jobs.append(client.GetJobs(bulk=bulk))
         return reduce(list.__add__, jobs, [])
     ##
     ##
-...
         the real memory used, due to kvm's memory de-duplication.
         """
         instances = backend.client.GetInstances(bulk=True)
         with pooled_rapi_client(backend) as client:
             instances = client.GetInstances(bulk=True)
         mem = 0
         for i in instances:
             mem += i['oper_ram']
-...
     def _create_network_synced(network, backend):
         client = backend.client
         backend_jobs = _create_network(network, [backend])
         (_, job) = backend_jobs[0]
         return wait_for_job(client, job)
         with pooled_rapi_client(backend) as client:
             backend_jobs = _create_network(network, [backend])
             (_, job) = backend_jobs[0]
             result = wait_for_job(client, job)
         return result
     def connect_network_synced(network, backend):
-...
             mode = 'routed'
         else:
             mode = 'bridged'
         client = backend.client
         for group in client.GetGroups():
             job = client.ConnectNetwork(network.backend_id, group, mode,
                                         network.link)
             result = wait_for_job(client, job)
             if result[0] != 'success':
                 return result
         with pooled_rapi_client(backend) as client:
             for group in client.GetGroups():
                 job = client.ConnectNetwork(network.backend_id, group, mode,
                                             network.link)
                 result = wait_for_job(client, job)
                 if result[0] != 'success':
                     return result
         return result

Also available in: Unified diff