def get_user_account(request, user_email, platform_name): """ Returns the user configuration for a given platform. This function does not resolve references. """ user_query = Query().get('local:user').filter_by( 'email', '==', user_email).select('user_id') user_details = execute_admin_query(request, user_query) platform_query = Query().get('local:platform').filter_by( 'platform', '==', platform_name).select('platform_id') platform_details = execute_admin_query(request, platform_query) account_query = Query().get('local:account').filter_by( 'platform_id', '==', platform_details[0]['platform_id']).filter_by( 'user_id', '==', user_details[0]['user_id']).select('user_id', 'platform_id', 'auth_type', 'config') accounts = execute_admin_query(request, account_query) if not accounts: raise Exception, "this account does not exist" if accounts[0]['auth_type'] == 'reference': pf = json.loads(accounts[0]['config'])['reference_platform'] return get_user_account(request, user_email, pf) return accounts[0]
def check(self): request = self.auth.request # Have we been authenticated by the ssl layer ? peer_certificate = request.channel.transport.getPeerCertificate() user_hrn = peer_certificate.get_subject().commonName if peer_certificate else None if not user_hrn: raise AuthenticationFailure, "GID verification failed" # We need to map the SFA user to the Manifold user... let's search into his accounts query_user_id = Query.get('local:linked_account').filter_by('identifier', '==', user_hrn).select('user_id') ret_user_ids = self.interface.forward(query_user_id) if ret_user_ids['code'] != 0: raise Exception, "Failure requesting linked accounts for identifier '%s'" % user_hrn user_ids = ret_user_ids['value'] if not user_ids: raise Exception, "No linked account found with identifier '%s'" % user_hrn print "user_ids", user_ids user_id = user_ids[0]['user_id'] query_user = Query.get('local:user').filter_by('user_id', '==', user_id) ret_users = self.interface.forward(query_user) if ret_users['code'] != 0: raise Exception, "Failure requesting linked accounts for identifier '%s'" % user_hrn users = ret_users['value'] if not users: raise Exception, "Internal error: no user found with user_id = '%d'" % user_id user, = users print "Linked SFA account '%s' for user: %r" % (user_hrn, user)
def topmenu_items_live(current, page): request = page.request # XXX TODO This should be triggered only when user is logged in # We might use local storage instead # REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2 if request.user.is_authenticated(): query_pi_auths = Query.get('myslice:user').filter_by( 'user_hrn', '==', '$user_hrn').select('user_hrn', 'pi_authorities') page.enqueue_query(query_pi_auths) else: query_pi_auths = Query() # # even though this plugin does not have any html materialization, the corresponding domid # # must exist because it is searched at init-time to create the JS plugin # # so we simply piggy-back the target button created in the topmenu topmenuvalidation = TopmenuValidation( page=page, # see above domid='topmenu-validation', query=query_pi_auths, # this one is the target for a $.show() when the query comes back button_domid="topmenu-validation") # although the result does not matter, rendering is required for the JS init code to make it in the page topmenuvalidation.render(request) return topmenu_items_static(current, request)
def get_context_data(self, **kwargs): page = Page(self.request) # This will simulate fake records in order to test the plugin fake_query = Query.get('ping').select('hrn', 'src_hostname', 'dst_hostname', 'delay') fake_query_all = Query.get('ping').select('hrn', 'src_hostname', 'dst_hostname', 'delay') generators = { 'hrn': 'random_string', 'src_hostname': 'random_string', 'dst_hostname': 'random_string', 'delay': 'random_int' } page.generate_records(fake_query, generators, 5) page.generate_records(fake_query_all, generators, 20) plugin = MadDash(query = fake_query, query_all = fake_query_all, page = page) context = super(MadDashView, self).get_context_data(**kwargs) context['unfold_main'] = plugin.render(self.request) context['title'] = 'Sandbox for MadDash plugin' context['topmenu_items'] = topmenu_items_live ('maddash', page) context['username'] = the_user(self.request) prelude_env = page.prelude_env() context.update(prelude_env) return context
def get_context_data(self, **kwargs): page = Page(self.request) # This will simulate fake records in order to test the plugin fake_query = Query.get('ping').select('hrn', 'src_hostname', 'dst_hostname', 'delay') fake_query_all = Query.get('ping').select('hrn', 'src_hostname', 'dst_hostname', 'delay') generators = { 'hrn': 'random_string', 'src_hostname': 'random_string', 'dst_hostname': 'random_string', 'delay': 'random_int' } page.generate_records(fake_query, generators, 5) page.generate_records(fake_query_all, generators, 20) plugin = MadDash(query=fake_query, query_all=fake_query_all, page=page) context = super(MadDashView, self).get_context_data(**kwargs) context['unfold_main'] = plugin.render(self.request) context['title'] = 'Sandbox for MadDash plugin' context['topmenu_items'] = topmenu_items_live('maddash', page) context['username'] = the_user(self.request) prelude_env = page.prelude_env() context.update(prelude_env) return context
def get_or_post (self, request, method): """ """ errors = [] slice_name ='' #purpose='' #url='' authority_hrn = None authority_name = None # Retrieve the list of authorities authorities = getAuthorities(request, admin=True) ##if self.theme == 'fed4fire' or self.theme == 'onelab': #authorities_query = Query.get('myslice:authority').select('authority_hrn') ##else: ## authorities_query = Query.get('authority').select('name', 'authority_hrn') #authorities = execute_admin_query(request, authorities_query) #if authorities is not None: # authorities = sorted(authorities, key=lambda k: k['authority_hrn']) # #if self.theme != 'fed4fire' or self.theme != 'onelab': # # authorities = sorted(authorities, key=lambda k: k['name']) # Get user_email (XXX Would deserve to be simplified) user_query = Query().get('local:user').select('email','config') user_details = execute_query(request, user_query) user_email = user_details[0].get('email') # getting user_hrn for user_detail in user_details: user_config = json.loads(user_detail['config']) user_authority = user_config.get('authority','N/A') # getting the org from authority # for authority in authorities: # if 'name' in authority and authority['authority_hrn'] == user_authority: # authority_name = authority['name'] # Handle the case when we use only hrn and not name #if authority_name is None: # authority_name = user_authority account_query = Query().get('local:account').select('user_id','platform_id','auth_type','config') account_details = execute_query(request, account_query) platform_query = Query().get('local:platform').select('platform_id','platform','gateway_type','disabled') platform_details = execute_query(request, platform_query) user_hrn = None #getting user_hrn from local:account for account_detail in account_details: for platform_detail in platform_details: if platform_detail['platform_id'] == account_detail['platform_id']: # taking user_hrn only from myslice account # NOTE: we should later handle accounts filter_by auth_type= managed OR user if 'myslice' in platform_detail['platform']: account_config = json.loads(account_detail['config']) user_hrn = account_config.get('user_hrn','N/A')
def sfa_add_user_to_slice(request, user_hrn, slice_params): # UPDATE myslice:slice SET researcher=['ple.upmc.jordan_auge','ple.inria.thierry_parmentelat','ple.upmc.loic_baron','ple.upmc.ciro_scognamiglio','ple.upmc.mohammed-yasin_rahman','ple.upmc.azerty'] where slice_hrn=='ple.upmc.myslicedemo' query_current_users = Query.get('slice').select('user').filter_by('slice_hrn','==',slice_params['hrn']) results_current_users = execute_query(request, query_current_users) slice_params['researcher'] = slice_params['researcher'] | results_current_users query = Query.update('slice').filter_by('user_hrn', '==', user_hrn).set(slice_params).select('slice_hrn') results = execute_query(request, query) # Also possible but not supported yet # UPDATE myslice:user SET slice=['ple.upmc.agent','ple.upmc.myslicedemo','ple.upmc.tophat'] where user_hrn=='ple.upmc.azerty' if not results: raise Exception, "Could not create %s. Already exists ?" % slice_params['hrn'] return results
def get(self, request): authority_contacts = {} authority = {'authority_hrn': 'fed4fire.upmc'} if request.user.is_authenticated(): user_local_query = Query().get('local:user').select( 'config').filter_by('email', '==', str(self.request.user)) user_local_details = execute_query(self.request, user_local_query) user_authority = json.loads( user_local_details[0]['config']).get('authority') logger.info( "**************________ management about = {}".format( user_authority)) # XXX Should be done using Metadata # select column.name from local:object where table=='authority' authority_query = Query().get('authority').select( 'authority_hrn', 'name', 'address', 'enabled', 'description', 'scientific', 'city', 'name', 'url', 'country', 'enabled', 'longitude', 'tech', 'latitude', 'pi_users', 'onelab_membership', 'postcode').filter_by('authority_hrn', '==', user_authority) authority_details = execute_query(self.request, authority_query) if authority_details: authority = authority_details[0] if 'scientific' in authority and authority[ 'scientific'] is not None: authority_contacts['scientific'] = [ x.strip()[1:-1] for x in authority['scientific'][1:-1].split(',') ] if 'technical' in authority and authority[ 'technical'] is not None: authority_contacts['technical'] = [ x.strip()[1:-1] for x in authority['tech'][1:-1].split(',') ] if 'legal' in authority and authority['legal'] is not None: authority_contacts['legal'] = [ x.strip().replace('"', '') for x in authority['legal'][1:-1].split(',') ] else: authority_contacts = None authority = None return render_to_response(self.template, { 'theme': self.theme, 'authority': authority, 'authority_contacts': authority_contacts }, context_instance=RequestContext(request))
def __init__(self, id=None, name=None): if id is not None: platform_query = Query().get('local:platform').select( 'platform_id', 'platform', 'gateway_type', 'disabled').filter_by('platform_id', '==', platform_id) if name is not None: platform_query = Query().get('local:platform').select( 'platform_id', 'platform', 'gateway_type', 'disabled').filter_by('platform', '==', platform) self.id = platform_query['platform_id'] self.name = platform_query['platform'] self.type = platform_query['gateway_type'] self.disabled = platform_query['disabled']
def proxy (request,format): """the view associated with /manifold/proxy/ with the query passed using POST""" # expecting a POST if request.method != 'POST': print "manifoldproxy.api: unexpected method %s -- exiting"%request.method return # we only support json for now # if needed in the future we should probably cater for # format_in : how is the query encoded in POST # format_out: how to serve the results if format != 'json': print "manifoldproxy.proxy: unexpected format %s -- exiting"%format return try: # translate incoming POST request into a query object if debug: print 'manifoldproxy.proxy: request.POST',request.POST manifold_query = Query() #manifold_query = ManifoldQuery() manifold_query.fill_from_POST(request.POST) # retrieve session for request # We allow some requests to use the ADMIN user account if (manifold_query.get_from() == 'local:user' and manifold_query.get_action() == 'create') \ or (manifold_query.get_from() == 'local:platform' and manifold_query.get_action() == 'get'): admin_user, admin_password = ConfigEngine().manifold_admin_user_password() manifold_api_session_auth = {'AuthMethod': 'password', 'Username': admin_user, 'AuthString': admin_password} else: print request.session['manifold'] manifold_api_session_auth = request.session['manifold']['auth'] if debug_empty and manifold_query.action.lower()=='get': json_answer=json.dumps({'code':0,'value':[]}) print "By-passing : debug_empty & 'get' request : returning a fake empty list" return HttpResponse (json_answer, mimetype="application/json") # actually forward manifold_api= ManifoldAPI(auth=manifold_api_session_auth) if debug: print '===> manifoldproxy.proxy: sending to backend', manifold_query # for the benefit of the python code, manifoldAPI raises an exception if something is wrong # however in this case we want to propagate the complete manifold result to the js world result = manifold_api.forward(manifold_query.to_dict()) # XXX TEMP HACK if 'description' in result and result['description'] \ and isinstance(result['description'], (tuple, list, set, frozenset)): result [ 'description' ] = [ ResultValue.to_html (x) for x in result['description'] ] json_answer=json.dumps(result) return HttpResponse (json_answer, mimetype="application/json") except Exception,e: print "** PROXY ERROR **",e import traceback traceback.print_exc()
def check(self): assert self.auth.has_key('session') query_sessions = Query.get('local:session').filter_by('session', '==', self.auth['session']) sessions = self.interface.execute_local_query(query_sessions) if not sessions: del self.auth['session'] raise AuthenticationFailure, "No such session: %s" % self.auth session = sessions[0] user_id = session['user_id'] try: query_users = Query.get('local:user').filter_by('user_id', '==', user_id) user, = self.interface.execute_local_query(query_users) except Exception, e: raise AuthenticationFailure, "No such user_id: %s" % e
def sfa_add_authority(request, authority_params): query = Query.create('authority').set(authority_params).select('authority_hrn') results = execute_query(request, query) print "sfa_add_auth results=",results if not results: raise Exception, "Could not create %s. Already exists ?" % authority_params['hrn'] return results
class SessionAuth(AuthMethod): """ Secondary authentication method. After authenticating with a primary authentication method, call GetSession() to generate a session key that may be used for subsequent calls. """ def check(self): assert self.auth.has_key('session') query_sessions = Query.get('local:session').filter_by('session', '==', self.auth['session']) sessions = self.interface.execute_local_query(query_sessions) if not sessions: del self.auth['session'] raise AuthenticationFailure, "No such session: %s" % self.auth session = sessions[0] user_id = session['user_id'] try: query_users = Query.get('local:user').filter_by('user_id', '==', user_id) user, = self.interface.execute_local_query(query_users) except Exception, e: raise AuthenticationFailure, "No such user_id: %s" % e if user and session['expires'] > time.time(): return user else: query_sessions = Query.delete('local:session').filter_by('session', '==', session['session']) try: self.interface.execute_local_query(query_sessions) except: pass raise AuthenticationFailure, "Invalid session"
def sfa_update_user(request, user_hrn, user_params): # user_params: keys [public_key] if 'email' in user_params: user_params['user_email'] = user_params['email'] query = Query.update('user').filter_by('user_hrn', '==', user_hrn).set(user_params).select('user_hrn') results = execute_query(request,query) return results
def get_platforms (self, request): username = self.request.user pf_query = Query().get('local:platform').filter_by('disabled', '==', '0').filter_by('gateway_type', '==', 'sfa').select('platform') res_platforms = execute_query(request, pf_query) platforms = [p['platform'] for p in res_platforms] return platforms
def main(): argc = len(sys.argv) if argc != 4: usage() sys.exit(1) email = sys.argv[1] config = sys.argv[2] status = sys.argv[3] password = getpass.getpass("Password: "******"$1$" password = password # Generate a somewhat unique 8 character salt string salt = str(time.time()) + str(Random().random()) salt = md5(salt).hexdigest()[:8] if len(password) <= len(magic) or password[0:len(magic)] != magic: password = crypt.crypt(password.encode('latin1'), magic + salt + "$") user_params = { 'email': email, 'password': password, 'config': config, 'status': status, } query = Query(action='create', object='local:user', params=user_params) # Instantiate a TopHat router with Router() as router: router.forward(query)
def manifold_add_platform(request, platform_params): query = Query.create('local:platform').set(platform_params).select(['user', 'platform']) results = execute_admin_query(request,query) if not results: raise Exception, "Failed creating manifold platform %s for user: %s" % (platform_params['platform'], platform_params['user']) result, = results return result['platform_id']
def manifold_add_account(request, account_params): query = Query.create('local:account').set(account_params).select(['user', 'platform']) results = execute_admin_query(request,query) if not results: raise Exception, "Failed creating manifold account on platform %s for user: %s" % (account_params['platform'], account_params['user']) result, = results return result['user_id']
def __init__ (self, platform_id, user_id): account_query = Query().get('local:account')\ .select('user_id','platform_id','auth_type','config')\ .filter_by('platform_id', '==', platform_id)\ .filter_by('user_id', '==', user_id) account_details = execute_query(self.request, account_query) self.user_id = account_details['user_id'] self.platform_id = account_details['platform_id'] self.auth_type = account_details['auth_type'] self.config = account_details['config'] account_config = json.loads(account_details['config']) self.usr_hrn = account_config.get('user_hrn',None) self.pub_key = account_config.get('user_public_key',None) self.reference = account_config.get ('reference_platform',None) self.user_cred = account_config.get('delegated_user_credential',None) self.user_cred_expiration = get_expiration(self.user_cred) slice_creds = account_config.get('delegated_slice_credentials',None) for slice_name, slice_cred in slice_creds.iteritems(): self.slice_cred_expiration = get_expiration(self.slice_cred) self.auth_cred = account_config.get('delegated_authority_credentials',None) self.auth_cred_expiration = get_expiration(self.auth_cred)
def get(self, request, state=None): env = {} pkey = None cert = None account_query = Query().get('local:account').select( 'user_id', 'platform_id', 'auth_type', 'config') account_details = execute_query(self.request, account_query) # Get the accounts of the current logged in user for account_detail in account_details: try: account_config = json.loads(account_detail['config']) if 'user_private_key' in account_config: pkey = account_config['user_private_key'] if 'gid' in account_config: cert = account_config['gid'] except ValueError as e: print('not a JSON') env['supername'] = 'Amira' env['cert'] = cert env['key'] = pkey if request.user.is_authenticated(): env['person'] = self.request.user env['username'] = self.request.user else: env['person'] = None env['username'] = None env['theme'] = self.theme env['section'] = "" return render_to_response(self.template_name, env, context_instance=RequestContext(request))
def __init__(self, allowed_capabilities = None): """ Create an Interface instance. Args: platforms: A list of Platforms. allowed_capabilities: A Capabilities instance or None """ # Register the list of Gateways Log.info("Registering gateways") register_gateways() # self.platforms is list(dict) where each dict describes a platform. # See platform table in the Storage. self.platforms = Storage.execute(Query().get("platform").filter_by("disabled", "=", False)) #, format = "object") # self.allowed_capabilities is a Capabilities instance (or None) self.allowed_capabilities = allowed_capabilities # self.data is {String : list(Announce)} dictionnary mapping each # platform name (= namespace) with its corresponding Announces. self.metadata = dict() # self.gateways is a {String : Gateway} which maps a platform name to # the appropriate Gateway instance. self.gateways = dict() self.policy = Policy(self) self.boot()
def load(self): Target.register_plugins() query_rules = Query.get('local:policy').select('policy_json') rules = self._interface.execute_local_query(query_rules) for rule in rules: self.rules.append(Rule.from_dict(json.loads(rule['policy_json'])))
def dispatch(request, action): results = [] error = None try: if request.method == 'POST': req_items = request.POST elif request.method == 'GET': req_items = request.GET for el in req_items.items(): if el[0].startswith('slice_hrn'): slice_hrn = el[1] elif el[0].startswith('initscript_code'): initscript_code = el[1] if (action == 'get'): # select initscript_code from initscript where slice_hrn=='onelab.upmc.express' query = Query.get('initscript').filter_by( 'slice_hrn', '==', slice_hrn).select('initscript_code') results = execute_admin_query(request, query) if (action == 'update'): # UPDATE initscript SET initscript_code='test3' where slice_hrn=='onelab.upmc.express' params = {'initscript_code': initscript_code} query = Query.update('initscript').filter_by( 'slice_hrn', '==', slice_hrn).set(params) results = execute_admin_query(request, query) if results[0]['initscript_code'] == 1: results[0]['initscript_code'] = initscript_code else: error = "Error in update return value" if (action == 'delete'): # delete from initscript where slice_hrn=='onelab.upmc.express' query = Query.delete('initscript').filter_by( 'slice_hrn', '==', slice_hrn) results = execute_admin_query(request, query) if results[0]['initscript_code'] == 1: results[0]['initscript_code'] = "" else: error = "Error in delete return value" except Exception, e: error = str(e)
def delete(self): query = Query.delete(self.type) query = self.applyFilters(query, True) if self.filters : query.set(self.filters) else: raise Exception, "Filters are required for delete" return execute_query(self.request, query)
def setLocalFields(self): query = Query.get('local:object').filter_by('table', '==', self.type).select('column.name') results = execute_query(self.request, query) if results : for r in results[0]['column'] : self.fields.append(r['name']) else : raise Exception, 'Manifold db error'
def sfa_add_user(request, user_params): if 'email' in user_params: user_params['user_email'] = user_params['email'] query = Query.create('user').set(user_params).select('user_hrn') results = execute_query(request, query) if not results: raise Exception, "Could not create %s. Already exists ?" % user_params['hrn'] return results
def manifold_add_user(request, user_params): # user_params: email, password e.g., user_params = {'email':'*****@*****.**','password':'******'} query = Query.create('local:user').set(user_params).select('email') results = execute_admin_query(request, query) if not results: raise Exception, "Failed creating manifold user: %s" % user_params['email'] result, = results return result['email']
def getUserAuthority(self, request): # Get user_email (XXX Would deserve to be simplified) user_query = Query().get('local:user').select('email', 'config') user_details = execute_query(request, user_query) for user_detail in user_details: user_config = json.loads(user_detail['config']) user_authority = user_config.get('authority', 'N/A') return user_authority
def get(self, request, state=None): env = self.default_env() email_list = [] status_list = [] authority_list = [] config = {} user_query = Query().get('local:user').select('email', 'status', 'config') user_details = execute_admin_query(self.request, user_query) for user in user_details: # get email email_list.append(user['email']) # get status if user['status'] == 0: user_status = 'Disabled' elif user['status'] == 1: user_status = 'Validation Pending' elif user['status'] == 2: user_status = 'Enabled' else: user_status = 'N/A' status_list.append(user_status) #get authority if user['config'] is not None: user_config = json.loads(user['config']) user_authority = user_config.get('authority', 'N/A') authority_list.append(user_authority) user_list = [{ 'email': t[0], 'status': t[1], 'authority': t[2] } for t in zip(email_list, status_list, authority_list)] if request.user.is_authenticated(): env['person'] = self.request.user else: env['person'] = None env['theme'] = self.theme env['user_list'] = user_list env['username'] = the_user(request) env['topmenu_items'] = topmenu_items(None, request) if state: env['state'] = state elif not env['username']: env['state'] = None # use one or two columns for the layout - not logged in users will see the login prompt env['layout_1_or_2'] = "layout-unfold2.html" if not env[ 'username'] else "layout-unfold1.html" return render_to_response(self.template, env, context_instance=RequestContext(request))
def authority_get_pi_emails(request, authority_hrn): #return ['*****@*****.**', '*****@*****.**'] pi_users = authority_get_pis(request,authority_hrn) pi_user_hrns = [ hrn for x in pi_users for hrn in x['pi_users'] ] query = Query.get('user').filter_by('user_hrn', 'included', pi_user_hrns).select('email') results = execute_query(request, query) print "mails", [result['email'] for result in results] return [result['email'] for result in results]
def get_query(self): """ \brief Returns the query representing the data produced by the nodes. \return query representing the data produced by the nodes. """ try: return self.query except: return Query()
def get(self): query = Query.get(self.type) if (self.id is not None) and (self.id not in self.fields) : query.select(self.fields + [self.id]) else : query.select(self.fields) query = self.applyFilters(query) return execute_query(self.request, query)
def get_platforms(request): ret = list() platform_query = Query().get('local:platform').filter_by( 'gateway_type', '==', 'sfa').filter_by('disabled', '==', 0).select('platform') platforms = execute_admin_query(request, platform_query) for p in platforms: ret.append(p['platform']) return ret
def check(self): # Method.type_check() should have checked that all of the # mandatory fields were present. assert self.auth.has_key('Username') # Get record (must be enabled) try: query_users = Query.get('local:user').filter_by('email', '==', self.auth['Username'].lower()) user, = self.interface.execute_local_query(query_users) except Exception, e: import traceback traceback.print_exc() Log.warning("Authentication failed, delete expired sessions") query_sessions = Query.delete('local:session').filter_by('expires', '<', int(time.time())) try: self.interface.execute_local_query(query_sessions) except: pass raise AuthenticationFailure, "No such account (PW): %s" % e
def manifold_update_user(request, email, user_params): # user_params: password, config e.g., query = Query.update('local:user').filter_by('email', '==', email).set(user_params).select('email') results = execute_admin_query(request,query) # NOTE: results remains empty and goes to Exception. However, it updates the manifold DB. # That's why I commented the exception part. -- Yasin #if not results: # raise Exception, "Failed updating manifold user: %s" % user_params['email'] #result, = results return results
def setKey(self): # What about key formed of multiple fields??? query = Query.get('local:object').filter_by('table', '==', self.type).select('key') results = execute_query(self.request, query) logger.debug("key of object = {}".format(results)) if results : for r in results[0]['key'] : self.id = r else : raise Exception, 'Manifold db error'
def authority_get_pis(request, authority_hrn): query = Query.get('authority').filter_by('authority_hrn', '==', authority_hrn).select('pi_users') results = execute_query(request, query) # NOTE: temporarily commented. Because results is giving empty list. # Needs more debugging #if not results: # raise Exception, "Authority not found: %s" % authority_hrn #result, = results #return result['pi_users'] return results
def create(self): query = Query.create(self.type) # No filters for create if self.params : for p in self.params : for k,v in p.iteritems() : logger.debug("param: {} : {}".format(k, v)) query.set({k : v}) logger.debug("query = {}".format(query)) else: raise Exception, "Params are required for create" return execute_query(self.request, query)
def createDatabase(request, slicename): result = {} Config = config(request) server = Config.get('influxdb', 'server') #port = Config.get('influxdb', 'port', 8086) port = 8086 user = Config.get('influxdb', 'user') password = Config.get('influxdb', 'password') dbname = slicename dbuser = request.user.username dbpassword = generatePassword() query = Query().get('user').filter_by('user_email', '==', dbuser).select('slices') slices = execute_query(request, query) if not slicename in slices: result['status'] = 'fail' result['message'] = 'no permissions' return HttpResponse(json.dumps(result), content_type="application/json") client = InfluxDBClient(server, port, user, password, dbname) try: client.create_database(dbname) except Exception as e: print e # Add database user try: client.add_database_user(dbuser, dbpassword) except Exception as e: print e # Make user a database admin client.set_database_admin(dbuser) # Insert an entry in the Influxdb table i = MeasurementsDB(backend='influxdb', server=server, port=port, dbname=dbname, dbuser=dbuser, dbpassword=dbpassword) i.save() result['status'] = 'ok' return HttpResponse(json.dumps(result), content_type="application/json")
def authenticate(self, token=None): if not token: return None try: username = token['username'] password = token['password'] request = token['request'] auth = {'AuthMethod': 'password', 'Username': username, 'AuthString': password} api = ManifoldAPI(auth) sessions_result = api.forward(Query.create('local:session').to_dict()) print "result" sessions = sessions_result.ok_value() print "ok" if not sessions: print "GetSession failed", sessions_result.error() return print "first", sessions session = sessions[0] # Change to session authentication api.auth = {'AuthMethod': 'session', 'session': session['session']} self.api = api # Get account details # the new API would expect Get('local:user') instead persons_result = api.forward(Query.get('local:user').to_dict()) persons = persons_result.ok_value() if not persons: print "GetPersons failed",persons_result.error() return person = persons[0] print "PERSON=", person request.session['manifold'] = {'auth': api.auth, 'person': person, 'expires': session['expires']} except ManifoldException, e: print "ManifoldBackend.authenticate caught ManifoldException, returning corresponding ManifoldResult" return e.manifold_result
def get(self, request, authority_hrn=None, state=None): env = self.default_env() if request.user.is_authenticated(): env['person'] = self.request.user if authority_hrn is None: # CACHE PB with fields page = Page(request) metadata = page.get_metadata() user_md = metadata.details_by_object('user') user_fields = [column['name'] for column in user_md['column']] # REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2 user_query = Query().get('myslice:user').select( user_fields).filter_by('user_hrn', '==', '$user_hrn') #user_query = Query().get('myslice:user').select('user_hrn','parent_authority').filter_by('user_hrn','==','$user_hrn') user_details = execute_query(self.request, user_query) try: env['user_details'] = user_details[0] except Exception, e: # If the Query fails, check in local DB try: user_local_query = Query().get('local:user').select( 'config').filter_by('email', '==', str(env['person'])) user_local_details = execute_query( self.request, user_local_query) user_local = user_local_details[0] user_local_config = user_local['config'] user_local_config = json.loads(user_local_config) user_local_authority = user_local_config.get( 'authority') if 'user_details' not in env or 'parent_authority' not in env[ 'user_details'] or env['user_details'][ 'parent_authority'] is None: env['user_details'] = { 'parent_authority': user_local_authority } except Exception, e: env['error'] = "Please check your Credentials"
def getUserHrn(self, request): user_hrn = None account_query = Query().get('local:account').select( 'user_id', 'platform_id', 'auth_type', 'config') account_details = execute_query(request, account_query) platform_query = Query().get('local:platform').select( 'platform_id', 'platform', 'gateway_type', 'disabled') platform_details = execute_query(request, platform_query) # getting user_hrn from local:account for account_detail in account_details: for platform_detail in platform_details: if platform_detail['platform_id'] == account_detail[ 'platform_id']: # taking user_hrn only from myslice account # NOTE: we should later handle accounts filter_by auth_type= managed OR user if 'myslice' in platform_detail['platform']: account_config = json.loads(account_detail['config']) user_hrn = account_config.get('user_hrn', 'N/A') return user_hrn
def perform_subquery(self, allowed_platforms, dbgraph, user, query_plan): """ Connect a new AST to the current AST using a SubQuery Node. If the connected table is "on join", we will use a LeftJoin and a CrossProduct Node instead. Args: dbgraph: The DBGraph instance related to the 3nf graph. allowed_platforms: A set of String where each String correponds to a queried platform name. user: The User issuing the Query. query_plan: The QueryPlan instance related to this Query, and that we're updating. """ # We need to build an AST just to collect subqueries #OBSOLETE| # XXX dbgraph not defined #OBSOLETE| #if not self.ast: #OBSOLETE| # self.ast = self.build_union(self.root, self.keep_root_a, dbgraph, user) #OBSOLETE| if not self.ast: #OBSOLETE| fields = set() #OBSOLETE| for _, (_, relation) in self.subqueries.items(): #OBSOLETE| fields |= relation.get_predicate().get_field_names() #OBSOLETE| self.ast = self.build_union(self.root, fields, allowed_platforms, dbgraph, user, query_plan) if not self.ast: self.perform_union_all(self.root, allowed_platforms, dbgraph, user, query_plan) if self.root.capabilities.is_onjoin(): # Let's identify tables involved in the key root_key_fields = self.root.keys.one().get_field_names() xp_ast_relation, sq_ast_relation = [], [] xp_key = () xp_value = () for name, ast_relation in self.subqueries.items(): if name in root_key_fields: ast, relation = ast_relation key, _, value = relation.get_predicate().get_tuple() xp_key += (value, ) xp_value += (key, ) xp_ast_relation.append(ast_relation) else: sq_ast_relation.append(ast_relation) ast = self.ast if sq_ast_relation: ast.subquery(sq_ast_relation) query = Query.action('get', self.root.get_name()).select(set(xp_key)) self.ast = AST().cross_product(xp_ast_relation, query) predicate = Predicate(xp_key, eq, xp_value) self.ast.left_join(ast, predicate) else: self.ast.subquery(self.subqueries.values())
def topmenu_items_live(current, page): request = page.request query_pi_auths = Query.get("user").filter_by("user_hrn", "==", "$user_hrn").select("pi_authorities") page.enqueue_query(query_pi_auths) # # even though this plugin does not have any html materialization, the corresponding domid # # must exist because it is searched at init-time to create the JS plugin # # so we simply piggy-back the target button created in the topmenu topmenuvalidation = TopmenuValidation( page=page, # see above domid="topmenu-validation", query=query_pi_auths, # this one is the target for a $.show() when the query comes back button_domid="topmenu-validation", ) # although the result does not matter, rendering is required for the JS init code to make it in the page topmenuvalidation.render(request) return topmenu_items_static(current, request)
def sfa_add_slice(request, slice_params): query = Query.create('slice').set(slice_params).select('slice_hrn') results = execute_query(request, query) if not results: raise Exception, "Could not create %s. Already exists ?" % slice_params['hrn'] return results
def get_or_post (self, request, method): errors = [] # Using cache manifold-tables to get the list of authorities faster authorities_query = Query.get('authority').select('name', 'authority_hrn') #onelab_enabled_query = Query.get('local:platform').filter_by('platform', '==', 'ple').filter_by('disabled', '==', 'False') #onelab_enabled = not not execute_admin_query(request, onelab_enabled_query) #if onelab_enabled: if True: print "ONELAB ENABLED" #authorities_query = Query.get('ple:authority').select('name', 'authority_hrn').filter_by('authority_hrn', 'included', ['ple.inria', 'ple.upmc', 'ple.ibbtple', 'ple.nitos']) # Now using Cache else: print "FIREXP ENABLED" authorities = execute_admin_query(request, authorities_query) if authorities is not None: authorities = sorted(authorities) # xxx tocheck - if authorities is empty, it's no use anyway # (users won't be able to validate the form anyway) page = Page(request) page.add_js_files ( [ "js/jquery.validate.js", "js/my_account.register.js" ] ) page.add_css_files ( [ "css/onelab.css", "css/registration.css" ] ) page.add_css_files ( [ "http://code.jquery.com/ui/1.10.3/themes/smoothness/jquery-ui.css" ] ) print 'registration view, method',method user_query = Query().get('local:user').select('user_id','email') user_details = execute_admin_query(self.request, user_query) if method == 'POST': # We shall use a form here #get_email = PendingUser.objects.get(email) reg_fname = request.POST.get('firstname', '') reg_lname = request.POST.get('lastname', '') #reg_aff = request.POST.get('affiliation','') reg_auth = request.POST.get('authority_hrn', '') #reg_login = request.POST.get('login', '') reg_email = request.POST.get('email','').lower() #prepare user_hrn split_email = reg_email.split("@")[0] split_email = split_email.replace(".", "_") user_hrn = reg_auth + '.' + split_email+ str(randint(1,1000000)) UserModel = get_user_model() #POST value validation if (re.search(r'^[\w+\s.@+-]+$', reg_fname)==None): errors.append('First Name may contain only letters, numbers, spaces and @/./+/-/_ characters.') if (re.search(r'^[\w+\s.@+-]+$', reg_lname) == None): errors.append('Last Name may contain only letters, numbers, spaces and @/./+/-/_ characters.') # checking in django_db !! if PendingUser.objects.filter(email__iexact=reg_email): errors.append('Email is pending for validation. Please provide a new email address.') if UserModel._default_manager.filter(email__iexact=reg_email): errors.append('This email is not usable. Please contact the administrator or try with another email.') for user_detail in user_details: if user_detail['email']==reg_email: errors.append('Email already registered in Manifold. Please provide a new email address.') # XXX TODO: Factorize with portal/accountview.py if 'generate' in request.POST['question']: from Crypto.PublicKey import RSA private = RSA.generate(1024) private_key = json.dumps(private.exportKey()) public = private.publickey() public_key = json.dumps(public.exportKey(format='OpenSSH')) # # Generate public and private keys using SFA Library # from sfa.trust.certificate import Keypair # k = Keypair(create=True) # public_key = k.get_pubkey_string() # private_key = k.as_pem() # private_key = ''.join(private_key.split()) # public_key = "ssh-rsa " + public_key # Saving to DB account_config = '{"user_public_key":'+ public_key + ', "user_private_key":'+ private_key + ', "user_hrn":"'+ user_hrn + '"}' auth_type = 'managed' #keypair = re.sub("\r", "", keypair) #keypair = re.sub("\n", "\\n", keypair) #keypair = keypair.rstrip('\r\n') #keypair = ''.join(keypair.split()) #for sending email: removing existing double qoute public_key = public_key.replace('"', ''); else: up_file = request.FILES['user_public_key'] file_content = up_file.read() file_name = up_file.name file_extension = os.path.splitext(file_name)[1] allowed_extension = ['.pub','.txt'] if file_extension in allowed_extension and re.search(r'ssh-rsa',file_content): account_config = '{"user_public_key":"'+ file_content + '", "user_hrn":"'+ user_hrn +'"}' account_config = re.sub("\r", "", account_config) account_config = re.sub("\n", "\\n",account_config) account_config = ''.join(account_config.split()) auth_type = 'user' # for sending email public_key = file_content public_key = ''.join(public_key.split()) else: errors.append('Please upload a valid RSA public key.') #b = PendingUser(first_name=reg_fname, last_name=reg_lname, affiliation=reg_aff, # email=reg_email, password=request.POST['password'], keypair=keypair) #b.save() #saving to django db 'portal_pendinguser' table if not errors: b = PendingUser( first_name = reg_fname, last_name = reg_lname, #affiliation = reg_aff, authority_hrn = reg_auth, #login = reg_login, email = reg_email, password = request.POST['password'], keypair = account_config, pi = '', ) b.save() # saves the user to django auth_user table [needed for password reset] user = User.objects.create_user(reg_email, reg_email, request.POST['password']) #creating user to manifold local:user user_config = '{"firstname":"'+ reg_fname + '", "lastname":"'+ reg_lname + '", "authority":"'+ reg_auth + '"}' user_params = {'email': reg_email, 'password': request.POST['password'], 'config': user_config, 'status': 1} manifold_add_user(request,user_params) #creating local:account in manifold user_id = user_detail['user_id']+1 # the user_id for the newly created user in local:user account_params = {'platform_id': 5, 'user_id': user_id, 'auth_type': auth_type, 'config': account_config} manifold_add_account(request,account_params) # Send email ctx = { 'first_name' : reg_fname, 'last_name' : reg_lname, 'authority_hrn' : reg_auth, 'email' : reg_email, 'user_hrn' : user_hrn, 'public_key' : public_key, } recipients = authority_get_pi_emails(request,reg_auth) # backup email: if authority_get_pi_emails fails recipients.append('*****@*****.**') msg = render_to_string('user_request_email.txt', ctx) send_mail("Onelab New User request for %s submitted"%reg_email, msg, '*****@*****.**', recipients) return render(request, 'user_register_complete.html') template_env = { 'topmenu_items': topmenu_items_live('Register', page), 'errors': errors, 'firstname': request.POST.get('firstname', ''), 'lastname': request.POST.get('lastname', ''), #'affiliation': request.POST.get('affiliation', ''), 'authority_hrn': request.POST.get('authority_hrn', ''), 'email': request.POST.get('email', ''), 'password': request.POST.get('password', ''), 'authorities': authorities, } template_env.update(page.prelude_env ()) return render(request, 'registration_view.html',template_env)
def dashboard_view(request): page = Page(request) slices_query = Query.get("slice").select("slice_hrn") # old# # xxx filter : should filter on the slices the logged user can see # old# # we don't have the user's hrn yet # old# # in addition this currently returns all slices anyways # old# # filter = ... # old# sort='slice_hrn',) page.enqueue_query(slices_query) main_plugin = Stack( page=page, title="Putting stuff together", sons=[ QueryCode(page=page, title="Vizualize your query", query=slices_query, toggled=False), QuickFilter( # we play with this one for demo purposes in dashboard.css domid="myquickfilter", page=page, title="play with filters", criterias=quickfilter_criterias, toggled=False, ), SliceList( # setting visible attributes first page=page, title="Asynchroneous SliceList", header="slices list", with_datatables=False, # this is the query at the core of the slice list query=slices_query, ), ], ) # variables that will get passed to the view-unfold2.html template template_env = {} # define 'unfold_main' to the template engine template_env["unfold_main"] = main_plugin.render(request) # more general variables expected in the template template_env["title"] = "Test view for a full request cycle" # the menu items on the top template_env["topmenu_items"] = topmenu_items_live("dashboard", page) # so we can sho who is logged template_env["username"] = the_user(request) # ########## add another plugin with the same request, on the RHS pane # will show up in the right-hand side area named 'related' related_plugin = SliceList( page=page, title="Same request, other layout", domid="sidelist", with_datatables=True, header="paginated slices", # share the query query=slices_query, ) # likewise but on the side view template_env["unfold_margin"] = related_plugin.render(request) # add our own css in the mix # page.add_css_files ( 'css/dashboard.css') # the prelude object in page contains a summary of the requirements() for all plugins # define {js,css}_{files,chunks} prelude_env = page.prelude_env() template_env.update(prelude_env) return render_to_response("view-unfold2.html", template_env, context_instance=RequestContext(request))
def get_context_data(self, **kwargs): page = Page(self.request) page.add_js_files ( [ "js/common.functions.js" ] ) for key, value in kwargs.iteritems(): print "%s = %s" % (key, value) if key == "platformname": platformname=value network_query = Query().get('local:platform')\ .filter_by('platform', '==', platformname)\ .select('platform','platform_longname','gateway_type') page.enqueue_query(network_query) # ListResources of the platform metadata = page.get_metadata() resource_md = metadata.details_by_object('resource') resource_fields = [column['name'] for column in resource_md['column']] resources = platformname + ':resource' query_resource_all = Query.get(resources).select(resource_fields) page.enqueue_query(query_resource_all) query_resource_default_fields = Query.get(resources).select('hrn','hostname', 'type','country') page.enqueue_query(query_resource_default_fields) page.expose_js_metadata() networklist = QueryTable( page = page, title = 'List', domid = 'checkboxes', # this is the query at the core of the slice list query = network_query, query_all = network_query, checkboxes = False, datatables_options = { 'iDisplayLength' : 25, 'bLengthChange' : True, }, ) # networklist = SimpleList( # title = None, # page = page, # key = 'platform', # query = network_query, # ) # # -------------------------------------------------------------------------- # RESOURCES # for internal use in the querytable plugin; # needs to be a unique column present for each returned record main_query_init_key = 'hrn' # the resources part is made of a Tabs (Geographic, List), resources_as_gmap = GoogleMap( page = page, title = 'Geographic view', domid = 'resources-map', # tab's sons preferably turn this off togglable = False, query = query_resource_default_fields, query_all = query_resource_all, # this key is the one issued by google googlemap_api_key = ConfigEngine().googlemap_api_key(), # the key to use at init-time init_key = main_query_init_key, checkboxes = False, # center on Paris latitude = 49., longitude = 9, zoom = 4, ) resources_as_3dmap = SensLabMap( page = page, title = '3D Map', domid = 'senslabmap', query = query_resource_default_fields, query_all = query_resource_all, ) resources_as_list = QueryTable( page = page, domid = 'resources-list', title = 'List view', # this is the query at the core of the slice list query = query_resource_default_fields, query_all = query_resource_all, init_key = main_query_init_key, checkboxes = False, datatables_options = { 'iDisplayLength': 25, 'bLengthChange' : True, 'bAutoWidth' : True, }, ) resources_sons = [ resources_as_gmap, resources_as_3dmap, resources_as_list, ] resources_area = Tabs ( page=page, domid="resources", togglable=True, title="Resources", outline_complete=True, sons= resources_sons, active_domid = 'resources-map', persistent_active=True, ) context = super(PlatformView, self).get_context_data(**kwargs) context['person'] = self.request.user context['networks'] = networklist.render(self.request) context['resources'] = resources_area.render(self.request) # XXX This is repeated in all pages # more general variables expected in the template context['title'] = 'Platforms connected to MySlice' # the menu items on the top context['topmenu_items'] = topmenu_items_live('Platforms', page) # so we can sho who is logged context['username'] = the_user(self.request) context.update(page.prelude_env()) return context
def get_or_post (self, request, method): # Using cache manifold-tables to get the list of authorities faster authorities_query = Query.get('authority').select('name', 'authority_hrn') authorities = execute_admin_query(request, authorities_query) if authorities is not None: authorities = sorted(authorities) user_query = Query().get('local:user').select('email') user_email = execute_query(self.request, user_query) self.user_email = user_email[0].get('email') account_query = Query().get('local:account').select('user_id','platform_id','auth_type','config') account_details = execute_query(self.request, account_query) platform_query = Query().get('local:platform').select('platform_id','platform','gateway_type','disabled') platform_details = execute_query(self.request, platform_query) # getting user_hrn from local:account for account_detail in account_details: for platform_detail in platform_details: if platform_detail['platform_id'] == account_detail['platform_id']: # taking user_hrn only from myslice account # NOTE: we should later handle accounts filter_by auth_type= managed OR user if 'myslice' in platform_detail['platform']: account_config = json.loads(account_detail['config']) user_hrn = account_config.get('user_hrn','N/A') #user_query = Query().get('user').select('user_hrn').filter_by('user_hrn','==','$user_hrn') #user_hrn = execute_query(self.request, user_query) #self.user_hrn = user_hrn[0].get('user_hrn') page = Page(request) page.add_css_files ( [ "http://code.jquery.com/ui/1.10.3/themes/smoothness/jquery-ui.css" ] ) if method == 'POST': self.errors = [] # The form has been submitted slice_name = request.POST.get('slice_name', '') authority_hrn = request.POST.get('authority_hrn', '') number_of_nodes = request.POST.get('number_of_nodes', '') purpose = request.POST.get('purpose', '') email = self.user_email #user_hrn = user_hrn cc_myself = True if (authority_hrn is None or authority_hrn == ''): self.errors.append('Please, select an authority') # What kind of slice name is valid? if (slice_name is None or slice_name == ''): self.errors.append('Slice Name is mandatory') if (purpose is None or purpose == ''): self.errors.append('Purpose is mandatory') if not self.errors: ctx = { 'email': email, 'slice_name': slice_name, 'authority_hrn': authority_hrn, 'number_of_nodes': number_of_nodes, 'purpose': purpose, } s = PendingSlice( slice_name = slice_name, user_hrn = user_hrn, authority_hrn = authority_hrn, number_of_nodes = number_of_nodes, purpose = purpose ) s.save() # The recipients are the PI of the authority recipients = authority_get_pi_emails(request, authority_hrn) #if cc_myself: recipients.append('*****@*****.**') msg = render_to_string('slice-request-email.txt', ctx) #print "email, msg, email, recipients", email , msg, email, recipients send_mail("Onelab user %s requested a slice"%email , msg, email, recipients) return render(request,'slice-request-ack-view.html') # Redirect after POST template_env = { 'topmenu_items': topmenu_items_live('Request a slice', page), 'errors': self.errors, 'slice_name': request.POST.get('slice_name', ''), 'authority_hrn': request.POST.get('authority_hrn', ''), 'number_of_nodes': request.POST.get('number_of_nodes', ''), 'purpose': request.POST.get('purpose', ''), 'email': self.user_email, 'user_hrn': user_hrn, 'cc_myself': True, 'authorities': authorities, } template_env.update(page.prelude_env ()) return render(request, 'slicerequest_view.html',template_env)
def manifold_delete_account(request, platform_id, user_id, account_params): query = Query.delete('local:account').filter_by('platform_id', '==', platform_id).filter_by('user_id', '==', user_id).set(account_params).select('user_id') results = execute_admin_query(request,query) return results
def get (self,request, slicename=tmp_default_slice): page = Page(request) page.add_css_files ('css/slice-view.css') page.add_js_files ( [ "js/common.functions.js" ] ) page.add_js_chunks ('$(function() { messages.debug("sliceview: jQuery version " + $.fn.jquery); });') page.add_js_chunks ('$(function() { messages.debug("sliceview: users turned %s"); });'%("on" if do_query_users else "off")) page.add_js_chunks ('$(function() { messages.debug("sliceview: leases turned %s"); });'%("on" if do_query_leases else "off")) page.add_js_chunks ('$(function() { messages.debug("manifold URL %s"); });'%(ConfigEngine().manifold_url())) metadata = page.get_metadata() resource_md = metadata.details_by_object('resource') resource_fields = [column['name'] for column in resource_md['column']] user_md = metadata.details_by_object('user') user_fields = ['user_hrn'] # [column['name'] for column in user_md['column']] # TODO The query to run is embedded in the URL main_query = Query.get('slice').filter_by('slice_hrn', '=', slicename) main_query.select( 'slice_hrn', #'resource.hrn', 'resource.urn', 'resource.hostname', 'resource.type', 'resource.network_hrn', 'lease.urn', 'user.user_hrn', #'application.measurement_point.counter' ) # for internal use in the querytable plugin; # needs to be a unique column present for each returned record main_query_init_key = 'hostname' query_resource_all = Query.get('resource').select(resource_fields) aq = AnalyzedQuery(main_query, metadata=metadata) page.enqueue_query(main_query, analyzed_query=aq) page.enqueue_query(query_resource_all) if do_query_users: # Required: the user must have an authority in its user.config # XXX Temporary solution user_query = Query().get('local:user').select('config','email') user_details = execute_query(self.request, user_query) # not always found in user_details... config={} # for user_detail in user_details: # #email = user_detail['email'] # if user_detail['config']: # config = json.loads(user_detail['config']) # user_detail['authority'] = config.get('authority',"Unknown Authority") # # if user_detail['authority'] is not None: # sub_authority = user_detail['authority'].split('.') # root_authority = sub_authority[0] # query_user_all = Query.get(root_authority+':user').select(user_fields) # # # XXX TODO this filter doesn't work - to be improved in Manifold # #.filter_by('authority.authority_hrn', '=', user_detail['authority']) # # page.enqueue_query(query_user_all) # else: # print "authority of the user is not in local:user db" query_user_all = Query.get('user').select(user_fields) # query_user_all = None # ... and for the relations # XXX Let's hardcode resources for now sq_resource = aq.subquery('resource') sq_user = aq.subquery('user') sq_lease = aq.subquery('lease') sq_measurement = aq.subquery('measurement') # Prepare the display according to all metadata # (some parts will be pending, others can be triggered by users). # # For example slice measurements will not be requested by default... # Create the base layout (Stack)... main_stack = Stack ( page=page, title="Slice %s"%slicename, sons=[], ) # ... responsible for the slice properties... # a nice header main_stack.insert ( Raw (page=page, togglable=False, toggled=True, html="<h2 class='well well-lg'> Slice %s</h2>"%slicename) ) # -------------------------------------------------------------------------- # QueryUpdater (Pending Operations) main_stack.insert(QueryUpdater( page = page, title = 'Pending operations', query = main_query, togglable = True, # start turned off, it will open up itself when stuff comes in toggled = False, domid = 'pending', outline_complete = True, )) # -------------------------------------------------------------------------- # Filter Resources # turn off for now -- see above filter_query_editor = QueryEditor( page = page, query = sq_resource, query_all = query_resource_all, title = "Select Columns", domid = 'select-columns', ) filter_active_filters = ActiveFilters( page = page, query = sq_resource, title = "Active Filters", ) filters_area = Stack( page = page, title = 'Filter Resources', domid = 'filters', sons = [filter_query_editor, filter_active_filters], togglable = True, toggled = 'persistent', outline_complete = True, ) main_stack.insert (filters_area) # -------------------------------------------------------------------------- # RESOURCES # the resources part is made of a Tabs (Geographic, List), resources_as_gmap = GoogleMap( page = page, title = 'Geographic view', domid = 'resources-map', # tab's sons preferably turn this off togglable = False, query = sq_resource, query_all = query_resource_all, # this key is the one issued by google googlemap_api_key = ConfigEngine().googlemap_api_key(), # the key to use at init-time init_key = main_query_init_key, checkboxes = True, # center on Paris latitude = 49., longitude = 9, zoom = 4, ) resources_as_3dmap = SensLabMap( page = page, title = '3D Map', domid = 'senslabmap', query = sq_resource, query_all = query_resource_all, ) resources_as_list = QueryTable( page = page, domid = 'resources-list', title = 'List view', # this is the query at the core of the slice list query = sq_resource, query_all = query_resource_all, init_key = main_query_init_key, checkboxes = True, datatables_options = { 'iDisplayLength': 25, 'bLengthChange' : True, 'bAutoWidth' : True, }, ) if insert_grid: resources_as_grid = QueryGrid( page = page, domid = 'resources-grid', title = 'Grid view', # this is the query at the core of the slice list query = sq_resource, query_all = query_resource_all, init_key = main_query_init_key, checkboxes = True, ) #if do_query_leases: # resources_as_scheduler = Scheduler( # page = page, # title = 'Scheduler', # domid = 'scheduler', # query = sq_resource, # query_all_resources = query_resource_all, # query_lease = sq_lease, # ) resources_as_scheduler2 = Scheduler2( page = page, domid = 'scheduler', title = 'Scheduler', # this is the query at the core of the slice list query = sq_resource, query_all_resources = query_resource_all, query_lease = sq_lease, ) # with the new 'Filter' stuff on top, no need for anything but the querytable resources_as_list_area = resources_as_list resources_sons = [ resources_as_gmap, resources_as_3dmap, resources_as_scheduler2, resources_as_list_area, ] if do_query_leases else [ resources_as_gmap, resources_as_3dmap, resources_as_list_area, resources_as_scheduler2, ] if insert_grid: resources_sons.append(resources_as_grid) resources_area = Tabs ( page=page, domid="resources", togglable=True, title="Resources", outline_complete=True, sons= resources_sons, active_domid = 'scheduler', persistent_active=True, ) main_stack.insert (resources_area) # -------------------------------------------------------------------------- # USERS if do_query_users and query_user_all is not None: tab_users = Tabs( page = page, domid = 'users', outline_complete = True, togglable = True, title = 'Users', active_domid = 'users-list', ) main_stack.insert(tab_users) tab_users.insert(QueryTable( page = page, title = 'Users List', domid = 'users-list', # tab's sons preferably turn this off togglable = False, # this is the query at the core of the slice list query = sq_user, query_all = query_user_all, checkboxes = True, datatables_options = { 'iDisplayLength' : 25, 'bLengthChange' : True, 'bAutoWidth' : True, }, )) # DEMO # -------------------------------------------------------------------------- # MEASUREMENTS measurements_stats_cpu = SliceStat( title = "CPU Usage", domid = 'resources-stats-cpu', page = page, stats = 'slice', key = 'hrn', query = 'none', slicename = slicename, o = 'cpu' ) measurements_stats_mem = SliceStat( title = "Memory Usage", domid = 'resources-stats-mem', page = page, stats = 'slice', key = 'hrn', query = 'none', slicename = slicename, o = 'mem' ) measurements_stats_asb = SliceStat( title = "Traffic Sent", domid = 'resources-stats-asb', page = page, stats = 'slice', key = 'hrn', query = 'none', slicename = slicename, o = 'asb' ) measurements_stats_arb = SliceStat( title = "Traffic Received", domid = 'resources-stats-arb', page = page, stats = 'slice', key = 'hrn', query = 'none', slicename = slicename, o = 'arb' ) tab_measurements = Tabs ( page=page, domid = "measurements", togglable = True, toggled = 'persistent', title = "Measurements", outline_complete=True, sons = [ measurements_stats_cpu, measurements_stats_mem, measurements_stats_asb, measurements_stats_arb ], active_domid = 'resources-stats-cpu', persistent_active = True, ) main_stack.insert (tab_measurements) # tab_measurements = Tabs ( # page = page, # active_domid = 'measurements-list', # outline_complete = True, # togglable = True, # title = 'Measurements', # domid = 'measurements', # ) # main_stack.insert(tab_measurements) # # tab_measurements.insert(QueryTable( # page = page, # title = 'Measurements', # domid = 'measurements-list', # # tab's sons preferably turn this off # togglable = False, # # this is the query at the core of the slice list # query = sq_measurement, # # do NOT set checkboxes to False # # this table being otherwise empty, it just does not fly with dataTables # checkboxes = True, # datatables_options = { # 'iDisplayLength' : 25, # 'bLengthChange' : True, # 'bAutoWidth' : True, # }, # )) # # # -------------------------------------------------------------------------- # # MESSAGES (we use transient=False for now) if insert_messages: main_stack.insert(Messages( page = page, title = "Runtime messages for slice %s"%slicename, domid = "msgs-pre", levels = "ALL", # plain messages are probably less nice for production but more reliable for development for now transient = False, # these make sense only in non-transient mode.. togglable = True, toggled = 'persistent', outline_complete = True, )) # variables that will get passed to the view-unfold1.html template template_env = {} # define 'unfold_main' to the template engine - the main contents template_env [ 'unfold_main' ] = main_stack.render(request) # more general variables expected in the template template_env [ 'title' ] = '%(slicename)s'%locals() # the menu items on the top template_env [ 'topmenu_items' ] = topmenu_items_live('Slice', page) # so we can sho who is logged template_env [ 'username' ] = the_user (request) # don't forget to run the requests page.expose_js_metadata() # the prelude object in page contains a summary of the requirements() for all plugins # define {js,css}_{files,chunks} template_env.update(page.prelude_env()) return render_to_response ('view-unfold1.html',template_env, context_instance=RequestContext(request))
def manifold_update_account(request,user_id,account_params): # account_params: config query = Query.update('local:account').filter_by('platform', '==', 'myslice').filter_by('user_id', '==', user_id).set(account_params).select('user_id') results = execute_admin_query(request,query) return results
def get_or_post(self, request, method): errors = [] # List authorities already in the Registry in order to avoid duplicates # Using cache manifold-tables to get the list of authorities faster authorities_query = Query.get("authority").select("name", "authority_hrn") authorities = execute_admin_query(request, authorities_query) if authorities is not None: authorities = sorted(authorities) root_authorities = sorted([a for a in authorities if "." not in a["authority_hrn"]]) page = Page(request) page.add_js_files(["js/jquery.validate.js", "js/join.js"]) page.add_css_files(["css/onelab.css", "css/registration.css"]) page.add_css_files(["http://code.jquery.com/ui/1.10.3/themes/smoothness/jquery-ui.css"]) if method == "POST": # xxx tocheck - if authorities is empty, it's no use anyway # (users won't be able to validate the form anyway) # List local users in Manifold DB in order ot avoid duplicates user_query = Query().get("local:user").select("user_id", "email") list_users = execute_admin_query(self.request, user_query) reg_root_authority_hrn = request.POST.get("root_authority_hrn", "").lower() reg_site_name = request.POST.get("site_name", "") reg_site_authority = request.POST.get("site_authority", "").lower() reg_site_abbreviated_name = request.POST.get("site_abbreviated_name", "") reg_site_url = request.POST.get("site_url", "") reg_site_latitude = request.POST.get("site_latitude", "") reg_site_longitude = request.POST.get("site_longitude", "") reg_fname = request.POST.get("pi_first_name", "") reg_lname = request.POST.get("pi_last_name", "") reg_auth = reg_root_authority_hrn + "." + reg_site_authority reg_email = request.POST.get("pi_email", "").lower() reg_phone = request.POST.get("pi_phone", "") # prepare user_hrn split_email = reg_email.split("@")[0] split_email = split_email.replace(".", "_") user_hrn = reg_auth + "." + split_email + str(randint(1, 1000000)) UserModel = get_user_model() reg_address_line1 = request.POST.get("address_line1", "") reg_address_line2 = request.POST.get("address_line2", "") reg_address_line3 = request.POST.get("address_line3", "") reg_address_city = request.POST.get("address_city", "") reg_address_postalcode = request.POST.get("address_postalcode", "") reg_address_state = request.POST.get("address_state", "") reg_address_country = request.POST.get("address_country", "") # POST value validation if re.search(r"^[\w+\s.@+-]+$", reg_fname) == None: errors.append("First Name may contain only letters, numbers, spaces and @/./+/-/_ characters.") if re.search(r"^[\w+\s.@+-]+$", reg_lname) == None: errors.append("Last Name may contain only letters, numbers, spaces and @/./+/-/_ characters.") if re.search(r"^\w+$", reg_site_authority) == None: errors.append("Site Authority may contain only letters or numbers.") # checking in django_db !! if PendingUser.objects.filter(email__iexact=reg_email): errors.append("Email is pending for validation. Please provide a new email address.") if PendingAuthority.objects.filter(site_authority__iexact=reg_auth): errors.append("This site is pending for validation.") if PendingAuthority.objects.filter(site_name__iexact=reg_site_name): errors.append("This site is pending for validation.") if UserModel._default_manager.filter(email__iexact=reg_email): errors.append("This email is not usable. Please contact the administrator or try with another email.") for user_detail in list_users: if user_detail["email"] == reg_email: errors.append("Email already registered in Manifold. Please provide a new email address.") # XXX TODO: Factorize with portal/accountview.py # if 'generate' in request.POST['question']: from Crypto.PublicKey import RSA private = RSA.generate(1024) private_key = json.dumps(private.exportKey()) public = private.publickey() public_key = json.dumps(public.exportKey(format="OpenSSH")) # Saving to DB account_config = ( '{"user_public_key":' + public_key + ', "user_private_key":' + private_key + ', "user_hrn":"' + user_hrn + '"}' ) auth_type = "managed" public_key = public_key.replace('"', "") if not errors: reg_password = request.POST["pi_password"] a = PendingAuthority( site_name=reg_site_name, site_authority=reg_root_authority_hrn + "." + reg_site_authority, site_abbreviated_name=reg_site_abbreviated_name, site_url=reg_site_url, site_latitude=reg_site_latitude, site_longitude=reg_site_longitude, address_line1=reg_address_line1, address_line2=reg_address_line2, address_line3=reg_address_line3, address_city=reg_address_city, address_postalcode=reg_address_postalcode, address_state=reg_address_state, address_country=reg_address_country, authority_hrn=reg_root_authority_hrn, ) a.save() reg_password = request.POST["pi_password"] b = PendingUser( first_name=reg_fname, last_name=reg_lname, authority_hrn=reg_auth, email=reg_email, password=reg_password, keypair=account_config, pi=reg_auth, ) b.save() # saves the user to django auth_user table [needed for password reset] user = User.objects.create_user(reg_email, reg_email, reg_password) # creating user to manifold local:user user_config = ( '{"firstname":"' + reg_fname + '", "lastname":"' + reg_lname + '", "authority":"' + reg_auth + '"}' ) user_params = {"email": reg_email, "password": reg_password, "config": user_config, "status": 1} manifold_add_user(request, user_params) # creating local:account in manifold user_id = user_detail["user_id"] + 1 # the user_id for the newly created user in local:user account_params = { "platform_id": 5, "user_id": user_id, "auth_type": auth_type, "config": account_config, } manifold_add_account(request, account_params) # Send email ctx = { "first_name": reg_fname, "last_name": reg_lname, "authority_hrn": reg_auth, "email": reg_email, "user_hrn": user_hrn, "public_key": public_key, } recipients = authority_get_pi_emails(request, reg_auth) # We don't need to send this email to user. # it's for the PI only # if ctx['cc_myself']: # recipients.append(ctx['email']) msg = render_to_string("user_request_email.txt", ctx) send_mail( "Onelab New Authority request for %s submitted" % reg_email, msg, "*****@*****.**", recipients ) return render(request, "user_register_complete.html") template_env = { "topmenu_items": topmenu_items_live("join", page), "errors": errors, "pi_first_name": request.POST.get("pi_first_name", ""), "pi_last_name": request.POST.get("pi_last_name", ""), "pi_email": request.POST.get("pi_email", ""), "pi_phone": request.POST.get("pi_phone", ""), "pi_password": request.POST.get("pi_password", ""), "site_name": request.POST.get("site_name", ""), "site_authority": request.POST.get("site_authority", "").lower(), "site_abbreviated_name": request.POST.get("site_abbreviated_name", ""), "site_url": request.POST.get("site_url", ""), "site_latitude": request.POST.get("site_latitude", ""), "site_longitude": request.POST.get("site_longitude", ""), "address_line1": request.POST.get("address_line1", ""), "address_line2": request.POST.get("address_line2", ""), "address_line3": request.POST.get("address_line3", ""), "address_city": request.POST.get("address_city", ""), "address_postalcode": request.POST.get("address_postalcode", ""), "address_state": request.POST.get("address_state", ""), "address_country": request.POST.get("address_country", ""), "root_authority_hrn": request.POST.get("root_authority_hrn", "").lower(), "root_authorities": root_authorities, "authorities": authorities, } template_env.update(page.prelude_env()) return render(request, "join_view.html", template_env)
def test_plugin_view (request): page = Page(request) page.expose_js_metadata() # variables that will get passed to this template template_env = {} slicename='ple.inria.heartbeat' main_query = Query.get('resource').filter_by('slice_hrn', '=', slicename).select(['network','type','hrn','hostname','sliver']) # without an querytable, this would use use : run_it=False as nothing would listen to the results page.enqueue_query (main_query, # run_it=False ) main_plugin = \ Stack ( page=page, title='thestack', togglable=True, domid='stack', sons=[ \ # make sure the 2 things work together Messages ( page=page, title="Transient Runtime messages", domid="messages-transient", levels='ALL', ), QueryTable ( page=page, title="Slice %s - checkboxes"%slicename, query=main_query, domid="querytable", checkboxes=True, togglable=True, ), Messages ( page=page, title="Inline Runtime messages", domid="messages", levels='ALL', togglable=True, transient=False, ), Raw ( page=page, title="issue messages", togglable=True, html=""" <input type="button" id="bouton" value="Click me" /> """, ), ]) page.add_js_chunks ( """ function issue_debug() {console.log("issue_debug");messages.debug("issue_debug");}; $(function(){$("#bouton").click(issue_debug);}); """) # define 'unfold_main' to the template engine template_env [ 'unfold_main' ] = main_plugin.render(request) # more general variables expected in the template template_env [ 'title' ] = 'Single Plugin View' template_env [ 'topmenu_items' ] = topmenu_items_live('plugin', page) template_env [ 'username' ] = the_user (request) # the prelude object in page contains a summary of the requirements() for all plugins # define {js,css}_{files,chunks} prelude_env = page.prelude_env() template_env.update(prelude_env) return render_to_response ('view-unfold1.html',template_env, context_instance=RequestContext(request))
def get (self, request, slicename='ple.inria.f14'): page=Page(request) page.expose_js_metadata() metadata = page.get_metadata() resource_md = metadata.details_by_object('resource') resource_fields = [column['name'] for column in resource_md['column']] main_query = Query.get('slice').filter_by('slice_hrn', '=', slicename) main_query.select( 'slice_hrn', #'resource.hrn', 'resource.hostname', 'resource.type', 'resource.network_hrn', 'lease.urn', 'user.user_hrn', #'application.measurement_point.counter' ) # for internal use in the querygrid plugin; # needs to be a unique column present for each returned record main_query_init_key = 'hostname' query_resource_all = Query.get('resource').select(resource_fields) aq = AnalyzedQuery(main_query, metadata=metadata) page.enqueue_query(main_query, analyzed_query=aq) page.enqueue_query(query_resource_all) sq_resource = aq.subquery('resource') resources_as_list = QueryGrid( page = page, domid = 'resources-list', title = 'List view', # this is the query at the core of the slice list query = sq_resource, query_all = query_resource_all, # safer to use 'hrn' as the internal unique key for this plugin init_key = main_query_init_key, checkboxes = True, datatables_options = { 'iDisplayLength': 25, 'bLengthChange' : True, 'bAutoWidth' : True, }, ) # variables that will get passed to the view-unfold1.html template template_env = {} # define 'unfold_main' to the template engine - the main contents template_env [ 'unfold_main' ] = resources_as_list.render(request) # more general variables expected in the template template_env [ 'title' ] = 'simple %(slicename)s'%locals() # the menu items on the top template_env [ 'topmenu_items' ] = topmenu_items_live('Slice', page) # so we can sho who is logged template_env [ 'username' ] = the_user (request) # the prelude object in page contains a summary of the requirements() for all plugins # define {js,css}_{files,chunks} prelude_env = page.prelude_env() template_env.update(prelude_env) result=render_to_response ('view-unfold1.html',template_env, context_instance=RequestContext(request)) return result