from myslice.theme import ThemeView
from myslice.configengine import ConfigEngine
-
+from myslice.settings import logger
theme = ThemeView()
# XXX tmp sfa dependency, should be moved to SFA gateway
#from sfa.util.xrn import Xrn
+def get_myslice_platform(request):
+ platform_query = Query().get('local:platform').select('platform_id','platform','gateway_type','disabled','config').filter_by('platform','==','myslice')
+ platform_details = execute_query(request, platform_query)
+ if isinstance(platform_details,list):
+ for platform_detail in platform_details:
+ return platform_detail
+ else:
+ return None
+
+def get_myslice_account(request):
+ try:
+ platform_myslice = get_myslice_platform(request)
+ account_query = Query().get('local:account').select('user_id','platform_id','auth_type','config').filter_by('platform_id','==',platform_myslice['platform_id'])
+ account_details = execute_query(request, account_query)
+ for account_detail in account_details:
+ return account_detail
+ except Exception as e:
+ print e
+ return None
+
+def get_registry_url(request):
+ try:
+ platform_detail = get_myslice_platform(request)
+ platform_config = json.loads(platform_detail['config'])
+ import socket
+ hostname = socket.gethostbyaddr(socket.gethostname())[0]
+ registry = platform_config.get('registry','N/A')
+ if 'localhost' in registry:
+ port = registry.split(':')[-1:][0]
+ registry = "http://" + hostname +':'+ port
+ return registry
+ except Exception as e:
+ print e
+ return None
+
+def get_jfed_identity(request):
+ try:
+ account_detail = get_myslice_account(request)
+ account_config = json.loads(account_detail['config'])
+ if 'user_private_key' in account_config:
+ private_key = account_config['user_private_key']
+ user_hrn = account_config.get('user_hrn','N/A')
+ platform_detail = get_myslice_platform(request)
+ registry = get_registry_url(request)
+ #registry = 'http://sfa-fed4fire.pl.sophia.inria.fr:12345/'
+ jfed_identity = user_hrn + '\n' + registry + '\n' + private_key
+ return jfed_identity
+ else:
+ return None
+ except Exception as e:
+ print e
+ return None
# Get the list of pis in a given authority
def authority_get_pis(request, authority_hrn):
pi_status = True
return pi_status
- except Exception,e:
- print "Exception in actions.py in authority_check_pis %s" % e
+ except Exception as e:
+ logger.error("Exception in actions.py in authority_check_pis {}".format(e))
return None
-def authority_add_pis(request, authority_hrn,user_hrn):
+def authority_add_pis(request, authority_hrn, user_hrn):
try:
+ pi_list = []
# getting pis of the authority of the user
pis = authority_get_pis (request, authority_hrn)
for pi in pis:
query = Query.update('myslice:authority').filter_by('authority_hrn', '==', authority_hrn).set({'pi_users':pi_list})
results = execute_query(request,query)
newpis = authority_get_pis (request, authority_hrn)
- return newpis
- except Exception,e:
- print "Exception in actions.py in authority_add_pis %s" % e
- return None
+
+ # Add the user to the slices of the project he/she joined
+ if len(authority_hrn.split('.')) > 2:
+ # this authority_hrn is a project
+ query_slices = Query.get('myslice:slice').filter_by('parent_authority', '==', authority_hrn).select('slice_hrn')
+ results_slices = execute_query(request,query_slices)
+ for s in results_slices:
+ sfa_add_user_to_slice(request, user_hrn, s['slice_hrn'])
+ # Clear Credentials of the user
+ user_email = get_user_email(request, user_hrn)
+ clear_user_creds(request, user_email)
+ return newpis
+ except Exception as e:
+ logger.error("Exception in actions.py in authority_add_pis {}".format(e))
+ raise Exception, "Exception in actions.py in authority_add_pis {}".format(e)
-def authority_remove_pis(request, authority_hrn,user_hrn):
+def authority_remove_pis(request, authority_hrn, user_hrn):
try:
+ print "-"*80
+ print "remove_pis"
+ pi_list = []
# getting pis of the authority of the user
pis = authority_get_pis (request, authority_hrn)
for pi in pis:
pi_list = pi['pi_users']
updated_pi_list = pi_list.remove(user_hrn)
- query = Query.update('authority').filter_by('authority_hrn', '==', authority_hrn).set({'pi_users':pi_list})
+ query = Query.update('myslice:authority').filter_by('authority_hrn', '==', authority_hrn).set({'pi_users':pi_list})
results = execute_query(request,query)
newpis = authority_get_pis (request, authority_hrn)
+
+ # Remove the user from the slices of the project he/she left
+ if len(authority_hrn.split('.')) > 2:
+ # this authority_hrn is a project
+ query_slices = Query.get('myslice:slice').filter_by('parent_authority', '==', authority_hrn).select('slice_hrn')
+ results_slices = execute_query(request,query_slices)
+ for s in results_slices:
+ print 'remove from slice %s' % s
+ sfa_remove_user_from_slice(request, user_hrn, s['slice_hrn'])
+
+ # Clear Credentials of the user
+ user_email = get_user_email(request, user_hrn)
+ clear_user_creds(request, user_email)
+
return newpis
- except Exception,e:
- print "Exception in actions.py in authority_remove_pis %s" % e
- return None
+ except Exception as e:
+ logger.error("Exception in actions.py in authority_remove_pis {}".format(e))
+ raise Exception, "Exception in actions.py in authority_remove_pis {}".format(e)
def authority_get_pi_emails(request, authority_hrn):
pi_users = authority_get_pis(request,authority_hrn)
- print "pi_users = %s" % pi_users
+ logger.info("pi_users = %s" % pi_users)
if any(pi['pi_users'] == None or not pi['pi_users'] for pi in pi_users):
#theme.template_name = 'email_default_recipients.txt'
results = execute_admin_query(request, query)
return [result['user_email'] for result in results]
+def get_user_email(request, user_hrn):
+ query = Query.get('myslice:user').filter_by('user_hrn', '==', user_hrn).select('user_email')
+ results = execute_admin_query(request, query)
+ return results[0]['user_email']
+
#clear user credentials
def clear_user_creds(request, user_email):
try:
else:
return None
- except Exception,e:
- print "Exception in actions.py in clear_user_creds %s" % e
+ except Exception as e:
+ logger.error("Exception in actions.py in clear_user_creds {}".format(e))
return None
def is_pi(wsgi_request, user_hrn, authority_hrn):
# authorities from user where user_hrn == "ple.upmc.jordan_auge"
- print "#### actions.py is_pi authority_hrn = ", authority_hrn
+ logger.debug("#### actions.py is_pi authority_hrn = {}".format(authority_hrn))
try:
# CACHE PB with fields
page = Page(wsgi_request)
query = Query().get('myslice:user').select(user_fields).filter_by('user_hrn','==',user_hrn)
#query = Query.get('myslice:user').filter_by('user_hrn', '==', user_hrn).select('pi_authorities')
results = execute_query(wsgi_request, query)
- print "is_pi results = ", results
for user_detail in results:
if authority_hrn in user_detail['pi_authorities']:
return True
- except Exception,e:
- print "Exception in actions.py in is_pi %s" % e
+ except Exception as e:
+ logger.error("Exception in actions.py in is_pi {}".format(e))
return False
# SFA get record
# REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2
query = Query.create('myslice:authority').set(authority_params).select('authority_hrn')
results = execute_query(request, query)
- print "sfa_add_auth results=",results
+ logger.info("sfa_add_auth results={}".format(results))
if not results:
raise Exception, "Could not create %s. Already exists ?" % authority_params['hrn']
return results
-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'
+def sfa_add_user_to_slice(request, user_hrn, slice_hrn):
+# UPDATE myslice:slice SET users = ['fed4fire.upmc.loic_baron', 'fed4fire.upmc.mohammed-yasin_rahman', 'fed4fire.upmc.demo'] WHERE slice_hrn == 'fed4fire.upmc.project_y.test_under' SELECT slice_hrn, slice_urn
+ # REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2
+ query_current_users = Query.get('myslice:slice').select('users').filter_by('slice_hrn','==',slice_hrn)
+ results_current_users = execute_query(request, query_current_users)
+ current_users = list()
+ for r in results_current_users:
+ current_users.extend(r['users'])
+ users = list(set([user_hrn]) | set(current_users))
# REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2
- query_current_users = Query.get('myslice:slice').select('user').filter_by('slice_hrn','==',slice_params['hrn'])
+ query = Query.update('myslice:slice').filter_by('slice_hrn', '==', slice_hrn).set({'users':users}).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 add user %s to slice %s" % (user_hrn, slice_hrn)
+ return results
+
+def sfa_remove_user_from_slice(request, user_hrn, slice_hrn):
+# UPDATE myslice:slice SET users = ['fed4fire.upmc.loic_baron', 'fed4fire.upmc.demo'] WHERE slice_hrn == 'fed4fire.upmc.project_y.test_under' SELECT slice_hrn, slice_urn
+ # REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2
+ query_current_users = Query.get('myslice:slice').select('users').filter_by('slice_hrn','==',slice_hrn)
results_current_users = execute_query(request, query_current_users)
- slice_params['researcher'] = slice_params['researcher'] | results_current_users
+ current_users = list()
+ for r in results_current_users:
+ current_users.extend(r['users'])
+ if user_hrn in current_users:
+ current_users.remove(user_hrn)
# REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2
- query = Query.update('myslice:slice').filter_by('user_hrn', '==', user_hrn).set(slice_params).select('slice_hrn')
+ query = Query.update('myslice:slice').filter_by('slice_hrn', '==', slice_hrn).set({'users':current_users}).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']
+ raise Exception, "Could not remove user %s to slice %s" % (user_hrn, slice_hrn)
return results
# Propose hrn
return results
#explicitly mention the platform_id
-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')
+def manifold_delete_account(request, user_id, platform_id = None):
+ query = Query.delete('local:account').filter_by('user_id', '==', user_id)
+ if platform_id is not None:
+ query.filter_by('platform_id', '==', platform_id)
results = execute_admin_query(request,query)
return results
-def manifold_delete_user(request, user_id, user_params):
- query = Query.delete('local:user').filter_by('user_id', '==', user_id).set(user_params).select('user_id')
+def manifold_delete_user(request, user_id):
+ query = Query.delete('local:user').filter_by('user_id', '==', user_id).select('user_id')
results = execute_admin_query(request,query)
return results
result, = results
return result['platform_id']
+def delete_local_user(wsgi_request, user_email):
+ user_query = Query().get('local:user') \
+ .filter_by('email', '==', user_email) \
+ .select('user_id','config')
+ user = execute_admin_query(wsgi_request, user_query)
+ if len(user) == 0:
+ return False
+ #raise Exception, "User not found, check local DB"
+ else:
+ user_id = user[0]['user_id']
+ user_config = json.loads(user[0]['config'])
+ authority_hrn = user_config.get('authority', None)
+
+ if is_pi(wsgi_request, '$user_hrn', authority_hrn):
+ # removing from Django auth_user
+ UserModel = get_user_model()
+ UserModel._default_manager.filter(email__iexact = user_email).delete()
+
+ # removing manifold account
+ manifold_delete_account(wsgi_request, user_id)
+
+ # removing manifold user
+ manifold_delete_user(wsgi_request, user_id)
+ else:
+ return False
+ #raise Exception, "No sufficient rights on authority = ",authority_hrn
+
+ return True
+
def make_request_user(user):
request = {}
return request
def make_requests(pending_users, pending_slices, pending_authorities, pending_projects, pending_joins):
- print "$$$$$$$$$$$$$$$ make_request"
+ logger.info("$$$$$$$$$$$$$$$ make_request")
requests = []
for user in pending_users:
requests.append(make_request_user(user))
return requests
def get_request_by_id(ids):
- print "$$$$$$$$$$$$$$$$ get_request_by_id"
+ logger.info("$$$$$$$$$$$$$$$$ get_request_by_id")
sorted_ids = { 'user': [], 'slice': [], 'authority': [], 'project': [], 'join': [] }
for type__id in ids:
type, id = type__id.split('__')
return make_requests(pending_users, pending_slices, pending_authorities, pending_projects, pending_joins)
def get_requests(authority_hrns=None):
- print "$$$$$$$$$$$$$ get_request_by_authority auth_hrns = ", authority_hrns
+ logger.info("$$$$$$$$$$$$$ get_request_by_authority auth_hrns = {}".format(authority_hrns))
if not authority_hrns:
## get those pending users who have confirmed their emails
pending_users = PendingUser.objects.filter(status__iexact = 'True')
#'pi' : None,
#'enabled' : True
}
- print "ADD Authority"
+ logger.info("ADD Authority")
sfa_add_authority(wsgi_request, sfa_authority_params)
request_status['SFA authority'] = {'status': True }
PendingAuthority.objects.get(id=request['id']).delete()
'authority_hrn' : hrn
}
sfa_add_authority(wsgi_request, sfa_authority_params)
- request_status['SFA project'] = {'status': True }
- PendingProject.objects.get(id=request['id']).delete()
# Add user as a PI of the project
+ # Clear user's Credentials
authority_add_pis(wsgi_request, hrn , request['user_hrn'])
- # Clear user's Credentials
- #sfa_user = sfa_get_user(wsgi_request, request['user_hrn'])
- clear_user_creds(wsgi_request,request['email'])
+ request_status['SFA project'] = {'status': True }
+ PendingProject.objects.get(id=request['id']).delete()
except Exception, e:
request_status['SFA project'] = {'status': False, 'description': str(e)}
elif request['type'] == 'join':
try:
# Add user as a PI of the project
+ # Clear user's Credentials
authority_add_pis(wsgi_request, request['authority_hrn'] , request['user_hrn'])
request_status['SFA join'] = {'status': True }
PendingJoin.objects.get(id=request['id']).delete()
- # Clear user's Credentials
- clear_user_creds(wsgi_request,request['email'])
-
except Exception, e:
request_status['SFA join'] = {'status': False, 'description': str(e)+' - '+str(request)}
else:
ids = filter(None, kwargs['id'].split('/'))
status = portal_validate_request(request, ids)
json_answer = json.dumps(status)
- return HttpResponse (json_answer, mimetype="application/json")
+ return HttpResponse (json_answer, content_type="application/json")
def reject_action(request, **kwargs):
ids = filter(None, kwargs['id'].split('/'))
status = portal_reject_request(request, ids)
json_answer = json.dumps(status)
- return HttpResponse (json_answer, mimetype="application/json")
+ return HttpResponse (json_answer, content_type="application/json")
def portal_reject_request(wsgi_request, request_ids):
msg = EmailMultiAlternatives(subject, text_content, sender, [user_email])
msg.attach_alternative(html_content, "text/html")
msg.send()
- except Exception, e:
- print "Failed to send email, please check the mail templates and the SMTP configuration of your server"
-
- # removing from Django auth_user
- UserModel = get_user_model()
- UserModel._default_manager.filter(email__iexact = user_email).delete()
+ except Exception as e:
+ logger.error("Failed to send email, please check the mail templates and the SMTP configuration of your server")
+
# removing from Django portal_pendinguser
PendingUser.objects.get(id=request['id']).delete()
- # removing from manifold
- # removing manifold account
- user_query = Query().get('local:user') \
- .filter_by('email', '==', user_email) \
- .select('user_id')
- user = execute_admin_query(wsgi_request, user_query)
- user_id = user[0]['user_id']
-
- platform_query = Query().get('local:platform') \
- .filter_by('platform', '==', 'myslice') \
- .select('platform_id')
- platform = execute_admin_query(wsgi_request, platform_query)
- platform_id = platform[0]['platform_id']
- account_params = {'user_id':user_id}
- manifold_delete_account(request, platform_id, user_id, account_params)
-
- # removing manifold user
- user_params = {'user_id':user_id}
- manifold_delete_user(request, user_id, user_params)
+
+ delete_local_user(wsgi_request, user_email)
except Exception, e:
request_status['SFA authority'] = {'status': False, 'description': str(e)}
msg = EmailMultiAlternatives(subject, text_content, sender, [user_email])
msg.attach_alternative(html_content, "text/html")
msg.send()
- except Exception, e:
- print "Failed to send email, please check the mail templates and the SMTP configuration of your server"
+ except Exception as e:
+ logger.error("Failed to send email, please check the mail templates and the SMTP configuration of your server")
PendingSlice.objects.get(id=request['id']).delete()
msg = EmailMultiAlternatives(subject, text_content, sender, [user_email])
msg.attach_alternative(html_content, "text/html")
msg.send()
- except Exception, e:
- print "Failed to send email, please check the mail templates and the SMTP configuration of your server"
+ except Exception as e:
+ logger.error("Failed to send email, please check the mail templates and the SMTP configuration of your server")
PendingAuthority.objects.get(id=request['id']).delete()
if not 'number_of_nodes' in request:
request['number_of_nodes']=""
+ # Slice is under a project
+ if len(request['authority_hrn'].split('.')) > 2:
+ pi_list = []
+ pis = authority_get_pis(wsgi_request, request['authority_hrn'])
+ for pi in pis:
+ pi_list = pi['pi_users']
+ user_hrns.extend(pi_list)
+
# XXX We should create a slice with Manifold terminology
slice_params = {
'slice_hrn' : hrn,
if not results:
raise Exception, "Could not create %s. Already exists ?" % slice_params['hrn']
else:
- clear_user_creds(wsgi_request,user_email)
+ try:
+ for u_hrn in user_hrns:
+ u_email = get_user_email(wsgi_request, u_hrn)
+ clear_user_creds(wsgi_request, u_email)
+ except Exception as e:
+ logger.error("Failed clear credentials for all users")
+ clear_user_creds(wsgi_request,user_email)
# log user activity
activity.slice.validate(request, { "slice" : hrn })
try:
msg = EmailMultiAlternatives(subject, text_content, sender, [user_email])
msg.attach_alternative(html_content, "text/html")
msg.send()
- except Exception, e:
- print "Failed to send email, please check the mail templates and the SMTP configuration of your server"
+ except Exception as e:
+ logger.error("Failed to send email, please check the mail templates and the SMTP configuration of your server")
return results
msg = EmailMultiAlternatives(subject, text_content, sender, recipients)
msg.attach_alternative(html_content, "text/html")
msg.send()
- except Exception, e:
- print "Failed to send email, please check the mail templates and the SMTP configuration of your server"
+ except Exception as e:
+ logger.error("Failed to send email, please check the mail templates and the SMTP configuration of your server")
def create_pending_project(wsgi_request, request):
sender = sender.replace('\n', '')
- subject = 'User validated'
+ subject = 'Account validated'
msg = EmailMultiAlternatives(subject, text_content, sender, [request['email']])
msg.attach_alternative(html_content, "text/html")
msg.send()
- except Exception, e:
- print "Failed to send email, please check the mail templates and the SMTP configuration of your server"
+ except Exception as e:
+ logger.error("Failed to send email, please check the mail templates and the SMTP configuration of your server")
return results
import requests
import time
from requests.auth import HTTPBasicAuth
-
- URL_REST = ConfigEngine.default_iotlab_url
- LOGIN_ADMIN = ConfigEngine.default_iotlab_admin_user
- PASSWORD_ADMIN = ConfigEngine.default_iotlab_admin_password
+
+ engine = ConfigEngine()
+ URL_REST = engine.iotlab_url()
+ LOGIN_ADMIN = engine.iotlab_admin_user()
+ PASSWORD_ADMIN = engine.iotlab_admin_password()
auth = HTTPBasicAuth(LOGIN_ADMIN,PASSWORD_ADMIN)
headers = {'content-type': 'application/json'}
iotlab_user_params1 = json.dumps(iotlab_user_params)
r=requests.post(url=URL_REST, data=iotlab_user_params1, headers=headers, auth=auth)
- print 'Create iotlab user : ', r.status_code, r.text
+ logger.info('Create iotlab user : {} {}'.format(r.status_code, r.text))
return r.text
def create_user(wsgi_request, request, namespace = None, as_admin = False):
'config' : json.dumps(account_config),
}
manifold_add_account(wsgi_request, account_params)
- except Exception, e:
- print "Failed creating manifold account on platform %s for user: %s" % ('myslice', request['email'])
+ except Exception as e:
+ logger.error("Failed creating manifold account on platform {} for user: {}".format('myslice', request['email']))
try:
# Send an email: the recipients are the PI of the authority
msg.attach_alternative(html_content, "text/html")
msg.send()
except Exception, e:
- print "Failed to send email, please check the mail templates and the SMTP configuration of your server"
+ logger.error("Failed to send email, please check the mail templates and the SMTP configuration of your server")
import traceback
- traceback.print_exc()
+ logger.error(traceback.format_exc())