rest/sfa_api.py

   1 import os
   2 import json
   3 import ConfigParser
   4 import datetime
   5 from time                       import mktime
   6 import xmltodict
   7
   8 from django.shortcuts           import render_to_response
   9 from django.http                import HttpResponse
  10
  11 from sfa.trust.certificate      import Keypair, Certificate
  12 from sfa.client.sfaserverproxy  import SfaServerProxy
  13 from sfa.client.return_value    import ReturnValue
  14 from sfa.util.xrn               import Xrn, get_leaf, get_authority, hrn_to_urn, urn_to_hrn
  15
  16 from manifold.core.query        import Query
  17 from manifold.operators.rename  import do_rename
  18
  19 from manifoldapi.manifoldapi    import execute_admin_query
  20
  21 from unfold.loginrequired       import LoginRequiredView
  22
  23 from myslice.settings           import logger, config
  24
  25 from rest.json_encoder          import MyEncoder
  26
  27 import uuid
  28 def unique_call_id(): return uuid.uuid4().urn
  29
  30 def dispatch(request, method):
  31
  32     hrn = ''
  33     urn = ''
  34     object_type = ''
  35     rspec = None
  36     recursive = False
  37     options   = dict()
  38     platforms = list()
  39
  40     results = dict()
  41     display = None
  42
  43     if request.method == 'POST':
  44         req_items = request.POST
  45     elif request.method == 'GET':
  46         req_items = request.GET
  47
  48     logger.debug("dispatch got = %s" % req_items.dict())
  49     #t = dict(req_items.iterlists())
  50     #rspec = req_items.getlist('rspec')
  51     #logger.debug("dispatch got = %s" % t)
  52
  53     platforms = req_items.getlist('platform[]')
  54     logger.debug("req_items type = %s" % type(req_items.dict()))
  55     for k in req_items.dict():
  56         logger.debug(k)
  57         if k == 'rspec':
  58             rspec = req_items.get(k)
  59         if k == 'hrn':
  60             hrn = req_items.get(k)
  61         if k == 'urn':
  62             urn = req_items.get(k)
  63         if k == 'type':
  64             object_type = req_items.get(k)
  65         if k == 'recursive':
  66             if v == '1':
  67                 recursive = True
  68             else:
  69                 recursive = False
  70         if k == 'display':
  71             display = req_items.get(k)
  72
  73     if rspec is not None:
  74         try:
  75             rspec = json.loads(rspec)
  76         except Exception,e:
  77             logger.debug("rspec type = %s" % type(rspec))
  78         if type(rspec) is dict:
  79             rspec = xmltodict.unparse(rspec)
  80     results = sfa_client(request, method, hrn=hrn, urn=urn, object_type=object_type, rspec=rspec, recursive=recursive, options=options, platforms=platforms)
  81     if display == 'table':
  82         return render_to_response('table-default.html', {'data' : data, 'fields' : columns, 'id' : '@component_id', 'options' : None})
  83     else:
  84         return HttpResponse(json.dumps(results, cls=MyEncoder), content_type="application/json")
  85
  86 def get_user_account(request, user_email, platform_name):
  87     """
  88     Returns the user configuration for a given platform.
  89     This function does not resolve references.
  90     """
  91     user_query  = Query().get('local:user').filter_by('email', '==', user_email).select('user_id')
  92     user_details = execute_admin_query(request, user_query)
  93     platform_query  = Query().get('local:platform').filter_by('platform', '==', platform_name).select('platform_id')
  94     platform_details = execute_admin_query(request, platform_query)
  95
  96     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')
  97     accounts = execute_admin_query(request, account_query)
  98
  99     if not accounts:
 100         raise Exception, "this account does not exist"
 101
 102     if accounts[0]['auth_type'] == 'reference':
 103         pf = json.loads(accounts[0]['config'])['reference_platform']
 104         return get_user_account(request, user_email, pf)
 105
 106     return accounts[0]
 107
 108 def sfa_client(request, method, hrn=None, urn=None, object_type=None, rspec=None, recursive=None, options=None, platforms=None, admin=False):
 109
 110     Config = ConfigParser.ConfigParser()
 111     monitor_file = os.path.abspath(os.path.dirname(__file__) + '/../myslice/monitor.ini')
 112     Config.read(monitor_file)
 113
 114     if admin:
 115         user_email, admin_password = config.manifold_admin_user_password()
 116     else:
 117         #logger.debug(request.session['user']['email'])
 118         user_email = request.session['user']['email']
 119
 120     results = dict()
 121
 122     if hrn is None:
 123         hrn = ''
 124     if urn is None:
 125         urn = ''
 126     if object_type is None:
 127         object_type = ''
 128     if rspec is None:
 129         rspec = ''
 130     else:
 131         logger.debug("RSPEC = %s" % rspec)
 132     if recursive is None:
 133         recursive = False
 134     if options is None:
 135         options  = dict()
 136     if platforms is None:
 137         platforms = list()
 138
 139     if method not in ['GetVersion','ListResources']:
 140         try:
 141             if not hrn:
 142                 hrn = urn_to_hrn(urn)
 143             else:
 144                 urn = hrn_to_urn(hrn, object_type)
 145         except Exception,e:
 146             logger.error(e)
 147             raise Exception, "Provide urn OR hrn + type as parameters of method %s" % method
 148
 149     if len(platforms)==0:
 150         platforms = get_platforms(request)
 151         #platforms.append('myslice')
 152     #results = {'method':method,'platforms':platforms,'rspec':rspec,'options':options}
 153
 154     result = []
 155     dict_result = {}
 156     data = []
 157     columns = []
 158     api_options = {}
 159     api_options['list_leases'] = 'all'
 160     server_am = False
 161     for pf in platforms:
 162         platform = get_platform_config(request, pf)
 163         if 'rspec_type' in platform and 'rspec_version' in platform:
 164             api_options['geni_rspec_version'] = {'type': platform['rspec_type'],'version': platform['rspec_version']}
 165         else:
 166             api_options['geni_rspec_version'] = {'type': 'GENI', 'version': '3'}
 167         if 'sm' in platform and len(platform['sm']) > 0:
 168             server_am = True
 169             server_url = platform['sm']
 170         if 'rm' in platform and len(platform['rm']) > 0:
 171             server_am = False
 172             server_url = platform['rm']
 173         if 'registry' in platform and len(platform['registry']) > 0:
 174             server_am = False
 175             server_url = platform['registry']
 176
 177         if not Config.has_option('monitor', 'cert') :
 178              #return HttpResponse(json.dumps({'error' : '-1'}), content_type="application/json")
 179              return {'error' : '-1', 'msg': 'monitor.ini has no cert configured'}
 180
 181         cert = os.path.abspath(Config.get('monitor', 'cert'))
 182         if not os.path.isfile(cert) :
 183              #return HttpResponse(json.dumps({'error' : '-1'}), content_type="application/json")
 184              return {'error' : '-1', 'msg': 'check cert file at %s'%cert}
 185
 186         if not Config.has_option('monitor', 'pkey') :
 187              #return HttpResponse(json.dumps({'error' : '-2'}), content_type="application/json")
 188              return {'error' : '-2'}
 189
 190         pkey = os.path.abspath(Config.get('monitor', 'pkey'))
 191         if not os.path.isfile(pkey) :
 192              #return HttpResponse(json.dumps({'error' : '-2'}), content_type="application/json")
 193              return {'error' : '-2'}
 194
 195         server = SfaServerProxy(server_url, pkey, cert)
 196
 197         try:
 198             # Get user config from Manifold
 199             user_config = get_user_config(request, user_email, pf)
 200             if 'delegated_user_credential' in user_config:
 201                 user_cred = user_config['delegated_user_credential']
 202             elif 'user_credential' in user_config:
 203                 user_cred = user_config['user_credential']
 204             else:
 205                 logger.error("no user credentials for user = ", user_email)
 206                 user_cred = {}
 207
 208             if object_type:
 209                 if 'delegated_%s_credentials'%object_type in user_config:
 210                     for obj_name, cred in user_config['delegated_%s_credentials'%object_type].items():
 211                         if obj_name == hrn:
 212                             object_cred = cred
 213                 elif '%s_credentials'%object_type in user_config:
 214                     for obj_name, cred in user_config['%s_credentials'%object_type].items():
 215                         if obj_name == hrn:
 216                             object_cred = cred
 217                 else:
 218                     logger.error("no credentials for object")
 219                     logger.error(object_type)
 220                     logger.error(object_name)
 221                     object_cred = {}
 222
 223             # Both AM & Registry
 224             if method == "GetVersion":
 225                 result = server.GetVersion()
 226             else:
 227                 # AM API Calls
 228                 if server_am:
 229                     if method == "ListResources":
 230                         result = server.ListResources([user_cred], api_options)
 231                         dict_result = xmltodict.parse(result['value'])
 232                         result['parsed'] = dict_result
 233                         if isinstance(dict_result['rspec']['node'], list):
 234                             columns.extend(dict_result['rspec']['node'][0].keys())
 235                         else:
 236                             columns.extend(dict_result['rspec']['node'].keys())
 237
 238                     elif method == "Describe":
 239                         version = server.GetVersion()
 240                         # if GetVersion = v2
 241                         if version['geni_api'] == 2:
 242                             # ListResources(slice_hrn)
 243                             api_options['geni_slice_urn'] = urn
 244                             result = server.ListResources([object_cred], api_options)
 245                             dict_result = xmltodict.parse(result['value'])
 246                         # else GetVersion = v3
 247                         else:
 248                             result = server.Describe([urn] ,[object_cred], api_options)
 249                             if isinstance(result, dict):
 250                                 if result['value'] != 0:
 251                                     dict_result = xmltodict.parse(result['value']['geni_rspec'])
 252
 253                         result['parsed'] = dict_result
 254                         if 'rspec' in dict_result and 'node' in dict_result['rspec']:
 255                             if isinstance(dict_result['rspec']['node'], list):
 256                                 columns.extend(dict_result['rspec']['node'][0].keys())
 257                             else:
 258                                 columns.extend(dict_result['rspec']['node'].keys())
 259
 260                     elif method == 'Renew':
 261                         # Renew till 1 month from now
 262                         d = datetime.datetime.utcnow() + datetime.timedelta(365/12)
 263                         date = d.isoformat("T") + "Z"
 264                         result = server.Renew([urn] ,[object_cred], date, api_options)
 265                     elif method == 'Delete':
 266                         result = server.Delete([urn] ,[object_cred], api_options)
 267                     elif method == 'Allocate':
 268                         api_options['call_id']    = unique_call_id()
 269                         # List of users comes from the Registry
 270                         users = get_users_in_slice(request, hrn)
 271                         api_options['sfa_users']  = users
 272                         api_options['geni_users'] = users
 273                         # if GetVersion = v2
 274                         version = server.GetVersion()
 275                         if version['geni_api'] == 2:
 276                             result = server.CreateSliver([urn] ,[object_cred], rspec, api_options)
 277                         # else GetVersion = v3
 278                         else:
 279                             result = server.Allocate(urn ,[object_cred], rspec, api_options)
 280                     elif method == 'Provision':
 281                         # if GetVersion = v2
 282                         # Nothing it is not supported by v2 AMs
 283                         version = server.GetVersion()
 284                         # List of users comes from the Registry
 285                         users = get_users_in_slice(request, hrn)
 286                         api_options['sfa_users']  = users
 287                         api_options['geni_users'] = users
 288                         if version['geni_api'] == 3:
 289                             api_options['call_id']    = unique_call_id()
 290                             result = server.Provision([urn] ,[object_cred], api_options)
 291                     elif method == 'Status':
 292                         result = server.Status([urn] ,[object_cred], api_options)
 293                     elif method == 'PerformOperationalAction':
 294                         # if GetVersion = v2
 295                         # Nothing it is not supported by v2 AMs
 296                         version = server.GetVersion()
 297                         if version['geni_api'] == 3:
 298                             result = server.PerformOperationalAction([urn] ,[object_cred], action, api_options)
 299                     elif method == 'Shutdown':
 300                         result = server.Shutdown(urn ,[object_cred], api_options)
 301                     else:
 302                         #return HttpResponse(json.dumps({'error' : '-3','msg':'method not supported by AM'}), content_type="application/json")
 303                         logger.debug('method %s not handled by AM' % method)
 304                         result = []
 305
 306                 # Registry API Calls
 307                 else:
 308                     record_dict = {'urn': urn, 'hrn': hrn, 'type': object_type}
 309                     if method == "List":
 310                         # hrn is required
 311                         api_options['recursive'] = recursive
 312                         result = server.List(hrn, user_cred, api_options)
 313                         if object_type:
 314                             result = filter_records(object_type, result)
 315                     elif method == "Resolve":
 316                         # hrn is required
 317                         # details can be True or False
 318                         api_options['details']=True
 319                         result = server.Resolve(hrn, user_cred, api_options)
 320                         if object_type:
 321                             result = filter_records(object_type, result)
 322                     elif method == "Register":
 323                         # record_dict must be crafted
 324                         # auth_cred must be selected in the list of auth_creds from user's account
 325                         result = server.Register(record_dict, auth_cred)
 326                     elif method == "Update":
 327                         # record_dict must be crafted
 328                         # object_cred must be selected in the list of creds for the object type
 329                         # from user's account
 330                         result = server.Update(record_dict, object_cred)
 331                     elif method == "Remove":
 332                         # hrn is required
 333                         # auth_cred must be selected in the list of auth_creds from user's account
 334                         # object_type is required
 335                         result = server.Remove(hrn, auth_cred, object_type)
 336                     else:
 337                         #return HttpResponse(json.dumps({'error' : '-3','msg':'method not supported by Registry'}), content_type="application/json")
 338                         logger.debug('method %s not handled by Registry' % method)
 339                         result = []
 340
 341             results[pf] = result
 342             if dict_result:
 343                 if 'rspec' in dict_result and 'node' in dict_result['rspec']:
 344                     if isinstance(dict_result['rspec']['node'], list):
 345                         data = data + dict_result['rspec']['node']
 346                     else:
 347                         data.append(dict_result['rspec']['node'])
 348         except Exception,e:
 349             import traceback
 350             logger.error(traceback.format_exc())
 351             logger.error(e)
 352             results[pf] = {'error':'-3', 'error_msg': str(e)}
 353
 354     results['columns'] = columns
 355     return results
 356
 357 def rename(self,key,new_key):
 358     ind = self._keys.index(key)  #get the index of old key, O(N) operation
 359     self._keys[ind] = new_key    #replace old key with new key in self._keys
 360     self[new_key] = self[key]    #add the new key, this is added at the end of self._keys
 361     self._keys.pop(-1)           #pop the last item in self._keys
 362
 363 def get_users_in_slice(request, slice_hrn):
 364     # select users.user_hrn, users.user_email, users.keys
 365     # from myslice:slice
 366     # where slice_hrn=='onelab.upmc.r2d2.slice1'
 367     users_query  = Query().get('myslice:slice').filter_by('slice_hrn', '==', slice_hrn).select('users.user_hrn', 'users.user_urn', 'users.user_email','users.keys')
 368     users = execute_admin_query(request, users_query)
 369     rmap = {'user_urn':'urn','user_email':'email','user_hrn':'hrn'}
 370     res = list()
 371     for u in users[0]['users']:
 372         r_user = dict()
 373         for k,v in u.items():
 374             if k in rmap.keys():
 375                 r_user[rmap[k]] = v
 376             else:
 377                 r_user[k]=v
 378         res.append(r_user)
 379     return res
 380
 381 def get_user_config(request, user_email, platform_name):
 382     account = get_user_account(request, user_email, platform_name)
 383     return json.loads(account['config']) if account['config'] else {}
 384
 385 def get_platforms(request):
 386     ret = list()
 387     platform_query  = Query().get('local:platform').filter_by('gateway_type', '==', 'sfa').filter_by('disabled','==',0).select('platform')
 388     platforms = execute_admin_query(request, platform_query)
 389
 390     for p in platforms:
 391         ret.append(p['platform'])
 392     return ret
 393
 394 def get_platform_config(request, platform_name):
 395     platform_query  = Query().get('local:platform').filter_by('platform', '==', platform_name).select('platform', 'config')
 396     platforms = execute_admin_query(request, platform_query)
 397
 398     return json.loads(platforms[0]['config']) if platforms[0]['config'] else {}
 399
 400 def filter_records(type, records):
 401     filtered_records = []
 402     for record in records:
 403         if (record['type'] == type) or (type == "all"):
 404             filtered_records.append(record)
 405     return filtered_records