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