sfa/iotlab/iotlabshell.py

   1 # -*- coding:utf-8 -*-
   2 """ Shell driver management """
   3
   4 from sfa.util.sfalogging import logger
   5 from iotlabcli import auth
   6 from iotlabcli import rest
   7 from iotlabcli import helpers
   8 from iotlabcli import experiment
   9 from urllib2 import HTTPError
  10
  11
  12 class IotLABShell(object):
  13     """
  14     A REST client shell to the Iot-LAB testbed API instance
  15     """
  16
  17     def __init__(self):
  18         user, passwd = auth.get_user_credentials()
  19         self.api = rest.Api(user, passwd)
  20
  21
  22     def get_nodes(self):
  23         """
  24         Get all OAR nodes
  25         :returns: nodes with OAR properties
  26         :rtype: dict
  27
  28         :Example:
  29         {"items": [
  30             {"archi": "a8:at86rf231",
  31              "mobile": 0,
  32              "mobility_type": " ",
  33              "network_address": "a8-53.grenoble.iot-lab.info",
  34              "site": "paris",
  35              "state": "Alive",
  36              "uid": "9856",
  37              "x": "0.37",
  38              "y": "5.44",
  39              "z": "2.33"
  40             },
  41             {"archi= ...}
  42           ]
  43         {
  44         """
  45         logger.warning("iotlashell get_nodes")
  46         nodes_dict = {}
  47         try:
  48             nodes = experiment.info_experiment(self.api)
  49         except HTTPError as err:
  50             logger.warning("iotlashell get_nodes error %s" % err.reason)
  51             return {'error' : err.reason}
  52         for node in nodes['items']:
  53             nodes_dict[node['network_address']] = node
  54         return nodes_dict
  55
  56
  57     def get_users(self):
  58         """
  59         Get all LDAP users
  60         :returns: users with LDAP attributes
  61         :rtype: dict
  62
  63         :Example:
  64         [{"firstName":"Frederic",
  65           "lastName":"Saint-marcel",
  66           "email":"frederic.saint-marcel@inria.fr",
  67           "structure":"INRIA",
  68           "city":"Grenoble",
  69           "country":"France",
  70           "login":"saintmar",
  71           sshPublicKeys":["ssh-rsa AAAAB3..."],
  72           "motivations":"test SFA",
  73           "validate":true,
  74           "admin":true,
  75           "createTimeStamp":"20120911115247Z"},
  76           {"firstName":"Julien",
  77            ...
  78           }
  79         ]
  80         """
  81         logger.warning("iotlashell get_users")
  82         users_dict = {}
  83         try:
  84             users = self.api.method('admin/users')
  85         except HTTPError as err:
  86             logger.warning("iotlashell get_users error %s" % err.reason)
  87             return {'error' : err.reason}
  88         for user in users:
  89             users_dict[user['email']] = user
  90         return users_dict
  91
  92
  93     def reserve_nodes(self, login, exp_name,
  94                       nodes_list, start_time, duration):
  95         """
  96         Submit a physical experiment (nodes list) and reservation date.
  97         """
  98         # pylint:disable=W0212,R0913,E1123
  99         logger.warning("iotlashell reserve_nodes")
 100         exp_file = helpers.FilesDict()
 101         _experiment = experiment._Experiment(exp_name, duration, start_time)
 102         _experiment.type = 'physical'
 103         _experiment.nodes = nodes_list
 104         exp_file['new_exp.json'] = helpers.json_dumps(_experiment)
 105         try:
 106             return self.api.method('admin/experiments?user=%s' % login,
 107                                    'post',
 108                                    files=exp_file)
 109         except HTTPError as err:
 110             logger.warning("iotlashell reserve_nodes error %s" % err.reason)
 111             return {'error' : err.reason}
 112
 113
 114     def get_reserved_nodes(self):
 115         """
 116         Get all OAR jobs with state Waiting or Running.
 117
 118         :Example:
 119         {"total":"1907",
 120          "items":[
 121              {"id":9960,
 122               "resources": ["m3-16.devgrenoble.iot-lab.info",...],
 123               "duration":"36000",
 124               "name":"test_sniffer",
 125               "state":"Running",
 126               "owner":"saintmar",
 127               "nb_resources":10,
 128               "date":1427966468},
 129               {"id": ...}
 130          ]
 131         }
 132         """
 133         logger.warning("iotlashell get_reserved_nodes")
 134         reserved_nodes_dict = {}
 135         request = 'admin/experiments?state=Running,Waiting'
 136         try:
 137             experiments = self.api.method(request)
 138         except HTTPError as err:
 139             logger.warning("iotlashell get_reserved_nodes error %s" %
 140                            err.reason)
 141             return {'error' : err.reason}
 142         for exp in experiments['items']:
 143             # BUG IN OAR REST API : job with reservation didn't return
 144             # resources attribute list
 145             # we use another request for finding job resources
 146             exp_nodes = self.api.method('admin/experiments/%d' % exp['id'])
 147             exp['resources'] = exp_nodes['nodes']
 148             reserved_nodes_dict[exp['id']] = exp
 149         return reserved_nodes_dict
 150
 151
 152     def add_user(self, slice_user):
 153         """
 154         Add LDAP user
 155         """
 156         # pylint:disable=E1123
 157         logger.warning("iotlashell add_user")
 158         user = {"type" : "SA", # single account creation
 159                 "city" : "To be defined",
 160                 "country" : "To be defined",
 161                 "motivations" : "SFA federation"}
 162         email = slice_user['email']
 163         user['email'] = email
 164         user['sshPublicKey'] = slice_user['keys'][0]
 165         # ex : onelab.inria
 166         user['structure'] = slice_user['slice_record']['authority']
 167         email = (email.split('@'))[0]
 168         user['firstName'] = email.split('.')[0]
 169         try:
 170             user['lastName'] = email.split('.')[1]
 171         except IndexError:
 172             user['lastName'] = email.split('.')[0]
 173         try:
 174             self.api.method('admin/users', 'post',
 175                         json=user)
 176         except HTTPError as err:
 177             logger.warning("iotlashell add_user error %s" % err.reason)
 178