planetstack/openstack/manager.py

   1 from planetstack import settings
   2 #from django.core import management
   3 #management.setup_environ(settings)
   4 import os
   5 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "planetstack.settings")
   6
   7 try:
   8     from openstack.client import OpenStackClient
   9     from openstack.driver import OpenStackDriver
  10     from planetstack.config import Config
  11     from core.models import *
  12     has_openstack = True
  13 except:
  14     has_openstack = False
  15
  16 #manager_enabled = Config().api_nova_enabled
  17 manager_enabled = False
  18
  19 def require_enabled(callable):
  20     def wrapper(*args, **kwds):
  21         if manager_enabled and has_openstack:
  22             return callable(*args, **kwds)
  23         else:
  24             return None
  25     return wrapper
  26
  27
  28 class OpenStackManager:
  29
  30     def __init__(self, auth={}, caller=None):
  31         if auth:
  32             self.client = OpenStackClient(**auth)
  33         else:
  34             self.client = OpenStackClient()
  35         self.has_openstack = has_openstack
  36         self.enabled = manager_enabled
  37         self.driver = OpenStackDriver(client=self.client)
  38         self.caller=caller
  39         if not self.caller:
  40             self.caller = self.driver.admin_user
  41             self.caller.kuser_id = self.caller.id
  42
  43     @require_enabled
  44     def save_role(self, role):
  45         if not role.role_id:
  46             keystone_role = self.driver.create_role(role.role_type)
  47             role.role_id = keystone_role.id
  48
  49     @require_enabled
  50     def delete_role(self, role):
  51         if role.role_id:
  52             self.driver.delete_role({'id': role.role_id})
  53
  54     @require_enabled
  55     def save_key(self, key):
  56         if not key.key_id:
  57             key_fields = {'name': key.name,
  58                           'key': key.key}
  59             nova_key = self.driver.create_keypair(**key_fields)
  60             key.key_id = nova_key.id
  61
  62     @require_enabled
  63     def delete_key(self, key):
  64         if key.key_id:
  65             self.driver.delete_keypair(key.key_id)
  66
  67     @require_enabled
  68     def save_user(self, user):
  69         if not user.kuser_id:
  70             name = user.email[:user.email.find('@')]
  71             user_fields = {'name': name,
  72                            'email': user.email,
  73                            'password': user.password,
  74                            'enabled': True}
  75             keystone_user = self.driver.create_user(**user_fields)
  76             user.kuser_id = keystone_user.id
  77
  78     @require_enabled
  79     def delete_user(self, user):
  80         if user.kuser_id:
  81             self.driver.delete_user(user.kuser_id)
  82
  83
  84
  85     @require_enabled
  86     def save_site(self, site, add_role=True):
  87         if not site.tenant_id:
  88             tenant = self.driver.create_tenant(tenant_name=site.login_base,
  89                                                description=site.name,
  90                                                enabled=site.enabled)
  91             site.tenant_id = tenant.id
  92             # give caller an admin role at the tenant they've created
  93             self.driver.add_user_role(self.caller.kuser_id, tenant.id, 'admin')
  94
  95         # update the record
  96         if site.id and site.tenant_id:
  97             self.driver.update_tenant(site.tenant_id,
  98                                       description=site.name,
  99                                       enabled=site.enabled)
 100
 101     @require_enabled
 102     def delete_site(self, site):
 103         if site.tenant_id:
 104             self.driver.delete_tenant(site.tenant_id)
 105
 106     @require_enabled
 107     def save_slice(self, slice):
 108         if not slice.tenant_id:
 109             nova_fields = {'tenant_name': slice.name,
 110                    'description': slice.description,
 111                    'enabled': slice.enabled}
 112             tenant = self.driver.create_tenant(**nova_fields)
 113             slice.tenant_id = tenant.id
 114
 115             # give caller an admin role at the tenant they've created
 116             self.driver.add_user_role(self.caller.kuser_id, tenant.id, 'admin')
 117
 118             # refresh credentials using this tenant
 119             self.driver.shell.connect(username=self.driver.shell.keystone.username,
 120                                       password=self.driver.shell.keystone.password,
 121                                       tenant=tenant.name)
 122
 123             # create network
 124             network = self.driver.create_network(slice.name)
 125             slice.network_id = network['id']
 126
 127             # create router
 128             router = self.driver.create_router(slice.name)
 129             slice.router_id = router['id']
 130
 131         if slice.id and slice.tenant_id:
 132             self.driver.update_tenant(slice.tenant_id,
 133                                       description=slice.description,
 134                                       enabled=slice.enabled)
 135
 136     @require_enabled
 137     def delete_slice(self, slice):
 138         if slice.tenant_id:
 139             self.driver.delete_router(slice.router_id)
 140             self.driver.delete_network(slice.network_id)
 141             self.driver.delete_tenant(slice.tenant_id)
 142
 143     @require_enabled
 144     def save_subnet(self, subnet):
 145         if not subnet.subnet_id:
 146             quantum_subnet = self.driver.create_subnet(name= subnet.slice.name,
 147                                           network_id=subnet.slice.network_id,
 148                                           cidr_ip = subnet.cidr,
 149                                           ip_version=subnet.ip_version,
 150                                           start = subnet.start,
 151                                           end = subnet.end)
 152             subnet.subnet_id = quantum_subnet['id']
 153             # add subnet as interface to slice's router
 154             self.driver.add_router_interface(subnet.slice.router_id, subnet.subnet_id)
 155             #add_route = 'route add -net %s dev br-ex gw 10.100.0.5' % self.cidr
 156             #commands.getstatusoutput(add_route)
 157
 158
 159     @require_enabled
 160     def delete_subnet(self, subnet):
 161         if subnet.subnet_id:
 162             self.driver.delete_router_interface(subnet.slice.router_id, subnet.subnet_id)
 163             self.driver.delete_subnet(subnet.subnet_id)
 164             #del_route = 'route del -net %s' % self.cidr
 165             #commands.getstatusoutput(del_route)
 166
 167     @require_enabled
 168     def save_sliver(self, sliver):
 169         if not sliver.instance_id:
 170             instance = self.driver.spawn_instance(name=sliver.name,
 171                                    key_name = sliver.key.name,
 172                                    image_id = sliver.image.image_id,
 173                                    hostname = sliver.node.name )
 174             sliver.instance_id = instance.id
 175             sliver.instance_name = getattr(instance, 'OS-EXT-SRV-ATTR:instance_name')
 176
 177     @require_enabled
 178     def delete_sliver(self, sliver):
 179         if sliver.instance_id:
 180             self.driver.destroy_instance(sliver.instance_id)
 181
 182
 183     def refresh_nodes(self):
 184         # collect local nodes
 185         nodes = Node.objects.all()
 186         nodes_dict = {}
 187         for node in nodes:
 188             if 'viccidev10' not in node.name:
 189                 nodes_dict[node.name] = node
 190
 191         deployment = DeploymentNetwork.objects.filter(name='VICCI')[0]
 192         login_bases = ['princeton', 'stanford', 'gt', 'uw', 'mpisws']
 193         sites = Site.objects.filter(login_base__in=login_bases)
 194         # collect nova nodes:
 195         compute_nodes = self.client.nova.hypervisors.list()
 196
 197         compute_nodes_dict = {}
 198         for compute_node in compute_nodes:
 199             compute_nodes_dict[compute_node.hypervisor_hostname] = compute_node
 200
 201         # add new nodes:
 202         new_node_names = set(compute_nodes_dict.keys()).difference(nodes_dict.keys())
 203         i = 0
 204         max = len(sites)
 205         for name in new_node_names:
 206             if i == max:
 207                 i = 0
 208             site = sites[i]
 209             node = Node(name=compute_nodes_dict[name].hypervisor_hostname,
 210                         site=site,
 211                         deploymentNetwork=deployment)
 212             node.save()
 213             i+=1
 214
 215         # remove old nodes
 216         old_node_names = set(nodes_dict.keys()).difference(compute_nodes_dict.keys())
 217         Node.objects.filter(name__in=old_node_names).delete()
 218
 219     def refresh_images(self):
 220         # collect local images
 221         images = Image.objects.all()
 222         images_dict = {}
 223         for image in images:
 224             images_dict[image.name] = image
 225
 226         # collect glance images
 227         glance_images = self.client.glance.get_images()
 228         glance_images_dict = {}
 229         for glance_image in glance_images:
 230             glance_images_dict[glance_image['name']] = glance_image
 231
 232         # add new images
 233         new_image_names = set(glance_images_dict.keys()).difference(images_dict.keys())
 234         for name in new_image_names:
 235             image = Image(image_id=glance_images_dict[name]['id'],
 236                           name=glance_images_dict[name]['name'],
 237                           disk_format=glance_images_dict[name]['disk_format'],
 238                           container_format=glance_images_dict[name]['container_format'])
 239             image.save()
 240
 241         # remove old images
 242         old_image_names = set(images_dict.keys()).difference(glance_images_dict.keys())
 243         Image.objects.filter(name__in=old_image_names).delete()
 244
 245