1 from django.contrib.auth import authenticate, login, logout
\r
2 from django.template import RequestContext
\r
3 from django.shortcuts import render, render_to_response
\r
5 from manifoldapi.manifoldresult import ManifoldResult
\r
6 from ui.topmenu import topmenu_items, the_user
\r
7 from myslice.configengine import ConfigEngine
\r
8 from manifold.core.query import Query
\r
9 from unfold.page import Page
\r
10 from manifoldapi.manifoldapi import execute_admin_query, execute_query
\r
11 from unfold.loginrequired import LoginRequiredAutoLogoutView
\r
13 from myslice.theme import ThemeView
\r
21 from django.views.decorators.csrf import csrf_exempt
\r
22 from django.http import *
\r
25 def response_mimetype(request):
\r
27 if "application/json" in request.META['HTTP_ACCEPT']:
\r
28 return "application/json"
\r
33 def json_to_rest(url, data ):
\r
35 req = urllib2.Request(url)
\r
36 req.add_header('Content-Type', 'application/json')
\r
37 response = urllib2.urlopen(req, json.dumps(data))
\r
40 mylist = ast.literal_eval(response.read())
\r
42 mylist = response.read().translate(None, '"[]').split(",")
\r
47 def unix_to_timestamp(timest):
\r
49 return datetime.datetime.fromtimestamp(int(timest)).strftime('%Y-%m-%d %H:%M:%S')
\r
53 def timestamp_to_unix(timest):
\r
60 def slice_to_exp(slices_users):
\r
63 wildcard_testbeds = {}
\r
66 for slice in slices_users:
\r
68 leases = slice['lease']
\r
70 if leases is not None and leases:
\r
71 for lease in leases:
\r
72 resource = lease['resource']
\r
73 start_t = lease['start_time']
\r
74 end_t = lease['end_time']
\r
76 testbed_start = resource.index('IDN+')+4
\r
77 testbed_end = resource.index('+node+')
\r
79 testbed = resource[testbed_start:testbed_end]
\r
80 node = resource[testbed_end+6:]
\r
81 if 'omf:nitos' in testbed:
\r
82 testbed = 'omf:nitos'
\r
83 if testbed in testbeds:
\r
84 if node not in testbeds[testbed]:
\r
85 testbeds[testbed].append(node)
\r
87 testbeds[testbed] = [node]
\r
89 #group nodes in consecutive timeslots
\r
90 if not node in nodes:
\r
91 nodes[node]={str(start_t):{'start_t':start_t, 'nodes':node, 'end_t':end_t}}
\r
93 if not str(start_t) in nodes[node]:
\r
95 for n in nodes[node]:
\r
96 if n[str(end_t)] == start_t:
\r
97 n[str(end_t)] == end_t
\r
100 nodes[node][str(start_t)]={'start_t':start_t, 'nodes':node, 'end_t':end_t}
\r
102 ######### FOR PLE LIKE start ##################
\r
103 for resource in slice['resource']:
\r
104 testbed_start = resource.index('IDN+')+4
\r
105 testbed_end = resource.index('+node+')
\r
106 tb = resource[testbed_start:testbed_end]
\r
107 node = resource[testbed_end+6:]
\r
110 if 'omf:nitos' in tb:
\r
112 if tb not in testbeds:
\r
114 if node not in wildcard_testbeds[slice['slice_hrn']][tb]:
\r
115 wildcard_testbeds[slice['slice_hrn']][tb].append([node])
\r
118 wildcard_testbeds[slice['slice_hrn']][tb] = [node]
\r
120 wildcard_testbeds[slice['slice_hrn']]={tb:[node]}
\r
124 s = slice['slice_last_updated']
\r
125 #s_time = int(time.mktime(datetime.datetime.strptime(s, "%Y%m%dT%H:%M:%Ss").timetuple()))
\r
126 s_time = time.mktime(s.timetuple())
\r
128 if slice['resource'] is not None:
\r
130 for resource in slice['resource']:
\r
131 testbed_start = resource.index('IDN+')+4
\r
132 testbed_end = resource.index('+node+')
\r
133 tb = resource[testbed_start:testbed_end]
\r
136 if 'omf:nitos' in tb:
\r
138 node = resource[testbed_end+6:]
\r
140 if testbed in testbeds:
\r
141 if node not in testbeds[testbed]:
\r
142 testbeds[testbed].append(node)
\r
144 testbeds[testbed] = [node]
\r
146 if not node in nodes:
\r
147 #nodes[node] = {str(start_t):{'start_t':s_time, 'nodes':node, 'end_t':int(time.time())}}
\r
148 nodes[node] = {str(start_t):{'start_t':s_time, 'nodes':node, 'end_t':s_time}}
\r
149 ######### FOR PLE LIKE end ##################
\r
152 #group grouped nodes in experiments
\r
154 for exp in nodes[n]:
\r
155 key = str(exp) + str(nodes[n][exp]['end_t']) + slice['slice_hrn']
\r
157 if key not in experiments:
\r
158 experiments[key]={'slice_hrn':slice['slice_hrn'], \
\r
159 'start':nodes[n][exp]['start_t'], 'end':nodes[n][exp]['end_t'], 'nodes':[nodes[n][exp]['nodes']]}
\r
162 ######### FOR PLE LIKE start ##################
\r
163 for item in wildcard_testbeds:
\r
164 if item == experiments[key]['slice_hrn']:
\r
165 for testbed in wildcard_testbeds[item]:
\r
167 if testbed not in testbeds:
\r
168 testbeds[testbed] = wildcard_testbeds[item][testbed]
\r
170 for n in wildcard_testbeds[item][testbed]:
\r
171 if n not in experiments[key]['nodes']:
\r
172 experiments[key]['nodes'].append(n)
\r
173 ######### FOR PLE LIKE end ##################
\r
175 elif nodes[n][exp]['end_t'] == experiments[key]['end']:
\r
176 experiments[key]['nodes'].append(nodes[n][exp]['nodes'])
\r
179 ######### FOR PLE LIKE start ##################
\r
180 for item in wildcard_testbeds:
\r
181 if item == experiments[key]['slice_hrn']:
\r
182 for testbed in wildcard_testbeds[item]:
\r
184 if testbed not in testbeds:
\r
185 testbeds[testbed] = wildcard_testbeds[item][testbed]
\r
187 for n in wildcard_testbeds[item][testbed]:
\r
188 if n not in experiments[key]['nodes']:
\r
189 experiments[key]['nodes'].append(n)
\r
190 ######### FOR PLE LIKE end ##################
\r
192 return (experiments,testbeds)
\r
194 class ReputationView (LoginRequiredAutoLogoutView, ThemeView):
\r
195 template_name = 'reputation.html'
\r
197 # expose this so we can mention the backend URL on the welcome page
\r
198 def default_env (self):
\r
200 'MANIFOLD_URL':ConfigEngine().manifold_url(),
\r
203 def post (self,request):
\r
204 env = self.default_env()
\r
205 env['theme'] = self.theme
\r
207 return render_to_response(self.template, env, context_instance=RequestContext(request))
\r
209 def get (self, request, state=None):
\r
210 env = self.default_env()
\r
212 ##### *** Reputation Plugin-specific START *** ############
\r
213 #The following 'if' is a dirty way for bypassing the JS AJAX cross-domain prevention policy...not pretty
\r
214 if request.GET.has_key(u'slicedata[user_eval][overall]'):
\r
216 dict_to_send['eid'] = str(request.GET[u'slicedata[id]'])
\r
217 dict_to_send['slice_hrn'] = str(request.GET[u'slicedata[slice_hrn]'])
\r
218 dict_to_send['user_hrn'] = str(request.GET[u'slicedata[user_hrn]'])
\r
219 dict_to_send['start_tunix'] = str(request.GET[u'slicedata[start_tunix]'])
\r
220 dict_to_send['end_tunix'] = str(request.GET[u'slicedata[end_tunix]'])
\r
221 dict_to_send['start_t'] = str(request.GET[u'slicedata[start_t]'])
\r
222 dict_to_send['end_t'] = str(request.GET[u'slicedata[end_t]'])
\r
223 dict_to_send['testbeds'] = ast.literal_eval(str(request.GET[u'testbeds']))
\r
224 dict_to_send['user_eval'] = {}
\r
225 dict_to_send['user_eval']['reuse'] = str(request.GET[u'slicedata[user_eval][reuse]'])
\r
226 dict_to_send['user_eval']['availability'] = str(request.GET[u'slicedata[user_eval][availability]'])
\r
227 dict_to_send['user_eval']['pay'] = str(request.GET[u'slicedata[user_eval][pay]'])
\r
228 dict_to_send['user_eval']['support'] = str(request.GET[u'slicedata[user_eval][support]'])
\r
229 dict_to_send['user_eval']['overall'] = str(request.GET[u'slicedata[user_eval][overall]'])
\r
230 dict_to_send['user_eval']['link_quality'] = str(request.GET[u'slicedata[user_eval][link_quality]'])
\r
231 dict_to_send['user_eval']['problems'] = str(request.GET[u'slicedata[user_eval][problems]'])
\r
232 dict_to_send['user_eval']['quality'] = str(request.GET[u'slicedata[user_eval][quality]'])
\r
234 slicedata_received = json_to_rest('http://survivor.lab.netmode.ntua.gr:4567/reputation/json', dict_to_send )
\r
236 return HttpResponse(json.dumps(slicedata_received), content_type = response_mimetype(self.request))
\r
242 userslice_query = Query().get('slice').select('slice_urn', 'slice_hrn', 'users', 'resource', 'lease', 'slice_last_updated')
\r
243 slice_details = execute_query(self.request, userslice_query)
\r
246 local_user_query = Query().get('local:user').select('email','status','config')
\r
247 local_user_details = execute_admin_query(self.request, local_user_query)
\r
249 #get users - create dict[email]=hrn
\r
250 user_query = Query().get('user').select('user_hrn','user_urn','user_email')
\r
251 user_details = execute_admin_query(self.request, user_query)
\r
253 for item in user_details:
\r
254 users_hrn[item['user_email']] = item['user_hrn']
\r
256 #get currenct username (email)
\r
257 if request.user.is_authenticated():
\r
258 cur_username = request.user.username
\r
260 #get a list of all the slices for the logged in user
\r
262 #env['slices_users'] = json.dumps(slice_details, ensure_ascii=False)
\r
263 for slice in slice_details:
\r
265 if users_hrn[cur_username] in slice['users']:
\r
266 slices_users.append({'slice_hrn':slice['slice_hrn'], 'user':cur_username, 'user_hrn':users_hrn[cur_username] \
\r
267 , 'resource':slice['resource'], 'lease':slice['lease'], 'slice_last_updated':slice['slice_last_updated'] })
\r
270 #env['slices_users'] = slices_users ### For logging
\r
271 #####create slicelist for template & JSON
\r
272 experiments,testbeds = slice_to_exp(slices_users)
\r
277 for exp in experiments:
\r
279 experiment['slice_hrn'] = experiments[exp]['slice_hrn']
\r
280 experiment['user_hrn'] = users_hrn[cur_username]
\r
281 experiment['start_tunix'] = experiments[exp]['start']
\r
282 experiment['end_tunix'] = experiments[exp]['end']
\r
283 experiment['start_t'] = unix_to_timestamp(experiments[exp]['start'])
\r
284 experiment['end_t'] = unix_to_timestamp(experiments[exp]['end'])
\r
285 experiment['testbeds'] = {}
\r
286 for exp_node in experiments[exp]['nodes']:
\r
287 list_testbeds = [ key for key,val in testbeds.items()]
\r
288 for tkey in list_testbeds:
\r
289 if exp_node in testbeds[tkey]:
\r
290 if tkey in experiment['testbeds']:
\r
291 if exp_node not in experiment['testbeds'][tkey]:
\r
292 experiment['testbeds'][tkey].append(exp_node)
\r
294 experiment['testbeds'][tkey] = [exp_node]
\r
295 tempid = hashlib.sha1(str(experiment)).hexdigest()
\r
296 experiment['id'] = tempid
\r
298 iddata.append(tempid)
\r
299 all_exp.append(experiment)
\r
300 env['logging_test'] = json.dumps(all_exp, ensure_ascii=False)
\r
301 env['slices_users'] = json.dumps(all_exp, ensure_ascii=False)
\r
302 ###### Check which experiments have not been rated yet. Pop from all_exp any experiment that has already been rated
\r
304 unrated_exp = json_to_rest('http://survivor.lab.netmode.ntua.gr:4567/reputation/qid', iddata)
\r
306 for item in all_exp:
\r
307 if item['id'] in unrated_exp:
\r
310 all_exp.pop(all_exp.index(item))
\r
312 ###### Get Reputation values from Reputation DB
\r
313 reps = json_to_rest('http://survivor.lab.netmode.ntua.gr:4567/reputation/showrep', "a")
\r
314 #env['logging_test'] = reps
\r
316 #create a services list and a dict containing the services for each testbed
\r
320 serv_per_tb[item['testbed']]=[]
\r
321 for serv in item['services']:
\r
322 if serv.keys()[0] not in services:
\r
323 services.append(serv.keys()[0])
\r
324 serv_per_tb[item['testbed']].append(serv.keys()[0])
\r
326 #in json, sevices are in the form: 'services':[{'serv1':x}, {'serv2':y}], so we transform it to 'services':[x,y] based on
\r
327 # the services dict above. If for a specific service there is no applicable value, we put N/A
\r
328 for testbed in reps:
\r
329 d = list(testbed['services'])
\r
330 del testbed['services']
\r
331 testbed['services'] = []
\r
336 testbed['services'].append(i[s])
\r
341 testbed['services'].append('N/A')
\r
343 ###### Pass variables to template
\r
344 #env['logging_test'] = json.dumps(all_exp, ensure_ascii=False)
\r
345 env['serv_per_tb'] = json.dumps(serv_per_tb, ensure_ascii=False)
\r
346 env['reputation'] = reps
\r
347 env['rep_serv'] = services
\r
348 env['slicelist'] = all_exp
\r
349 env['json_data'] = json.dumps(all_exp, ensure_ascii=False)
\r
351 ###### *** Reputation Plugin-specific END *** ############
\r
354 if request.user.is_authenticated():
\r
355 env['person'] = self.request.user
\r
357 env['person'] = None
\r
359 env['theme'] = self.theme
\r
360 #env['user_list']= user_list
\r
362 env['username']=the_user(request)
\r
363 env['topmenu_items'] = topmenu_items(None, request)
\r
364 if state: env['state'] = state
\r
365 elif not env['username']: env['state'] = None
\r
366 # use one or two columns for the layout - not logged in users will see the login prompt
\r
367 env['layout_1_or_2']="layout-unfold2.html" if not env['username'] else "layout-unfold1.html"
\r
369 return render_to_response(self.template, env, context_instance=RequestContext(request))
\r