plstackapi/openstack/manager.py

   1 from plstackapi.planetstack import settings
   2 from django.core import management
   3 management.setup_environ(settings)
   4 from plstackapi.openstack.client import OpenStackClient
   5 from plstackapi.openstack.driver import OpenStackDriver
   6 from plstackapi.planetstack.config import Config
   7 from plstackapi.core.models import *
   8
   9 def require_enabled(callable):
  10     enabled = Config().api_nova_enabled
  11     def wrapper(*args, **kwds):
  12         if enabled:
  13             return callable(*args, **kwds)
  14         else:
  15             return None
  16     return wrapper
  17
  18
  19 class OpenStackManager:
  20
  21     def __init__(self, auth={}, caller=None):
  22         self.client = None
  23         if auth:
  24             self.client = OpenStackClient(**auth)
  25
  26         self.driver = OpenStackDriver(client=self.client)
  27         self.caller=None
  28
  29     @require_enabled
  30     def save_role(self, role):
  31         if not role.role_id:
  32             keystone_role = self.driver.create_role(role.role_type)
  33             role.role_id = keystone_role.id
  34
  35     @require_enabled
  36     def delete_role(self, role):
  37         if role.role_id:
  38             self.driver.delete_role({'id': role.role_id})
  39
  40     def refresh_nodes(self):
  41         # collect local nodes
  42         nodes = Node.objects.all()
  43         nodes_dict = {}
  44         for node in nodes:
  45             if 'viccidev10' not in node.name:
  46                 nodes_dict[node.name] = node
  47
  48         deployment = DeploymentNetwork.objects.filter(name='VICCI')[0]
  49         login_bases = ['princeton', 'stanford', 'gt', 'uw', 'mpisws']
  50         sites = Site.objects.filter(login_base__in=login_bases)
  51         # collect nova nodes:
  52         compute_nodes = self.client.nova.hypervisors.list()
  53
  54         compute_nodes_dict = {}
  55         for compute_node in compute_nodes:
  56             compute_nodes_dict[compute_node.hypervisor_hostname] = compute_node
  57
  58         # add new nodes:
  59         new_node_names = set(compute_nodes_dict.keys()).difference(nodes_dict.keys())
  60         i = 0
  61         max = len(sites)
  62         for name in new_node_names:
  63             if i == max:
  64                 i = 0
  65             site = sites[i]
  66             node = Node(name=compute_nodes_dict[name].hypervisor_hostname,
  67                         site=site,
  68                         deploymentNetwork=deployment)
  69             node.save()
  70             i+=1
  71
  72         # remove old nodes
  73         old_node_names = set(nodes_dict.keys()).difference(compute_nodes_dict.keys())
  74         Node.objects.filter(name__in=old_node_names).delete()
  75
  76     def refresh_images(self):
  77         # collect local images
  78         images = Image.objects.all()
  79         images_dict = {}
  80         for image in images:
  81             images_dict[image.name] = image
  82
  83         # collect glance images
  84         glance_images = self.client.glance.get_images()
  85         glance_images_dict = {}
  86         for glance_image in glance_images:
  87             glance_images_dict[glance_image['name']] = glance_image
  88
  89         # add new images
  90         new_image_names = set(glance_images_dict.keys()).difference(images_dict.keys())
  91         for name in new_image_names:
  92             image = Image(image_id=glance_images_dict[name]['id'],
  93                           name=glance_images_dict[name]['name'],
  94                           disk_format=glance_images_dict[name]['disk_format'],
  95                           container_format=glance_images_dict[name]['container_format'])
  96             image.save()
  97
  98         # remove old images
  99         old_image_names = set(images_dict.keys()).difference(glance_images_dict.keys())
 100         Image.objects.filter(name__in=old_image_names).delete()
 101
 102