ForgotPassword: DONE-Using the Django authentication system- Adapted to use manifold...
[unfold.git] / portal / sliceview.py
1 import json
2 from django.template                 import RequestContext
3 from django.shortcuts                import render_to_response
4
5 from unfold.loginrequired            import LoginRequiredAutoLogoutView
6
7 from unfold.page                     import Page
8 from manifold.core.query             import Query, AnalyzedQuery
9 from manifold.manifoldapi            import execute_query
10
11 from ui.topmenu                      import topmenu_items_live, the_user
12
13 from plugins.raw                     import Raw
14 from plugins.stack                   import Stack
15 from plugins.tabs                    import Tabs
16 from plugins.querytable              import QueryTable 
17 from plugins.querygrid               import QueryGrid
18 from plugins.queryupdater            import QueryUpdater
19 from plugins.googlemap               import GoogleMap
20 from plugins.senslabmap              import SensLabMap
21 from plugins.scheduler               import Scheduler
22 from plugins.querycode               import QueryCode
23 # Thierry
24 # stay away from query editor for now as it seems to make things go very slow
25 # see https://lists.myslice.info/pipermail/devel-myslice/2013-December/000221.html 
26 #from plugins.query_editor            import QueryEditor
27 from plugins.active_filters          import ActiveFilters
28 from plugins.quickfilter             import QuickFilter
29 from plugins.messages                import Messages
30 from plugins.slicestat               import SliceStat
31
32 from myslice.config                  import Config
33
34 tmp_default_slice='ple.upmc.myslicedemo'
35
36 # temporary : turn off the users part to speed things up
37 #do_query_users=True
38 do_query_users=False
39
40 #do_query_leases=True
41 do_query_leases=False
42
43 insert_grid=False
44 #insert_grid=True
45
46 insert_messages=False
47 #insert_messages=True
48
49 class SliceView (LoginRequiredAutoLogoutView):
50
51     def get (self,request, slicename=tmp_default_slice):
52     
53         page = Page(request)
54         page.add_css_files ('css/slice-view.css')
55         page.add_js_files  ( [ "js/common.functions.js" ] )
56         page.add_js_chunks ('$(function() { messages.debug("sliceview: jQuery version " + $.fn.jquery); });')
57         page.add_js_chunks ('$(function() { messages.debug("sliceview: users turned %s"); });'%("on" if do_query_users else "off"))
58         page.add_js_chunks ('$(function() { messages.debug("sliceview: leases turned %s"); });'%("on" if do_query_leases else "off"))
59         config=Config()
60         page.add_js_chunks ('$(function() { messages.debug("manifold URL %s"); });'%(config.manifold_url()))
61
62         metadata = page.get_metadata()
63         resource_md = metadata.details_by_object('resource')
64         resource_fields = [column['name'] for column in resource_md['column']]
65     
66         user_md = metadata.details_by_object('user')
67         user_fields = ['user_hrn'] # [column['name'] for column in user_md['column']]
68     
69         # TODO The query to run is embedded in the URL
70         main_query = Query.get('slice').filter_by('slice_hrn', '=', slicename)
71         main_query.select(
72                 'slice_hrn',
73                 #'resource.hrn', 'resource.urn', 
74                 'resource.hostname', 'resource.type', 
75                 'resource.network_hrn',
76                 'lease.urn',
77                 'user.user_hrn',
78                 #'application.measurement_point.counter'
79         )
80         # for internal use in the querytable plugin;
81         # needs to be a unique column present for each returned record
82         main_query_init_key = 'hostname'
83     
84         query_resource_all = Query.get('resource').select(resource_fields)
85
86         aq = AnalyzedQuery(main_query, metadata=metadata)
87         page.enqueue_query(main_query, analyzed_query=aq)
88         page.enqueue_query(query_resource_all)
89         if do_query_users:
90             # Required: the user must have an authority in its user.config
91             # XXX Temporary solution
92             user_query  = Query().get('local:user').select('config','email')
93             user_details = execute_query(self.request, user_query)
94             
95             # not always found in user_details...
96             config={}
97 #            for user_detail in user_details:
98 #                #email = user_detail['email']
99 #                if user_detail['config']:
100 #                    config = json.loads(user_detail['config'])
101 #            user_detail['authority'] = config.get('authority',"Unknown Authority")
102 #
103 #            if user_detail['authority'] is not None:
104 #                sub_authority = user_detail['authority'].split('.')
105 #                root_authority = sub_authority[0]
106 #                query_user_all = Query.get(root_authority+':user').select(user_fields)
107 #
108 #                # XXX TODO this filter doesn't work - to be improved in Manifold
109 #                #.filter_by('authority.authority_hrn', '=', user_detail['authority'])
110 #
111 #                page.enqueue_query(query_user_all)
112 #            else:
113 #                print "authority of the user is not in local:user db"
114             query_user_all = Query.get('user').select(user_fields)
115             #    query_user_all = None
116     
117         # ... and for the relations
118         # XXX Let's hardcode resources for now
119         sq_resource    = aq.subquery('resource')
120         sq_user        = aq.subquery('user')
121         sq_lease       = aq.subquery('lease')
122         sq_measurement = aq.subquery('measurement')
123         
124     
125         # Prepare the display according to all metadata
126         # (some parts will be pending, others can be triggered by users).
127         # 
128         # For example slice measurements will not be requested by default...
129     
130         # Create the base layout (Stack)...
131         main_stack = Stack (
132             page=page,
133             title="Slice %s"%slicename,
134             sons=[],
135         )
136     
137         # ... responsible for the slice properties...
138     
139         # a nice header
140         main_stack.insert (
141             Raw (page=page,
142                  togglable=False, 
143                  toggled=True,
144                  html="<h2 class='well well-lg'> Slice %s</h2>"%slicename)
145         )
146     
147         # --------------------------------------------------------------------------
148         # QueryUpdater (Pending Operations)
149
150         main_stack.insert(QueryUpdater(
151             page                = page,
152             title               = 'Pending operations',
153             query               = main_query,
154             togglable           = True,
155             # start turned off, it will open up itself when stuff comes in
156             toggled             = False, 
157             domid               = 'pending',
158             outline_complete    = True,
159         ))
160
161         # --------------------------------------------------------------------------
162         # Filter Resources
163        
164 # turn off for now -- see above
165 #        filter_query_editor = QueryEditor(
166 #            page  = page,
167 #            query = sq_resource, 
168 #            query_all = query_resource_all,
169 #            title = "Select Columns",
170 #            domid = 'select-columns',
171 #            )
172         filter_active_filters = ActiveFilters(
173             page  = page,
174             query = sq_resource,
175             title = "Active Filters",
176             )
177         filters_area = Stack(
178             page                = page,
179             title               = 'Filter Resources',
180             domid               = 'filters',
181             sons                = [# filter_query_editor, 
182                                    filter_active_filters],
183             togglable           = True,
184             toggled             = 'persistent',
185             outline_complete    = True, 
186         )
187         main_stack.insert (filters_area)
188
189         # --------------------------------------------------------------------------
190         # RESOURCES
191         # the resources part is made of a Tabs (Geographic, List), 
192
193         resources_as_gmap = GoogleMap(
194             page       = page,
195             title      = 'Geographic view',
196             domid      = 'resources-map',
197             # tab's sons preferably turn this off
198             togglable  = False,
199             query      = sq_resource,
200             query_all  = query_resource_all,
201             # this key is the one issued by google
202             googlemap_api_key = Config().googlemap_api_key(),
203             # the key to use at init-time
204             init_key   = main_query_init_key,
205             checkboxes = True,
206             # center on Paris
207             latitude   = 49.,
208             longitude  = 9,
209             zoom       = 4,
210         )
211
212         resources_as_3dmap = SensLabMap(
213             page       = page,
214             title      = '3D Map',
215             domid      = 'senslabmap',
216             query      = sq_resource,
217             query_all  = query_resource_all,
218         )
219
220         resources_as_list = QueryTable( 
221             page       = page,
222             domid      = 'resources-list',
223             title      = 'List view',
224             # this is the query at the core of the slice list
225             query      = sq_resource,
226             query_all  = query_resource_all,
227             init_key     = main_query_init_key,
228             checkboxes = True,
229             datatables_options = { 
230                 'iDisplayLength': 25,
231                 'bLengthChange' : True,
232                 'bAutoWidth'    : True,
233                 },
234             )
235
236         if insert_grid:
237             resources_as_grid = QueryGrid( 
238                 page       = page,
239                 domid      = 'resources-grid',
240                 title      = 'Grid view',
241                 # this is the query at the core of the slice list
242                 query      = sq_resource,
243                 query_all  = query_resource_all,
244                 init_key     = main_query_init_key,
245                 checkboxes = True,
246                 )
247
248         if do_query_leases:
249             resources_as_scheduler = Scheduler(
250                 page        = page,
251                 title       = 'Scheduler',
252                 domid       = 'scheduler',
253                 query       = sq_resource,
254                 query_all_resources = query_resource_all,
255                 query_lease = sq_lease,
256                 )
257
258        # with the new 'Filter' stuff on top, no need for anything but the querytable
259         resources_as_list_area = resources_as_list 
260
261         resources_sons = [
262             resources_as_gmap, 
263             resources_as_3dmap,
264             resources_as_scheduler,
265             resources_as_list_area,
266             ] if do_query_leases else [
267             resources_as_gmap, 
268             resources_as_3dmap,
269             resources_as_list_area,
270             ]
271         if insert_grid:
272             resources_sons.append(resources_as_grid)
273
274         resources_area = Tabs ( page=page, 
275                                 domid="resources",
276                                 togglable=True,
277                                 title="Resources",
278                                 outline_complete=True,
279                                 sons= resources_sons,
280                                 active_domid = 'resources-map',
281                                 persistent_active=True,
282                                 )
283         main_stack.insert (resources_area)
284
285         # --------------------------------------------------------------------------
286         # USERS
287     
288         if do_query_users and query_user_all is not None:
289             tab_users = Tabs(
290                 page                = page,
291                 domid               = 'users',
292                 outline_complete    = True,
293                 togglable           = True,
294                 title               = 'Users',
295                 active_domid        = 'users-list',
296                 )
297             main_stack.insert(tab_users)
298     
299             tab_users.insert(QueryTable( 
300                 page        = page,
301                 title       = 'Users List',
302                 domid       = 'users-list',
303                 # tab's sons preferably turn this off
304                 togglable   = False,
305                 # this is the query at the core of the slice list
306                 query       = sq_user,
307                 query_all  = query_user_all,
308                 checkboxes  = True,
309                 datatables_options = { 
310                     'iDisplayLength' : 25,
311                     'bLengthChange'  : True,
312                     'bAutoWidth'     : True,
313                 },
314             ))
315
316 # DEMO    
317         # --------------------------------------------------------------------------
318         # MEASUREMENTS
319         measurements_stats_cpu = SliceStat(
320             title = "CPU Usage",
321             domid = 'resources-stats-cpu',
322             page  = page,
323             stats = 'slice',
324             key   = 'hrn',
325             query = 'none',
326             slicename = slicename,
327             o = 'cpu'
328         )
329         
330         measurements_stats_mem = SliceStat(
331             title = "Memory Usage",
332             domid = 'resources-stats-mem',
333             page  = page,
334             stats = 'slice',
335             key   = 'hrn',
336             query = 'none',
337             slicename = slicename,
338             o = 'mem'
339         )
340         
341         measurements_stats_asb = SliceStat(
342             title = "Traffic Sent",
343             domid = 'resources-stats-asb',
344             page  = page,
345             stats = 'slice',
346             key   = 'hrn',
347             query = 'none',
348             slicename = slicename,
349             o = 'asb'
350         )
351         
352         measurements_stats_arb = SliceStat(
353             title = "Traffic Received",
354             domid = 'resources-stats-arb',
355             page  = page,
356             stats = 'slice',
357             key   = 'hrn',
358             query = 'none',
359             slicename = slicename,
360             o = 'arb'
361         )
362
363         tab_measurements = Tabs ( page=page,
364                                 domid="measurements",
365                                 togglable=True,
366                                 toggled  = False,
367                                 title="Measurements",
368                                 outline_complete=True,
369                                 sons=[ measurements_stats_cpu, measurements_stats_mem, measurements_stats_asb, measurements_stats_arb ],
370                                 active_domid = 'measurements_stats_cpu',
371                                 )
372         main_stack.insert (tab_measurements)
373         
374 #        tab_measurements = Tabs (
375 #            page                = page,
376 #            active_domid        = 'measurements-list',
377 #            outline_complete    = True,
378 #            togglable           = True,
379 #            title               = 'Measurements',
380 #            domid               = 'measurements',
381 #        )
382 #        main_stack.insert(tab_measurements)
383 #    
384 #        tab_measurements.insert(QueryTable( 
385 #            page        = page,
386 #            title       = 'Measurements',
387 #            domid       = 'measurements-list',
388 #            # tab's sons preferably turn this off
389 #            togglable   = False,
390 #            # this is the query at the core of the slice list
391 #            query       = sq_measurement,
392 #            # do NOT set checkboxes to False
393 #            # this table being otherwise empty, it just does not fly with dataTables
394 #            checkboxes  = True,
395 #            datatables_options = { 
396 #                'iDisplayLength' : 25,
397 #                'bLengthChange'  : True,
398 #                'bAutoWidth'     : True,
399 #            },
400 #        ))
401 #    
402 #        # --------------------------------------------------------------------------
403 #        # MESSAGES (we use transient=False for now)
404         if insert_messages:
405             main_stack.insert(Messages(
406                     page   = page,
407                     title  = "Runtime messages for slice %s"%slicename,
408                     domid  = "msgs-pre",
409                     levels = "ALL",
410                     # plain messages are probably less nice for production but more reliable for development for now
411                     transient = False,
412                     # these make sense only in non-transient mode..
413                     togglable = True,
414                     toggled = 'persistent',
415                     outline_complete = True,
416                     ))
417     
418         # variables that will get passed to the view-unfold1.html template
419         template_env = {}
420         
421         # define 'unfold_main' to the template engine - the main contents
422         template_env [ 'unfold_main' ] = main_stack.render(request)
423     
424         # more general variables expected in the template
425         template_env [ 'title' ] = '%(slicename)s'%locals()
426         # the menu items on the top
427         template_env [ 'topmenu_items' ] = topmenu_items_live('Slice', page) 
428         # so we can sho who is logged
429         template_env [ 'username' ] = the_user (request) 
430     
431         # don't forget to run the requests
432         page.expose_js_metadata()
433         # the prelude object in page contains a summary of the requirements() for all plugins
434         # define {js,css}_{files,chunks}
435         template_env.update(page.prelude_env())
436
437         return render_to_response ('view-unfold1.html',template_env,
438                                    context_instance=RequestContext(request))