From: Jordan Augé <jordan.auge@lip6.fr>
Date: Mon, 3 Mar 2014 12:55:47 +0000 (+0100)
Subject: Merge branch 'onelab' of ssh://git.onelab.eu/git/myslice into onelab
X-Git-Tag: myslice-1.1~249^2~3
X-Git-Url: http://git.onelab.eu/?p=myslice.git;a=commitdiff_plain;h=d251934bd71c678f552dc9a1d49c3f8efe102e1e

Merge branch 'onelab' of ssh://git.onelab.eu/git/myslice into onelab

Conflicts:
	portal/registrationview.py
---

d251934bd71c678f552dc9a1d49c3f8efe102e1e
diff --cc portal/actions.py
index 084ee884,c22d8fba..b2f53184
--- a/portal/actions.py
+++ b/portal/actions.py
@@@ -4,10 -4,6 +4,10 @@@ from manifoldapi.manifoldapi        imp
  from portal.models               import PendingUser, PendingSlice, PendingAuthority
  import json
  
- from portal.models               import PendingSlice
++from django.contrib.auth.models import User
 +from django.template.loader      import render_to_string
 +from django.core.mail            import send_mail
 +
  # Thierry: moving this right into the code so 
  # most people can use myslice without having to install sfa
  # XXX tmp sfa dependency, should be moved to SFA gateway
@@@ -33,24 -30,11 +33,23 @@@ def authority_get_pi_emails(request, au
          return ['support@myslice.info']
      else:
          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')
++        query = Query.get('user').filter_by('user_hrn', 'included', pi_user_hrns).select('user_email')
          results = execute_admin_query(request, query)
--        print "mails",  [result['email'] for result in results]
--        return [result['email'] for result in results]
++        return [result['user_email'] for result in results]
 +
 +def is_pi(wsgi_request, user_hrn, authority_hrn):
 +    # XXX could be done in a single query !
  
 +    # select pi_authorities from user where user_hrn == "ple.upmc.jordan_auge"
 +    query = Query.get('user').filter_by('user_hrn', '==', user_hrn).select('pi_authorities')
 +    results = execute_admin_query(wsgi_request, query)
 +    if not results:
 +        # XXX Warning ?
 +        return False
 +    result = results[0]
 +    user_authority_hrns = result.get('pi_authorities', [])
 +    return authority_hrn in user_authority_hrns
 +    
  # SFA get record
  
  def sfa_get_user(request, user_hrn, pub):
@@@ -172,7 -152,7 +171,9 @@@ def make_request_user(user)
      request['last_name']     = user.last_name
      request['email']         = user.email
      request['login']         = user.login
--    request['keypair']       = user.keypair
++    request['user_hrn']      = user.user_hrn
++    request['public_key']    = user.public_key
++    request['private_key']   = user.private_key
      return request
  
  def make_request_slice(slice):
@@@ -336,208 -405,3 +337,207 @@@ def validate_action(request, **kwargs)
  
  # Django and ajax
  # http://djangosnippets.org/snippets/942/
 +
 +
 +
 +#-------------------------------------------------------------------------------
 +# REQUESTS - Slices
 +#-------------------------------------------------------------------------------
 +
 +def create_slice(wsgi_request, request):
 +    """
 +    Arguments:
 +        wsgi_request (~ WSGIRequest) : 
 +        request (dict) : the slice request in our own dict format
 +
 +    Raises:
 +        Exception
 +    """
 +    hrn = "%s.%s" % (request['authority_hrn'], request['slice_name'])
 +    # XXX tmp sfa dependency
 +    from sfa.util.xrn import Xrn 
 +    urn = Xrn(hrn, request['type']).get_urn()
 +    
 +    # Add User to Slice if we have the user_hrn in pendingslice table
 +    user_hrn = request.get('user_hrn', None)
 +    user_hrns = list([user_hrn]) if user_hrn else list()
 +
 +    # XXX We should create a slice with Manifold terminology
 +    slice_params = {
 +        'slice_hrn'        : hrn, 
 +        'slice_urn'        : urn,
 +        'slice_type'       : request['type'],
 +        'users'            : user_hrns,
 +        'slice_enabled'    : True
 +    }
 +    # ignored in request: id, timestamp,  number_of_nodes, type_of_nodes, purpose
 +
 +    query = Query.create('slice').set(slice_params).select('slice_hrn')
 +    results = execute_query(wsgi_request, query)
 +    if not results:
 +        raise Exception, "Could not create %s. Already exists ?" % slice_params['hrn']
 +    return results
 +
 +def create_pending_slice(wgsi_request, request):
 +    """
 +    """
 +
 +    # Insert an entry in the PendingSlice table
 +    s = PendingSlice(
 +        slice_name      = request['slice_name'],
 +        user_hrn        = request['user_hrn'],
 +        authority_hrn   = request['authority_hrn'],
 +        number_of_nodes = request['number_of_nodes'],
 +        purpose         = request['purpose'],
 +    )
 +    s.save()
 +
 +    # Send an email: the recipients are the PI of the authority
 +    recipients = authority_get_pi_emails(wsgi_request, authority_hrn)
 +    msg = render_to_string('slice-request-email.txt', request)
 +    send_mail("Onelab user %(email)s requested a slice" % request, msg, email, recipients)
 +
 +#-------------------------------------------------------------------------------
 +# REQUESTS - Users
 +#-------------------------------------------------------------------------------
 +
 +def manifold_add_reference_user_accounts(wsgi_request, request):
 +    """When a new user is created, add reference accounts to the reference platform.
 +    """
 +    # XXX XXX XXX The rest of this function has to be checked XXX XXX XXX
 +
 +    # Retrieve user information
 +    user_query  = Query().get('local:user')             \
 +        .select('user_id', 'config', 'email', 'status') \
 +        .filter_by('email', '==', request['email'])
 +    user_details = execute_admin_query(wsgi_request, user_query)
 +
 +    # USER MAIN ACCOUNT != reference
 +    #print 'USER MAIN ACCOUNT != reference'
 +    list_accounts_query = Query().get('local:account')              \
 +        .select('user_id', 'platform_id', 'auth_type', 'config')    \
 +        .filter_by('user_id', '==', user_details[0]['user_id'])     \
 +        .filter_by('auth_type', '!=', 'reference')
 +    list_accounts = execute_admin_query(wsgi_request, list_accounts_query)
 +
 +    # XXX main_platform is being erased several times ???
 +    for account in list_accounts:
 +        main_platform_query = Query().get('local:platform')         \
 +            .select('platform_id', 'platform')                      \
 +            .filter_by('platform_id', '==', account['platform_id'])
 +        main_platform = execute_admin_query(wsgi_request, main_platform_query)
 +
 +    # Add reference accounts on SFA enabled platforms
 +    platforms_query = Query().get('local:platform') \
 +        .filter_by('disabled', '==', '0')           \
 +        .filter_by('gateway_type', '==', 'sfa')     \
 +        .select('platform_id', 'gateway_type')
 +    platforms = execute_admin_query(wsgi_request, platforms_query)
 +    for platform in platforms:
 +        #print "add reference to platform ",platform
 +        manifold_account_params = {
 +            'user_id'       : user_details[0]['user_id'],
 +            'platform_id'   : platform['platform_id'],
 +            'auth_type'     : 'reference',
 +            'config'        : '{"reference_platform": "' + main_platform[0]['platform'] + '"}',
 +        }
 +        manifold_add_account(wsgi_request, manifold_account_params)
 +
 +def sfa_create_user(wsgi_request, request):
 +    """
 +    Arguments:
 +        wsgi_request (~ WSGIRequest) : 
 +        request (dict) : the user request in our own dict format
 +
 +    Raises:
 +        Exception
 +    """
 +    from sfa.util.xrn import Xrn 
 +
 +    auth_pi = request.get('pi', None)
 +    auth_pi = list([auth_pi]) if auth_pi else list()
 +
 +    # We create a slice request with Manifold terminology
 +    sfa_user_params = {
 +        'user_hrn'   : request['user_hrn'],
 +        'user_email' : request['email'],
 +        'urn'        : Xrn(request['user_hrn'], request['type']).get_urn(),
 +        'type'       : request['type'],
 +        'keys'       : request['public_key'],
 +        'first_name' : request['first_name'],
 +        'last_name'  : request['last_name'],
 +        #'slices'    : None,
 +        #'researcher': None,
 +        'pi'         : auth_pi,
 +        'enabled'    : True
 +    }
 +
-     query = Query.create('user').set(user_params).select('user_hrn')
++    query = Query.create('user').set(sfa_user_params).select('user_hrn')
 +    results = execute_query(wsgi_request, query)
 +    if not results:
 +        raise Exception, "Could not create %s. Already exists ?" % user_params['user_hrn']
 +    return results
 +
 +def create_user(wsgi_request, request):
 +    
 +    # XXX This has to be stored centrally
 +    USER_STATUS_ENABLED = 2
 +
 +    # NOTE : if we were to create a user directly (just like we create slices,
 +    # we would have to perform the steps in create_pending_user too
 +
 +    # Add the user to the SFA registry
-     sfa_add_user(wsgi_request, request)
++    sfa_create_user(wsgi_request, request)
 +
 +    # Update Manifold user status
 +    manifold_update_user(wsgi_request, request['email'], {'status': USER_STATUS_ENABLED})
 +
 +    # Add reference accounts for platforms
 +    manifold_add_reference_user_accounts(wsgi_request, request)
 +
- def create_pending_user(wgsi_request, request, user_detail):
++def create_pending_user(wsgi_request, request, user_detail):
 +    """
 +    """
 +
 +    # Insert an entry in the PendingUser table
 +    b = PendingUser(
 +        first_name    = request['first_name'],
 +        last_name     = request['last_name'],
 +        authority_hrn = request['authority_hrn'],
 +        email         = request['email'],
 +        password      = request['password'],
-         keypair       = request['account_config'],  # XXX REMOVE
-         public_key    = request['public_key'],      # TODO NEW
-         private_key   = request['private_key'],     # TODO NEW
-         user_hrn      = request['user_hrn'],        # TODO NEW
++        public_key    = request['public_key'],
++        private_key   = request['private_key'],
++        user_hrn      = request['user_hrn'],
 +        pi            = '',                         # XXX Why not None ?
 +    )
 +    b.save()
 +
 +    # saves the user to django auth_user table [needed for password reset]
 +    user = User.objects.create_user(request['email'], request['email'], request['password'])
 +
 +    # Creating a manifold user
 +    user_id = manifold_add_user(wsgi_request, request)
 +
 +    # Creating a Manifold account on the MySlice platform
 +    # Note the JSON representation of public and private keys already includes quotes
 +    account_config = {
 +        'user_hrn'          : request['user_hrn'],
 +        'user_public_key'   : request['public_key'],
 +    }
 +    if request['private_key']:
 +        account_config['user_private_key'] = request['private_key']
 +
 +    user_id = user_detail['user_id'] + 1 # the user_id for the newly created user in local:user
 +    account_params = {
 +        'platform_id'   : 5, # XXX ALERT !!
 +        'user_id'       : user_id, 
 +        'auth_type'     : request['auth_type'], 
 +        'config'        : json.dumps(account_config),
 +    }
 +    manifold_add_account(wsgi_request, account_params)
 +
 +    # Send an email: the recipients are the PI of the authority
-     recipients = authority_get_pi_emails(wsgi_request, authority_hrn)
++    recipients = authority_get_pi_emails(wsgi_request, request['authority_hrn'])
 +    msg = render_to_string('user_request_email.txt', request)
 +    send_mail("Onelab New User request for %(email)s submitted" % request, msg, 'support@myslice.info', recipients)
diff --cc portal/dashboardview.py
index c2f6e9ce,a4e0ad45..2b0ab828
--- a/portal/dashboardview.py
+++ b/portal/dashboardview.py
@@@ -22,7 -22,7 +22,6 @@@ class DashboardView (LoginRequiredAutoL
          # We might have slices on different registries with different user accounts 
          # We note that this portal could be specific to a given registry, to which we register users, but i'm not sure that simplifies things
          # Different registries mean different identities, unless we identify via SFA HRN or have associated the user email to a single hrn
--	print self.request
          #messages.info(self.request, 'You have logged in')
          page = Page(self.request)
  
@@@ -48,7 -48,7 +47,9 @@@
  #            root_authority = sub_authority[0]
  #            slice_query = Query().get(root_authority+':user').filter_by('user_hrn', '==', '$user_hrn').select('user_hrn', 'slice.slice_hrn')
  #        else:
 -        slice_query = Query().get('user').filter_by('user_hrn', '==', '$user_hrn').select('slice.slice_hrn')
++        print "SLICE QUERY"
++        print "-" * 80
 +        slice_query = Query().get('user').filter_by('user_hrn', '==', '$user_hrn').select('slices.slice_hrn')
          page.enqueue_query(slice_query)
          page.enqueue_query(testbed_query)
  
diff --cc portal/registrationview.py
index c133a576,58567dd8..8fd5917b
--- a/portal/registrationview.py
+++ b/portal/registrationview.py
@@@ -3,7 -3,7 +3,6 @@@ import jso
  from random import randint
  
  from django.core.mail           import send_mail
--from django.contrib.auth.models import User
  from django.views.generic       import View
  from django.template.loader     import render_to_string
  from django.shortcuts           import render
@@@ -17,7 -17,7 +16,7 @@@ from manifoldapi.manifoldapi    import 
  from manifold.core.query        import Query
  
  from portal.models              import PendingUser
--from portal.actions             import authority_get_pi_emails, manifold_add_user,manifold_add_account
++from portal.actions             import create_pending_user
  
  from theme import ThemeView
  
@@@ -56,75 -60,129 +55,74 @@@ class RegistrationView (FreeAccessView
          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] 
 +            # The form has been submitted
 +
 +            user_request = {
 +                'first_name'    : wsgi_request.POST.get('firstname',     ''),
 +                'last_name'     : wsgi_request.POST.get('lastname',      ''),
 +                'authority_hrn' : wsgi_request.POST.get('authority_hrn', ''),
 +                'email'         : wsgi_request.POST.get('email',         '').lower(),
 +                'password'      : wsgi_request.POST.get('password',      ''),
 +            }
 +
 +            # Construct user_hrn from email (XXX Should use common code)
-             split_email = reg_email.split("@")[0] 
++            split_email = user_request['email'].split("@")[0] 
              split_email = split_email.replace(".", "_")
 -            user_hrn = reg_auth + '.' + split_email+ str(randint(1,1000000))
 +            user_request['user_hrn'] = user_request['authority_hrn'] \
 +                     + '.' + split_email + str(randint(1,1000000))
              
 +            # Validate input
              UserModel = get_user_model()
 -
 -            #POST value validation  
 -            if (re.search(r'^[\w+\s.@+-]+$', reg_fname)==None):
 +            if (re.search(r'^[\w+\s.@+-]+$', user_request['first_name']) == None):
                  errors.append('First Name may contain only letters, numbers, spaces and @/./+/-/_ characters.')
 -            if (re.search(r'^[\w+\s.@+-]+$', reg_lname) == None):
 +            if (re.search(r'^[\w+\s.@+-]+$', user_request['last_name']) == 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):
 +            if PendingUser.objects.filter(email__iexact = user_request['email']):
                  errors.append('Email is pending for validation. Please provide a new email address.')
 -            if UserModel._default_manager.filter(email__iexact=reg_email): 
 +            if UserModel._default_manager.filter(email__iexact = user_request['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:
 +                if user_detail['email'] == user_request['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']:
 +            # XXX TODO: Factorize with portal/accountview.py
 +            if 'generate' in wsgi_request.POST['question']:
 +                user_request['auth_type'] = 'managed'
 +
 +                # XXX Common code, dependency ?
                  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('"', '');
 +
 +                # Example: private_key = '-----BEGIN RSA PRIVATE KEY-----\nMIIC...'
 +                # Example: public_key = 'ssh-rsa AAAAB3...'
 +                user_request['private_key'] = private.exportKey()
-                 user_request['public_key']  = private.public_key().exportKey(format='OpenSSH')
++                user_request['public_key']  = private.publickey().exportKey(format='OpenSSH')
 +
              else: 
 -                up_file = request.FILES['user_public_key']
 -                file_content =  up_file.read()
 -                file_name = up_file.name
 +                user_request['auth_type'] = 'user'
 +
 +                up_file        = wsgi_request.FILES['user_public_key']
 +
 +                file_content   = up_file.read().strip()
 +                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:
 +
 +                ALLOWED_EXTENSIONS =  ['.pub','.txt']
 +                if file_extension not in ALLOWED_EXTENSIONS or not re.search(r'ssh-rsa',file_content):
                      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,
 -                    }
 +                user_request['private_key'] = None
 +                user_request['public_key']  = file_content
                  
 -                recipients = authority_get_pi_emails(request,reg_auth)
 -                
 -
 -                msg = render_to_string('user_request_email.txt', ctx)
 -                send_mail("Onelab New User request for %s submitted"%reg_email, msg, 'support@myslice.info', recipients)
 +            if not errors:
 +                create_pending_user(wsgi_request, user_request, user_detail)
                  self.template_name = 'user_register_complete.html'
 -                return render(request, self.template, {'theme': self.theme}) 
 +                return render(wsgi_request, self.template, {'theme': self.theme}) 
 +
- 
-         # Backlashed \n => \\n but no surrounding " "
-         public_key_formatted = request['public_key'].replace('"', '');
++        else:
++            user_request = {}
  
          template_env = {
            'topmenu_items': topmenu_items_live('Register', page),
diff --cc portal/templates/onelab/onelab_home-view.html
index a1206de1,7a3f7199..4915b9e2
--- a/portal/templates/onelab/onelab_home-view.html
+++ b/portal/templates/onelab/onelab_home-view.html
@@@ -102,8 -106,8 +106,8 @@@
  		{% if person %}
          $.post("/rest/user/",{'filters':{'user_hrn':'$user_hrn'}}, function( data ) {
  		  var items = [];
--		  $.each( data[0].slice, function( key, val ) {
--		  	items.push( "<li><a href=\"/slice/"+val.slice_hrn+"\">" + val.slice_hrn + "</a></li>" );
++		  $.each( data[0].slices, function(i, val) {
++		  	items.push( "<li><a href=\"/slice/"+val+"\">" + val + "</a></li>" );
  		  });
  		  
  		  $("div#home-slice-list").html($( "<ul/>", { html: items.join( "" ) }));