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
15 logger = Logger(logfile='observer.log', level=logging.INFO)
17 class OpenStackObserver:
20 self.manager = OpenStackManager()
21 # The Condition object that gets signalled by Feefie events
22 self.event_cond = threading.Condition()
24 def wait_for_event(self, timeout):
25 self.event_cond.acquire()
26 self.event_cond.wait(timeout)
27 self.event_cond.release()
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()
36 if not self.manager.enabled or not self.manager.has_openstack:
40 logger.info('Observer run loop')
42 logger.info('Calling sync tenants')
45 self.sync_user_tenant_roles()
47 self.sync_sliver_ips()
48 logger.info('Calling sync external routes')
49 self.sync_external_routes()
50 self.wait_for_event(timeout=300)
51 logger.info('Observer woken up')
57 save all role that don't already exist in keystone. Remove keystone roles that
58 don't exist in planetstack
60 # sync all roles that don't already in keystone
61 keystone_roles = self.manager.driver.shell.keystone.roles.findall()
62 keystone_role_names = [kr.name for kr in keystone_roles]
63 pending_roles = Role.objects.all()
64 pending_role_names = [r.role_type for r in pending_roles]
65 for role in pending_roles:
66 if role.role_type not in keystone_role_names:
68 self.manager.save_role(role)
69 logger.info("save role: %s" % (role))
71 logger.log_exc("save role failed: %s" % role)
74 # don't delete roles for now
76 # delete keystone roles that don't exist in planetstack
77 for keystone_role in keystone_roles:
78 if keystone_role.name == 'admin':
80 if keystone_role.name not in pending_role_names:
82 self.manager.driver.delete_role({id: keystone_role.id})
87 def sync_tenants(self):
89 Save all sites and sliceswhere enacted < updated or enacted == None.
90 Remove sites and slices that no don't exist in openstack db if they
91 have an enacted time (enacted != None).
93 # get all sites that need to be synced (enacted < updated or enacted is None)
94 pending_sites = Site.objects.filter(Q(enacted__lt=F('updated')) | Q(enacted=None))
95 for site in pending_sites:
97 self.manager.save_site(site)
98 logger.info("saved site %s" % site)
100 logger.log_exc("save site failed: %s" % site)
102 # get all slices that need to be synced (enacted < updated or enacted is None)
103 pending_slices = Slice.objects.filter(Q(enacted__lt=F('updated')) | Q(enacted=None))
104 for slice in pending_slices:
106 self.manager.init_caller(slice.creator, slice.creator.site.login_base)
107 self.manager.save_slice(slice)
108 logger.info("saved slice %s" % slice)
110 logger.log_exc("save slice failed: %s" % slice)
112 # get all sites that where enacted != null. We can assume these sites
113 # have previously been synced and need to be checed for deletion.
114 sites = Site.objects.filter(enacted__isnull=False)
117 site_dict[site.login_base] = site
119 # get all slices that where enacted != null. We can assume these slices
120 # have previously been synced and need to be checed for deletion.
121 slices = Slice.objects.filter(enacted__isnull=False)
124 slice_dict[slice.name] = slice
126 # delete keystone tenants that don't have a site record
127 tenants = self.manager.driver.shell.keystone.tenants.findall()
128 system_tenants = ['admin','service']
129 for tenant in tenants:
130 if tenant.name in system_tenants:
132 if tenant.name not in site_dict and tenant.name not in slice_dict:
134 self.manager.driver.delete_tenant(tenant.id)
135 logger.info("deleted tenant: %s" % (tenant))
137 logger.log_exc("delete tenant failed: %s" % tenant)
140 def sync_users(self):
142 save all users where enacted < updated or enacted == None. Remove users that
143 no don't exist in openstack db if they have an enacted time (enacted != None).
145 # get all users that need to be synced (enacted < updated or enacted is None)
146 pending_users = User.objects.filter(Q(enacted__lt=F('updated')) | Q(enacted=None))
147 for user in pending_users:
149 self.manager.save_user(user)
150 logger.info("saved user: %s" % (user))
152 logger.log_exc("save user failed: %s" %user)
154 # get all users that where enacted != null. We can assume these users
155 # have previously been synced and need to be checed for deletion.
156 users = User.objects.filter(enacted__isnull=False)
159 user_dict[user.kuser_id] = user
161 # delete keystone users that don't have a user record
162 system_users = ['admin', 'nova', 'quantum', 'glance', 'cinder', 'swift', 'service']
163 users = self.manager.driver.shell.keystone.users.findall()
165 if user.name in system_users:
167 if user.id not in user_dict:
169 #self.manager.driver.delete_user(user.id)
170 logger.info("deleted user: %s" % user)
172 logger.log_exc("delete user failed: %s" % user)
175 def sync_user_tenant_roles(self):
177 Save all site privileges and slice memberships wheree enacted < updated or
178 enacted == None. Remove ones that don't exist in openstack db if they have
179 an enacted time (enacted != None).
181 # sync site privileges
182 pending_site_privileges = SitePrivilege.objects.filter(Q(enacted__lt=F('updated')) | Q(enacted=None))
183 for site_priv in pending_site_privileges:
185 self.manager.save_site_privilege(site_priv)
186 logger.info("saved site privilege: %s" % (site_priv))
187 except: logger.log_exc("save site privilege failed: %s " % site_priv)
189 # sync slice memberships
190 pending_slice_memberships = SliceMembership.objects.filter(Q(enacted__lt=F('updated')) | Q(enacted=None))
191 for slice_memb in pending_slice_memberships:
193 self.manager.save_slice_membership(slice_memb)
194 logger.info("saved slice membership: %s" % (slice_memb))
195 except: logger.log_exc("save slice membership failed: %s" % slice_memb)
197 # get all site privileges and slice memberships that have been enacted
198 user_tenant_roles = defaultdict(list)
199 for site_priv in SitePrivilege.objects.filter(enacted__isnull=False):
200 user_tenant_roles[(site_priv.user.kuser_id, site_priv.site.tenant_id)].append(site_priv.role.role)
201 for slice_memb in SliceMembership.objects.filter(enacted__isnull=False):
202 user_tenant_roles[(slice_memb.user.kuser_id, slice_memb.slice.tenant_id)].append(slice_memb.role.role)
204 # Some user tenant role aren't stored in planetstack but they must be preserved.
205 # Role that fall in this category are
206 # 1. Never remove a user's role that their home site
207 # 2. Never remove a user's role at a slice they've created.
208 # Keep track of all roles that must be preserved.
209 users = User.objects.all()
212 tenant_ids = [s['tenant_id'] for s in user.slices.values()]
213 tenant_ids.append(user.site.tenant_id)
214 preserved_roles[user.kuser_id] = tenant_ids
217 # begin removing user tenant roles from keystone. This is stored in the
219 for metadata in self.manager.driver.shell.keystone_db.get_metadata():
221 if metadata.user_id == self.manager.driver.admin_user.id:
223 # skip preserved tenant ids
224 if metadata.user_id in preserved_roles and \
225 metadata.tenant_id in preserved_roles[metadata.user_id]:
227 # get roles for user at this tenant
228 user_tenant_role_ids = user_tenant_roles.get((metadata.user_id, metadata.tenant_id), [])
230 if user_tenant_role_ids:
231 # The user has roles at the tenant. Check if roles need to
233 user_keystone_role_ids = metadata.data.get('roles', [])
234 for role_id in user_keystone_role_ids:
235 if role_id not in user_tenant_role_ids:
236 user_keystone_role_ids.pop(user_keystone_role_ids.index(role_id))
238 # The user has no roles at this tenant.
239 metadata.data['roles'] = []
240 #session.add(metadata)
241 logger.info("pruning metadata for %s at %s" % (metadata.user_id, metadata.tenant_id))
243 def sync_slivers(self):
245 save all slivers where enacted < updated or enacted == None. Remove slivers that
246 no don't exist in openstack db if they have an enacted time (enacted != None).
248 # get all users that need to be synced (enacted < updated or enacted is None)
249 pending_slivers = Sliver.objects.filter(Q(enacted__lt=F('updated')) | Q(enacted=None))
250 for sliver in pending_slivers:
253 # update manager context
254 self.manager.init_caller(sliver.creator, sliver.slice.name)
255 self.manager.save_sliver(sliver)
256 logger.info("saved sliver: %s" % (sliver))
258 logger.log_exc("save sliver failed: %s" % sliver)
260 # get all slivers where enacted != null. We can assume these users
261 # have previously been synced and need to be checed for deletion.
262 slivers = Sliver.objects.filter(enacted__isnull=False)
264 for sliver in slivers:
265 sliver_dict[sliver.instance_id] = sliver
267 # delete sliver that don't have a sliver record
268 ctx = self.manager.driver.shell.nova_db.ctx
269 instances = self.manager.driver.shell.nova_db.instance_get_all(ctx)
270 for instance in instances:
271 if instance.uuid not in sliver_dict:
273 # lookup tenant and update context
274 tenant = self.manager.driver.shell.keystone.tenants.find(id=instance.project_id)
275 self.manager.init_admin(tenant=tenant.name)
276 self.manager.driver.destroy_instance(instance.uuid)
277 logger.info("destroyed sliver: %s" % (instance))
279 logger.log_exc("destroy sliver failed: %s" % instance)
282 def sync_sliver_ips(self):
283 # fill in null ip addresses
284 slivers = Sliver.objects.filter(ip=None)
285 for sliver in slivers:
287 self.manager.init_admin(tenant=sliver.slice.name)
288 servers = self.manager.driver.shell.nova.servers.findall(id=sliver.instance_id)
292 ips = server.addresses.get(sliver.slice.name, [])
295 sliver.ip = ips[0]['addr']
297 logger.info("saved sliver ip: %s %s" % (sliver, ips[0]))
299 def sync_external_routes(self):
300 routes = self.manager.driver.get_external_routes()
301 subnets = self.manager.driver.shell.quantum.list_subnets()['subnets']
302 for subnet in subnets:
304 self.manager.driver.add_external_route(subnet, routes)
306 logger.log_exc("failed to add external route for subnet %s" % subnet)