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