planetstack/openstack/observer.py

   1 import time
   2 import traceback
   3 import commands
   4 import threading
   5
   6 from datetime import datetime
   7 from collections import defaultdict
   8 from core.models import *
   9 from django.db.models import F, Q
  10 from openstack.manager import OpenStackManager
  11 from util.logger import Logger, logging, logger
  12 #from timeout import timeout
  13
  14
  15 logger = Logger(logfile='observer.log', level=logging.INFO)
  16
  17 class OpenStackObserver:
  18
  19     def __init__(self):
  20         self.manager = OpenStackManager()
  21         # The Condition object that gets signalled by Feefie events
  22         self.event_cond = threading.Condition()
  23
  24     def wait_for_event(self, timeout):
  25         self.event_cond.acquire()
  26         self.event_cond.wait(timeout)
  27         self.event_cond.release()
  28
  29     def wake_up(self):
  30         logger.info('Wake up routine called. Event cond %r'%self.event_cond)
  31         self.event_cond.acquire()
  32         self.event_cond.notify()
  33         self.event_cond.release()
  34
  35     def run(self):
  36         if not self.manager.enabled or not self.manager.has_openstack:
  37             return
  38         while True:
  39             try:
  40                 logger.info('Observer run loop')
  41                 #self.sync_roles()
  42
  43                 logger.info('Calling sync tenants')
  44                 try:
  45                     self.sync_tenants()
  46                 except:
  47                     logger.log_exc("Exception in sync_tenants")
  48                     traceback.print_exc()
  49
  50                 logger.info('Calling sync users')
  51                 try:
  52                     self.sync_users()
  53                 except:
  54                     logger.log_exc("Exception in sync_users")
  55                     traceback.print_exc()
  56
  57                 logger.info('Calling sync tenant roles')
  58                 try:
  59                     self.sync_user_tenant_roles()
  60                 except:
  61                     logger.log_exc("Exception in sync_users")
  62                     traceback.print_exc()
  63
  64                 logger.info('Calling sync slivers')
  65                 try:
  66                     self.sync_slivers()
  67                 except:
  68                     logger.log_exc("Exception in sync slivers")
  69                     traceback.print_exc()
  70
  71                 logger.info('Calling sync sliver ips')
  72                 try:
  73                     self.sync_sliver_ips()
  74                 except:
  75                     logger.log_exc("Exception in sync_sliver_ips")
  76                     traceback.print_exc()
  77
  78                 logger.info('Calling sync networks')
  79                 try:
  80                     self.sync_networks()
  81                 except:
  82                     logger.log_exc("Exception in sync_networks")
  83                     traceback.print_exc()
  84
  85                 logger.info('Calling sync external routes')
  86                 try:
  87                     self.sync_external_routes()
  88                 except:
  89                      logger.log_exc("Exception in sync_external_routes")
  90                      traceback.print_exc()
  91
  92                 logger.info('Waiting for event')
  93                 self.wait_for_event(timeout=300)
  94                 time.sleep(300)
  95                 logger.info('Observer woken up')
  96             except:
  97                 logger.log_exc("Exception in observer run loop")
  98                 traceback.print_exc()
  99
 100     def sync_roles(self):
 101         """
 102         save all role that don't already exist in keystone. Remove keystone roles that
 103         don't exist in planetstack
 104         """
 105         # sync all roles that don't already in keystone
 106         keystone_roles = self.manager.driver.shell.keystone.roles.findall()
 107         keystone_role_names = [kr.name for kr in keystone_roles]
 108         pending_roles = Role.objects.all()
 109         pending_role_names = [r.role_type for r in pending_roles]
 110         for role in pending_roles:
 111             if role.role_type not in keystone_role_names:
 112                 try:
 113                     self.manager.save_role(role)
 114                     logger.info("save role: %s" % (role))
 115                 except:
 116                     logger.log_exc("save role failed: %s" % role)
 117                     traceback.print_exc()
 118
 119         # don't delete roles for now
 120         """
 121         # delete keystone roles that don't exist in planetstack
 122         for keystone_role in keystone_roles:
 123             if keystone_role.name == 'admin':
 124                 continue
 125             if keystone_role.name not in pending_role_names:
 126                 try:
 127                     self.manager.driver.delete_role({id: keystone_role.id})
 128                 except:
 129                     traceback.print_exc()
 130         """
 131
 132     def sync_tenants(self):
 133         """
 134         Save all sites and sliceswhere enacted < updated or enacted == None.
 135         Remove sites and slices that no don't exist in openstack db if they
 136         have an enacted time (enacted != None).
 137         """
 138         # get all sites that need to be synced (enacted < updated or enacted is None)
 139         pending_sites = Site.objects.filter(Q(enacted__lt=F('updated')) | Q(enacted=None))
 140         for site in pending_sites:
 141             try:
 142                 self.manager.save_site(site)
 143                 logger.info("saved site %s" % site)
 144             except:
 145                 logger.log_exc("save site failed: %s" % site)
 146
 147         # get all slices that need to be synced (enacted < updated or enacted is None)
 148         pending_slices = Slice.objects.filter(Q(enacted__lt=F('updated')) | Q(enacted=None))
 149         for slice in pending_slices:
 150             try:
 151                 self.manager.init_caller(slice.creator, slice.creator.site.login_base)
 152                 self.manager.save_slice(slice)
 153                 logger.info("saved slice %s" % slice)
 154             except:
 155                 logger.log_exc("save slice failed: %s" % slice)
 156
 157         # get all sites that where enacted != null. We can assume these sites
 158         # have previously been synced and need to be checed for deletion.
 159         sites = Site.objects.filter(enacted__isnull=False)
 160         site_dict = {}
 161         for site in sites:
 162             site_dict[site.login_base] = site
 163
 164         # get all slices that where enacted != null. We can assume these slices
 165         # have previously been synced and need to be checed for deletion.
 166         slices = Slice.objects.filter(enacted__isnull=False)
 167         slice_dict = {}
 168         for slice in slices:
 169             slice_dict[slice.name] = slice
 170
 171         # delete keystone tenants that don't have a site record
 172         tenants = self.manager.driver.shell.keystone.tenants.findall()
 173         system_tenants = ['admin','service']
 174         for tenant in tenants:
 175             if tenant.name in system_tenants:
 176                 continue
 177             if tenant.name not in site_dict and tenant.name not in slice_dict:
 178                 try:
 179                     self.manager.driver.delete_tenant(tenant.id)
 180                     logger.info("deleted tenant: %s" % (tenant))
 181                 except:
 182                     logger.log_exc("delete tenant failed: %s" % tenant)
 183
 184
 185     def sync_users(self):
 186         """
 187         save all users where enacted < updated or enacted == None. Remove users that
 188         no don't exist in openstack db if they have an enacted time (enacted != None).
 189         """
 190         # get all users that need to be synced (enacted < updated or enacted is None)
 191         pending_users = User.objects.filter(Q(enacted__lt=F('updated')) | Q(enacted=None))
 192         for user in pending_users:
 193             try:
 194                 self.manager.save_user(user)
 195                 logger.info("saved user: %s" % (user))
 196             except:
 197                 logger.log_exc("save user failed: %s" %user)
 198
 199         # get all users that where enacted != null. We can assume these users
 200         # have previously been synced and need to be checed for deletion.
 201         users = User.objects.filter(enacted__isnull=False)
 202         user_dict = {}
 203         for user in users:
 204             user_dict[user.kuser_id] = user
 205
 206         # delete keystone users that don't have a user record
 207         system_users = ['admin', 'nova', 'quantum', 'glance', 'cinder', 'swift', 'service']
 208         users = self.manager.driver.shell.keystone.users.findall()
 209         for user in users:
 210             if user.name in system_users:
 211                 continue
 212             if user.id not in user_dict:
 213                 try:
 214                     #self.manager.driver.delete_user(user.id)
 215                     logger.info("deleted user: %s" % user)
 216                 except:
 217                     logger.log_exc("delete user failed: %s" % user)
 218
 219
 220     def sync_user_tenant_roles(self):
 221         """
 222         Save all site privileges and slice memberships wheree enacted < updated or
 223         enacted == None. Remove ones that don't exist in openstack db if they have
 224         an enacted time (enacted != None).
 225         """
 226         # sync site privileges
 227         pending_site_privileges = SitePrivilege.objects.filter(Q(enacted__lt=F('updated')) | Q(enacted=None))
 228         for site_priv in pending_site_privileges:
 229             try:
 230                 self.manager.save_site_privilege(site_priv)
 231                 logger.info("saved site privilege: %s" % (site_priv))
 232             except: logger.log_exc("save site privilege failed: %s " % site_priv)
 233
 234         # sync slice memberships
 235         pending_slice_memberships = SliceMembership.objects.filter(Q(enacted__lt=F('updated')) | Q(enacted=None))
 236         for slice_memb in pending_slice_memberships:
 237             try:
 238                 self.manager.save_slice_membership(slice_memb)
 239                 logger.info("saved slice membership: %s" % (slice_memb))
 240             except: logger.log_exc("save slice membership failed: %s" % slice_memb)
 241
 242         # get all site privileges and slice memberships that have been enacted
 243         user_tenant_roles = defaultdict(list)
 244         for site_priv in SitePrivilege.objects.filter(enacted__isnull=False):
 245             user_tenant_roles[(site_priv.user.kuser_id, site_priv.site.tenant_id)].append(site_priv.role.role)
 246         for slice_memb in SliceMembership.objects.filter(enacted__isnull=False):
 247             user_tenant_roles[(slice_memb.user.kuser_id, slice_memb.slice.tenant_id)].append(slice_memb.role.role)
 248
 249         # Some user tenant role aren't stored in planetstack but they must be preserved.
 250         # Role that fall in this category are
 251         # 1. Never remove a user's role that their home site
 252         # 2. Never remove a user's role at a slice they've created.
 253         # Keep track of all roles that must be preserved.
 254         users = User.objects.all()
 255         preserved_roles = {}
 256         for user in users:
 257             tenant_ids = [s['tenant_id'] for s in user.slices.values()]
 258             tenant_ids.append(user.site.tenant_id)
 259             preserved_roles[user.kuser_id] = tenant_ids
 260
 261
 262         # begin removing user tenant roles from keystone. This is stored in the
 263         # Metadata table.
 264         for metadata in self.manager.driver.shell.keystone_db.get_metadata():
 265             # skip admin roles
 266             if metadata.user_id == self.manager.driver.admin_user.id:
 267                 continue
 268             # skip preserved tenant ids
 269             if metadata.user_id in preserved_roles and \
 270                metadata.tenant_id in preserved_roles[metadata.user_id]:
 271                 continue
 272             # get roles for user at this tenant
 273             user_tenant_role_ids = user_tenant_roles.get((metadata.user_id, metadata.tenant_id), [])
 274
 275             if user_tenant_role_ids:
 276                 # The user has roles at the tenant. Check if roles need to
 277                 # be updated.
 278                 user_keystone_role_ids = metadata.data.get('roles', [])
 279                 for role_id in user_keystone_role_ids:
 280                     if role_id not in user_tenant_role_ids:
 281                         user_keystone_role_ids.pop(user_keystone_role_ids.index(role_id))
 282             else:
 283                 # The user has no roles at this tenant.
 284                 metadata.data['roles'] = []
 285             #session.add(metadata)
 286             logger.info("pruning metadata for %s at %s" % (metadata.user_id, metadata.tenant_id))
 287
 288     def sync_slivers(self):
 289         """
 290         save all slivers where enacted < updated or enacted == None. Remove slivers that
 291         no don't exist in openstack db if they have an enacted time (enacted != None).
 292         """
 293         # get all users that need to be synced (enacted < updated or enacted is None)
 294         pending_slivers = Sliver.objects.filter(Q(enacted__lt=F('updated')) | Q(enacted=None))
 295         for sliver in pending_slivers:
 296             if sliver.creator:
 297                 try:
 298                     # update manager context
 299                     self.manager.init_caller(sliver.creator, sliver.slice.name)
 300                     self.manager.save_sliver(sliver)
 301                     logger.info("saved sliver: %s" % (sliver))
 302                 except:
 303                     logger.log_exc("save sliver failed: %s" % sliver)
 304
 305         # get all slivers where enacted != null. We can assume these users
 306         # have previously been synced and need to be checed for deletion.
 307         slivers = Sliver.objects.filter(enacted__isnull=False)
 308         sliver_dict = {}
 309         for sliver in slivers:
 310             sliver_dict[sliver.instance_id] = sliver
 311
 312         # delete sliver that don't have a sliver record
 313         ctx = self.manager.driver.shell.nova_db.ctx
 314         instances = self.manager.driver.shell.nova_db.instance_get_all(ctx)
 315         for instance in instances:
 316             if instance.uuid not in sliver_dict:
 317                 try:
 318                     # lookup tenant and update context
 319                     tenant = self.manager.driver.shell.keystone.tenants.find(id=instance.project_id)
 320                     self.manager.init_admin(tenant=tenant.name)
 321                     self.manager.driver.destroy_instance(instance.uuid)
 322                     logger.info("destroyed sliver: %s" % (instance))
 323                 except:
 324                     logger.log_exc("destroy sliver failed: %s" % instance)
 325
 326
 327     def sync_sliver_ips(self):
 328         # fill in null ip addresses
 329         slivers = Sliver.objects.filter(ip=None)
 330         for sliver in slivers:
 331             # update connection
 332             self.manager.init_admin(tenant=sliver.slice.name)
 333             servers = self.manager.driver.shell.nova.servers.findall(id=sliver.instance_id)
 334             if not servers:
 335                 continue
 336             server = servers[0]
 337             ips = server.addresses.get(sliver.slice.name, [])
 338             if not ips:
 339                 continue
 340             sliver.ip = ips[0]['addr']
 341             sliver.save()
 342             logger.info("saved sliver ip: %s %s" % (sliver, ips[0]))
 343
 344     def sync_external_routes(self):
 345         routes = self.manager.driver.get_external_routes()
 346         subnets = self.manager.driver.shell.quantum.list_subnets()['subnets']
 347         for subnet in subnets:
 348             try:
 349                 self.manager.driver.add_external_route(subnet, routes)
 350             except:
 351                 logger.log_exc("failed to add external route for subnet %s" % subnet)
 352
 353     def sync_networks(self):
 354         """
 355         save all networks where enacted < updated or enacted == None. Remove networks that
 356         no don't exist in openstack db if they have an enacted time (enacted != None).
 357         """
 358         # get all users that need to be synced (enacted < updated or enacted is None)
 359         pending_networks = Network.objects.filter(Q(enacted__lt=F('updated')) | Q(enacted=None))
 360         for network in pending_networks:
 361             if network.owner and network.owner.creator:
 362                 try:
 363                     # update manager context
 364                     self.manager.init_caller(network.owner.creator, network.owner.name)
 365                     self.manager.save_network(network)
 366                     logger.info("saved network: %s" % (network))
 367                 except:
 368                     logger.log_exc("save network failed: %s" % network)
 369
 370         # get all networks where enacted != null. We can assume these users
 371         # have previously been synced and need to be checed for deletion.
 372         networks = Network.objects.filter(enacted__isnull=False)
 373         network_dict = {}
 374         for network in networks:
 375             network_dict[network.network_id] = network
 376
 377         # TODO: delete Network objects if quantum network doesn't exist
 378         #       (need to write self.manager.driver.shell.quantum_db)
 379