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