sfa/dummy/dummy_testbed_api.py

   1 import SimpleXMLRPCServer
   2 import time
   3
   4 dummy_api_addr = ("localhost", 8080)
   5
   6 # Fake Testbed DB
   7
   8 nodes_list = []
   9 for i in range(1,11):
  10     node = {'hostname': 'node'+str(i)+'.dummy-testbed.org', 'type': 'dummy-node', 'node_id': i}
  11     nodes_list.append(node)
  12
  13 slices_list = []
  14 for i in range(1,3):
  15     slice = {'slice_name': 'slice'+str(i),
  16              'user_ids': range(i,4,2),
  17              'slice_id': i,
  18              'node_ids': range(i,10,2),
  19              'enabled': True,
  20              'expires': int(time.time())+60*60*24*30}
  21     slices_list.append(slice)
  22
  23 users_list = []
  24 for i in range(1,5):
  25     user = {'user_name': 'user'+str(i), 'user_id': i, 'email': 'user'+str(i)+'@dummy-testbed.org', 'keys': ['user_ssh_pub_key_'+str(i)]}
  26     users_list.append(user)
  27
  28 DB = {'nodes_list': nodes_list,'node_index': 11, 'slices_list': slices_list, 'slice_index': 3, 'users_list': users_list, 'user_index': 5}
  29
  30 #Filter function gor the GET methods
  31
  32 def FilterList(myfilter, mylist):
  33     result = []
  34     result.extend(mylist)
  35     for item in mylist:
  36          for key in myfilter.keys():
  37              if 'ids' in key:
  38                  pass
  39              else:
  40                  if isinstance(myfilter[key], str) and myfilter[key] != item[key] or isinstance(myfilter[key], list) and item[key] not in myfilter[key]:
  41                      result.remove(item)
  42                      break
  43     return result
  44
  45
  46 # RPC functions definition
  47 #GET
  48 def GetTestbedInfo():
  49     return {'name': 'dummy', 'longitude': 123456, 'latitude': 654321, 'domain':'dummy-testbed.org'}
  50
  51 def GetNodes(filter=None):
  52     if filter is None: filter={}
  53     global DB
  54     result = []
  55     result.extend(DB['nodes_list'])
  56     if 'node_ids' in filter:
  57         for node in DB['nodes_list']:
  58              if node['node_id'] not in filter['node_ids']:
  59                  result.remove(node)
  60     if filter:
  61         result = FilterList(filter, result)
  62     return result
  63
  64 def GetSlices(filter=None):
  65     if filter is None: filter={}
  66     global DB
  67     result = []
  68     result.extend(DB['slices_list'])
  69     if 'slice_ids' in filter:
  70         for slice in DB['slices_list']:
  71              if slice['slice_id'] not in filter['slice_ids']:
  72                  result.remove(slice)
  73
  74     if filter:
  75         result = FilterList(filter, result)
  76     return result
  77
  78
  79 def GetUsers(filter=None):
  80     if filter is None: filter={}
  81     global DB
  82     result = []
  83     result.extend(DB['users_list'])
  84     if 'user_ids' in filter:
  85         for user in DB['users_list']:
  86              if user['user_id'] not in filter['user_ids']:
  87                  result.remove(user)
  88
  89     if filter:
  90         result = FilterList(filter, result)
  91     return result
  92
  93
  94 #def GetKeys():
  95
  96
  97
  98 #add
  99
 100 def AddNode(node):
 101     global DB
 102     if not isinstance(node, dict):
 103         return False
 104     for key in node.keys():
 105          if key not in ['hostname', 'type']:
 106              return False
 107     node['node_id'] = DB['node_index']
 108     DB['node_index'] += 1
 109     DB['nodes_list'].append(node)
 110     return node['node_id']
 111
 112 def AddSlice(slice):
 113     global DB
 114     if not isinstance(slice, dict):
 115         return False
 116     for key in slice.keys():
 117          if key not in ['slice_name', 'user_ids', 'node_ids', 'enabled', 'expires']:
 118              return False
 119     slice['slice_id'] = DB['slice_index']
 120     slice['expires'] = int(time.time())+60*60*24*30
 121     DB['slice_index'] += 1
 122     DB['slices_list'].append(slice)
 123     return slice['slice_id']
 124
 125
 126 def AddUser(user):
 127     global DB
 128     if not isinstance(user, dict):
 129         return False
 130     for key in user.keys():
 131          if key not in ['user_name', 'email', 'keys']:
 132              return False
 133     user['user_id'] = DB['user_index']
 134     DB['user_index'] += 1
 135     DB['users_list'].append(user)
 136     return user['user_id']
 137
 138
 139 def AddUserKey(param):
 140     global DB
 141     if not isinstance(param, dict):
 142         return False
 143     try:
 144         for user in DB['users_list']:
 145              if param['user_id'] == user['user_id']:
 146                  if 'keys' in user.keys():
 147                      user['keys'].append(param['key'])
 148                  else:
 149                     user['keys'] = [param['key']]
 150                  return True
 151         return False
 152     except:
 153         return False
 154
 155 def AddUserToSlice(param):
 156     global DB
 157     if not isinstance(param, dict):
 158         return False
 159     try:
 160         for slice in DB['slices_list']:
 161              if param['slice_id'] == slice['slice_id']:
 162                  if not 'user_ids' in slice: slice['user_ids'] = []
 163                  slice['user_ids'].append(param['user_id'])
 164                  return True
 165         return False
 166     except:
 167         return False
 168
 169 def AddSliceToNodes(param):
 170     global DB
 171     if not isinstance(param, dict):
 172         return False
 173     try:
 174         for slice in DB['slices_list']:
 175              if param['slice_id'] == slice['slice_id']:
 176                  if not 'node_ids' in slice: slice['node_ids'] = []
 177                  slice['node_ids'].extend(param['node_ids'])
 178                  return True
 179         return False
 180     except:
 181         return False
 182
 183
 184 #Delete
 185
 186 def DeleteNode(param):
 187     global DB
 188     if not isinstance(param, dict):
 189         return False
 190     try:
 191         for node in DB['nodes_list']:
 192              if param['node_id'] == node['node_id']:
 193                  DB['nodes_list'].remove(node)
 194                  for slice in DB['slices_list']:
 195                       if param['node_id'] in slice['node_ids']:
 196                           slice['node_ids'].remove(param['node_id'])
 197                           return True
 198         return False
 199     except:
 200         return False
 201
 202
 203 def DeleteSlice(param):
 204     global DB
 205     if not isinstance(param, dict):
 206         return False
 207     try:
 208         for slice in DB['slices_list']:
 209              if param['slice_id'] == slice['slice_id']:
 210                  DB['slices_list'].remove(slice)
 211                  return True
 212         return False
 213     except:
 214         return False
 215
 216
 217 def DeleteUser(param):
 218     global DB
 219     if not isinstance(param, dict):
 220         return False
 221     try:
 222         for user in DB['users_list']:
 223              if param['user_id'] == user['user_id']:
 224                  DB['users_list'].remove(user)
 225                  for slice in DB['slices_list']:
 226                       if param['user_id'] in slice['user_ids']:
 227                           slice['user_ids'].remove(param['user_id'])
 228                           return True
 229         return False
 230     except:
 231         return False
 232
 233
 234 def DeleteKey(param):
 235     global DB
 236     if not isinstance(param, dict):
 237         return False
 238     try:
 239         for user in DB['users_list']:
 240              if param['key'] in user['keys']:
 241                  user['keys'].remove(param['key'])
 242                  return True
 243         return False
 244     except:
 245         return False
 246
 247 def DeleteUserFromSlice(param):
 248     global DB
 249     if not isinstance(param, dict):
 250         return False
 251     try:
 252         for slice in DB['slices_list']:
 253              if param['slice_id'] == slice['slice_id'] and param['user_id'] in slice['user_ids']:
 254                  slice['user_ids'].remove(param['user_id'])
 255                  return True
 256         return False
 257     except:
 258         return False
 259
 260
 261 def DeleteSliceFromNodes(param):
 262     global DB
 263     if not isinstance(param, dict):
 264         return False
 265     try:
 266         for slice in DB['slices_list']:
 267              if param['slice_id'] == slice['slice_id']:
 268                  for node_id in param['node_ids']:
 269                       if node_id in slice['node_ids']: slice['node_ids'].remove(node_id)
 270                  return True
 271         return False
 272     except:
 273         return False
 274
 275
 276 #Update
 277
 278 def UpdateNode(param):
 279     global DB
 280     if not isinstance(param, dict):
 281         return False
 282     try:
 283         for node in DB['nodes_list']:
 284              if param['node_id'] == node['node_id']:
 285                  for key in param['fields'].keys():
 286                       if key in ['hostname', 'type']:
 287                           node[key] = param['fields'][key]
 288                  return True
 289         return False
 290     except:
 291         return False
 292
 293
 294 def UpdateSlice(param):
 295     global DB
 296     if not isinstance(param, dict):
 297         return False
 298     try:
 299         for slice in DB['slices_list']:
 300              if param['slice_id'] == slice['slice_id']:
 301                  for key in param['fields'].keys():
 302                       if key in ['slice_name']:
 303                           slice[key] = param['fields'][key]
 304                  return True
 305         return False
 306     except:
 307         return False
 308
 309
 310 def UpdateUser(param):
 311     global DB
 312     if not isinstance(param, dict):
 313         return False
 314     try:
 315         for user in DB['users_list']:
 316              if param['user_id'] == user['user_id']:
 317                  for key in param['fields'].keys():
 318                       if key in ['user_name', 'email']:
 319                           user[key] = param['fields'][key]
 320                  return True
 321         return False
 322     except:
 323         return False
 324
 325
 326
 327
 328 # Instantiate the XMLRPC server
 329 dummy_api_server = SimpleXMLRPCServer.SimpleXMLRPCServer(dummy_api_addr)
 330
 331 # RPC functions registration
 332 dummy_api_server.register_function(GetTestbedInfo)
 333 dummy_api_server.register_function(GetNodes)
 334 dummy_api_server.register_function(GetSlices)
 335 dummy_api_server.register_function(GetUsers)
 336 dummy_api_server.register_function(AddNode)
 337 dummy_api_server.register_function(AddSlice)
 338 dummy_api_server.register_function(AddUser)
 339 dummy_api_server.register_function(AddUserKey)
 340 dummy_api_server.register_function(AddUserToSlice)
 341 dummy_api_server.register_function(AddSliceToNodes)
 342 dummy_api_server.register_function(DeleteNode)
 343 dummy_api_server.register_function(DeleteSlice)
 344 dummy_api_server.register_function(DeleteUser)
 345 dummy_api_server.register_function(DeleteKey)
 346 dummy_api_server.register_function(DeleteUserFromSlice)
 347 dummy_api_server.register_function(DeleteSliceFromNodes)
 348 dummy_api_server.register_function(UpdateNode)
 349 dummy_api_server.register_function(UpdateSlice)
 350 dummy_api_server.register_function(UpdateUser)
 351
 352
 353 # Register Introspective functions
 354 dummy_api_server.register_introspection_functions()
 355
 356 # Handle requests
 357 dummy_api_server.serve_forever()
 358
 359
 360