sfa/dummy/dummy_testbed_api.py

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