planetstack/openstack/manager.py

   1 import os
   2 #os.environ.setdefault("DJANGO_SETTINGS_MODULE", "planetstack.settings")
   3 import string
   4 import random
   5 import hashlib
   6 from datetime import datetime
   7
   8 from netaddr import IPAddress, IPNetwork
   9 from planetstack import settings
  10 from django.core import management
  11 from core.models import *
  12 from planetstack.config import Config
  13 try:
  14     from openstack.client import OpenStackClient
  15     from openstack.driver import OpenStackDriver
  16     has_openstack = True
  17 except:
  18     has_openstack = False
  19
  20 manager_enabled = Config().api_nova_enabled
  21
  22
  23 def random_string(size=6):
  24     return ''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(size))
  25
  26 def require_enabled(callable):
  27     def wrapper(*args, **kwds):
  28         if manager_enabled and has_openstack:
  29             return callable(*args, **kwds)
  30         else:
  31             return None
  32     return wrapper
  33
  34
  35 class OpenStackManager:
  36
  37     def __init__(self, auth={}, caller=None):
  38         self.client = None
  39         self.driver = None
  40         self.caller = None
  41         self.has_openstack = has_openstack
  42         self.enabled = manager_enabled
  43
  44         if has_openstack and manager_enabled:
  45             if auth:
  46                 try:
  47                     self.init_user(auth, caller)
  48                 except:
  49                     # if this fails then it meanse the caller doesn't have a
  50                     # role at the slice's tenant. if the caller is an admin
  51                     # just use the admin client/manager.
  52                     if caller and caller.is_admin:
  53                         self.init_admin()
  54                     else: raise
  55             else:
  56                 self.init_admin()
  57
  58     @require_enabled
  59     def init_caller(self, caller, tenant):
  60         auth = {'username': caller.email,
  61                 'password': hashlib.md5(caller.password).hexdigest()[:6],
  62                 'tenant': tenant}
  63         self.client = OpenStackClient(**auth)
  64         self.driver = OpenStackDriver(client=self.client)
  65         self.caller = caller
  66
  67     @require_enabled
  68     def init_admin(self, tenant=None):
  69         # use the admin credentials
  70         self.client = OpenStackClient(tenant=tenant)
  71         self.driver = OpenStackDriver(client=self.client)
  72         self.caller = self.driver.admin_user
  73         self.caller.kuser_id = self.caller.id
  74
  75     @require_enabled
  76     def save_role(self, role):
  77         if not role.role:
  78             keystone_role = self.driver.create_role(role.role_type)
  79             role.role = keystone_role.id
  80
  81     @require_enabled
  82     def delete_role(self, role):
  83         if role.role:
  84             self.driver.delete_role({'id': role.role})
  85
  86     @require_enabled
  87     def save_key(self, key, name):
  88         key_fields = {'name': name,
  89                       'public_key': key}
  90         nova_key = self.driver.create_keypair(**key_fields)
  91
  92     @require_enabled
  93     def delete_key(self, key):
  94         if key.nkey_id:
  95             self.driver.delete_keypair(key.nkey_id)
  96
  97     @require_enabled
  98     def save_user(self, user):
  99         name = user.email[:user.email.find('@')]
 100         user_fields = {'name': name,
 101                        'email': user.email,
 102                        'password': hashlib.md5(user.password).hexdigest()[:6],
 103                        'enabled': True}
 104         if not user.kuser_id:
 105             keystone_user = self.driver.create_user(**user_fields)
 106             user.kuser_id = keystone_user.id
 107         else:
 108             self.driver.update_user(user.kuser_id, user_fields)
 109
 110         if user.site:
 111             self.driver.add_user_role(user.kuser_id, user.site.tenant_id, 'user')
 112             if user.is_admin:
 113                 self.driver.add_user_role(user.kuser_id, user.site.tenant_id, 'admin')
 114             else:
 115                 # may have admin role so attempt to remove it
 116                 self.driver.delete_user_role(user.kuser_id, user.site.tenant_id, 'admin')
 117
 118         if user.public_key:
 119             self.init_caller(user, user.site.login_base)
 120             self.save_key(user.public_key, user.keyname)
 121             self.init_admin()
 122
 123         user.save()
 124         user.enacted = datetime.now()
 125         user.save(update_fields=['enacted'])
 126
 127     @require_enabled
 128     def delete_user(self, user):
 129         if user.kuser_id:
 130             self.driver.delete_user(user.kuser_id)
 131
 132     @require_enabled
 133     def save_site(self, site, add_role=True):
 134         if not site.tenant_id:
 135             tenant = self.driver.create_tenant(tenant_name=site.login_base,
 136                                                description=site.name,
 137                                                enabled=site.enabled)
 138             site.tenant_id = tenant.id
 139             # give caller an admin role at the tenant they've created
 140             self.driver.add_user_role(self.caller.kuser_id, tenant.id, 'admin')
 141
 142         # update the record
 143         if site.id and site.tenant_id:
 144             self.driver.update_tenant(site.tenant_id,
 145                                       description=site.name,
 146                                       enabled=site.enabled)
 147
 148         # commit the updated record
 149         site.save()
 150         site.enacted = datetime.now()
 151         site.save(update_fields=['enacted']) # enusre enacted > updated
 152
 153
 154     @require_enabled
 155     def delete_site(self, site):
 156         if site.tenant_id:
 157             self.driver.delete_tenant(site.tenant_id)
 158
 159     @require_enabled
 160     def save_site_privilege(self, site_priv):
 161         if site_priv.user.kuser_id and site_priv.site.tenant_id:
 162             self.driver.add_user_role(site_priv.user.kuser_id,
 163                                       site_priv.site.tenant_id,
 164                                       site_priv.role.role_type)
 165         site_priv.enacted = datetime.now()
 166         site_priv.save(update_fields=['enacted'])
 167
 168
 169     @require_enabled
 170     def delete_site_privilege(self, site_priv):
 171         self.driver.delete_user_role(site_priv.user.kuser_id,
 172                                      site_priv.site.tenant_id,
 173                                      site_priv.role.role_type)
 174
 175     @require_enabled
 176     def save_slice(self, slice):
 177         if not slice.tenant_id:
 178             nova_fields = {'tenant_name': slice.name,
 179                    'description': slice.description,
 180                    'enabled': slice.enabled}
 181             tenant = self.driver.create_tenant(**nova_fields)
 182             slice.tenant_id = tenant.id
 183
 184             # give caller an admin role at the tenant they've created
 185             self.driver.add_user_role(self.caller.kuser_id, tenant.id, 'admin')
 186
 187             # refresh credentials using this tenant
 188             self.driver.shell.connect(username=self.driver.shell.keystone.username,
 189                                       password=self.driver.shell.keystone.password,
 190                                       tenant=tenant.name)
 191
 192             # create network
 193             network = self.driver.create_network(slice.name)
 194             slice.network_id = network['id']
 195
 196             # create router
 197             router = self.driver.create_router(slice.name)
 198             slice.router_id = router['id']
 199
 200             # create subnet
 201             next_subnet = self.get_next_subnet()
 202             cidr = str(next_subnet.cidr)
 203             ip_version = next_subnet.version
 204             start = str(next_subnet[2])
 205             end = str(next_subnet[-2])
 206             subnet = self.driver.create_subnet(name=slice.name,
 207                                                network_id = network['id'],
 208                                                cidr_ip = cidr,
 209                                                ip_version = ip_version,
 210                                                start = start,
 211                                                end = end)
 212             slice.subnet_id = subnet['id']
 213             # add subnet as interface to slice's router
 214             self.driver.add_router_interface(router['id'], subnet['id'])
 215             # add external route
 216             self.driver.add_external_route(subnet)
 217
 218
 219         if slice.id and slice.tenant_id:
 220             self.driver.update_tenant(slice.tenant_id,
 221                                       description=slice.description,
 222                                       enabled=slice.enabled)
 223
 224         slice.save()
 225         slice.enacted = datetime.now()
 226         slice.save(update_fields=['enacted'])
 227
 228     @require_enabled
 229     def delete_slice(self, slice):
 230         if slice.tenant_id:
 231             self._delete_slice(slice.tenant_id, slice.network_id,
 232                                slice.router_id, slice.subnet_id)
 233     @require_enabled
 234     def _delete_slice(self, tenant_id, network_id, router_id, subnet_id):
 235         self.driver.delete_router_interface(slice.router_id, slice.subnet_id)
 236         self.driver.delete_subnet(slice.subnet_id)
 237         self.driver.delete_router(slice.router_id)
 238         self.driver.delete_network(slice.network_id)
 239         self.driver.delete_tenant(slice.tenant_id)
 240         # delete external route
 241         subnet = None
 242         subnets = self.driver.shell.quantum.list_subnets()['subnets']
 243         for snet in subnets:
 244             if snet['id'] == slice.subnet_id:
 245                 subnet = snet
 246         if subnet:
 247             self.driver.delete_external_route(subnet)
 248
 249
 250     @require_enabled
 251     def save_slice_membership(self, slice_memb):
 252         if slice_memb.user.kuser_id and slice_memb.slice.tenant_id:
 253             self.driver.add_user_role(slice_memb.user.kuser_id,
 254                                       slice_memb.slice.tenant_id,
 255                                       slice_memb.role.role_type)
 256         slice_memb.enacted = datetime.now()
 257         slice_memb.save(update_fields=['enacted'])
 258
 259
 260     @require_enabled
 261     def delete_slice_membership(self, slice_memb):
 262         self.driver.delete_user_role(slice_memb.user.kuser_id,
 263                                      slice_memb.slice.tenant_id,
 264                                      slice_memb.role.role_type)
 265
 266
 267     @require_enabled
 268     def get_next_subnet(self):
 269         # limit ourself to 10.0.x.x for now
 270         valid_subnet = lambda net: net.startswith('10.0')
 271         subnets = self.driver.shell.quantum.list_subnets()['subnets']
 272         ints = [int(IPNetwork(subnet['cidr']).ip) for subnet in subnets \
 273                 if valid_subnet(subnet['cidr'])]
 274         ints.sort()
 275         last_ip = IPAddress(ints[-1])
 276         last_network = IPNetwork(str(last_ip) + "/24")
 277         next_network = IPNetwork(str(IPAddress(last_network) + last_network.size) + "/24")
 278         return next_network
 279
 280     @require_enabled
 281     def save_subnet(self, subnet):
 282         if not subnet.subnet_id:
 283             quantum_subnet = self.driver.create_subnet(name= subnet.slice.name,
 284                                           network_id=subnet.slice.network_id,
 285                                           cidr_ip = subnet.cidr,
 286                                           ip_version=subnet.ip_version,
 287                                           start = subnet.start,
 288                                           end = subnet.end)
 289             subnet.subnet_id = quantum_subnet['id']
 290             # add subnet as interface to slice's router
 291             self.driver.add_router_interface(subnet.slice.router_id, subnet.subnet_id)
 292             #add_route = 'route add -net %s dev br-ex gw 10.100.0.5' % self.cidr
 293             #commands.getstatusoutput(add_route)
 294
 295
 296     @require_enabled
 297     def delete_subnet(self, subnet):
 298         if subnet.subnet_id:
 299             self.driver.delete_router_interface(subnet.slice.router_id, subnet.subnet_id)
 300             self.driver.delete_subnet(subnet.subnet_id)
 301             #del_route = 'route del -net %s' % self.cidr
 302             #commands.getstatusoutput(del_route)
 303
 304     @require_enabled
 305     def save_sliver(self, sliver):
 306         if not sliver.instance_id:
 307             slice_memberships = SliceMembership.objects.filter(slice=sliver.slice)
 308             pubkeys = [sm.user.public_key for sm in slice_memberships if sm.user.public_key != None]
 309             pubkeys.append(sliver.creator.public_key)
 310             instance = self.driver.spawn_instance(name=sliver.name,
 311                                    key_name = sliver.creator.keyname,
 312                                    image_id = sliver.image.image_id,
 313                                    hostname = sliver.node.name,
 314                                    pubkeys = pubkeys )
 315             sliver.instance_id = instance.id
 316             sliver.instance_name = getattr(instance, 'OS-EXT-SRV-ATTR:instance_name')
 317
 318         if sliver.instance_id and ("numberCores" in sliver.changed_fields):
 319             self.driver.update_instance_metadata(sliver.instance_id, {"cpu_cores": str(sliver.numberCores)})
 320
 321         sliver.save()
 322         sliver.enacted = datetime.now()
 323         sliver.save(update_fields=['enacted'])
 324
 325     @require_enabled
 326     def delete_sliver(self, sliver):
 327         if sliver.instance_id:
 328             self.driver.destroy_instance(sliver.instance_id)
 329
 330
 331     def refresh_nodes(self):
 332         # collect local nodes
 333         nodes = Node.objects.all()
 334         nodes_dict = {}
 335         for node in nodes:
 336             if 'viccidev10' not in node.name:
 337                 nodes_dict[node.name] = node
 338
 339         deployment = Deployment.objects.filter(name='VICCI')[0]
 340         login_bases = ['princeton', 'stanford', 'gt', 'uw', 'mpisws']
 341         sites = Site.objects.filter(login_base__in=login_bases)
 342         # collect nova nodes:
 343         compute_nodes = self.client.nova.hypervisors.list()
 344
 345         compute_nodes_dict = {}
 346         for compute_node in compute_nodes:
 347             compute_nodes_dict[compute_node.hypervisor_hostname] = compute_node
 348
 349         # add new nodes:
 350         new_node_names = set(compute_nodes_dict.keys()).difference(nodes_dict.keys())
 351         i = 0
 352         max = len(sites)
 353         for name in new_node_names:
 354             if i == max:
 355                 i = 0
 356             site = sites[i]
 357             node = Node(name=compute_nodes_dict[name].hypervisor_hostname,
 358                         site=site,
 359                         deployment=deployment)
 360             node.save()
 361             i+=1
 362
 363         # remove old nodes
 364         old_node_names = set(nodes_dict.keys()).difference(compute_nodes_dict.keys())
 365         Node.objects.filter(name__in=old_node_names).delete()
 366
 367     def refresh_images(self):
 368         from core.models.image import Image
 369         # collect local images
 370         images = Image.objects.all()
 371         images_dict = {}
 372         for image in images:
 373             images_dict[image.name] = image
 374
 375         # collect glance images
 376         glance_images = self.client.glance.get_images()
 377         glance_images_dict = {}
 378         for glance_image in glance_images:
 379             glance_images_dict[glance_image['name']] = glance_image
 380
 381         # add new images
 382         new_image_names = set(glance_images_dict.keys()).difference(images_dict.keys())
 383         for name in new_image_names:
 384             image = Image(image_id=glance_images_dict[name]['id'],
 385                           name=glance_images_dict[name]['name'],
 386                           disk_format=glance_images_dict[name]['disk_format'],
 387                           container_format=glance_images_dict[name]['container_format'])
 388             image.save()
 389
 390         # remove old images
 391         old_image_names = set(images_dict.keys()).difference(glance_images_dict.keys())
 392         Image.objects.filter(name__in=old_image_names).delete()
 393
 394