def rest_api_token(self, expiration=3600): __logger__.debug("getting token @ time %s", time.time()) return get_response('{}/rest-server/api/v1/token'.format(self.pai_uri), body={ 'username': self.user, 'password': self.password, 'expiration': expiration }).json()['token']
def process(self, args): __logger__.debug('Parsed arguments to %s', args) actor = self.actor if self.single_action else self.actions[args.action] actor.check_arguments(args) actor.restore(args) result = actor.do_action(args) actor.store(args) return result
def available_resources(self): my_virtual_clusters = self.rest_api_user()["virtualCluster"] if isinstance(my_virtual_clusters, str): my_virtual_clusters = my_virtual_clusters.split(",") __logger__.debug("user %s belongs to %s", self.user, my_virtual_clusters) resources = self.virtual_cluster_available_resources() return {k: v for k, v in resources.items() if k in my_virtual_clusters}
def __init__(self, pai_uri: str=None, user: str=None, password: str=None, storages: list=[], default_storage_alias: str=None, **kwargs): __logger__.debug('creating cluster from info %s', get_args()) self.pai_uri = pai_uri self.user = user self.password = password self.storages = storages self.default_storage_alias = default_storage_alias self.storage_clients = {} for k, v in kwargs.items(): setattr(self, k, v) for cfg in storages: self.add_storage(**cfg) if len(storages) == 1: self.default_storage_alias = storages[0]["storage_alias"]
def pretty_print_POST(req): """ At this point it is completely built and ready to be fired; it is "prepared". However pay attention at the formatting used in this function because it is programmed to be pretty printed and may differ from the actual request. """ __logger__.debug('{}\n{}\n{}\n\n{}'.format( '-----------START-----------', req.method + ' ' + req.url, '\n'.join('{}: {}'.format(k, v) for k, v in req.headers.items()), req.body, ))
def to_file(obj, fname: str, fmt=None, **kwargs): if not fmt: _, ext = os.path.splitext(fname) if ext in __json_exts__: fmt, dic = json, dict(indent=4) elif ext in __yaml_exts__: import yaml fmt, dic = yaml, dict(default_flow_style=False) else: raise NotImplementedError dic.update(kwargs) else: dic = kwargs with safe_open(fname, 'w') as fp: fmt.dump(obj, fp, **dic) __logger__.debug("serialize object to file %s", fname)
def retry(self, f_exit, func, *args, **kwargs): t, i = 0, 0 while True: try: x = func(*args, **kwargs) if f_exit(x): if not self.silent: to_screen("ready: {}".format(x)) return x except NotReadyError as identifier: __logger__.debug("condition not satisfied", identifier) if not self.silent: to_screen("not ready yet: {}".format(x)) i, t = i + 1, t + self.t_sleep if self.max_try and i >= self.max_try or self.timeout and t >= self.timeout: return None if self.t_sleep: time.sleep(self.t_sleep)
def get_response( path: str, headers: dict = {'Content-Type': 'application/json'}, body: dict = dict(), method: str = 'POST', allowed_status=[200], # type: list[int] max_try: int = 1) -> Response: """ Send request to REST server and get the response. Args: path (str): REST server path headers (dict, optional): Defaults to {'Content-Type': 'application/json'}. request headers body (dict, optional): Defaults to dict(). data body of the request (default is json format) method (str, optional): Defaults to 'POST'. POST / PUT / GET allowed_status (list, optional): Defaults to [200]. raise exception if the status_code of response not in the list Returns: [Response]: request response """ num, successful = 0, False # deal with body format dic = dict(headers=headers) if headers.get('Content-Type', 'application/json'): dic["json"] = body else: dic["data"] = body while num < max_try: num += 1 response = request(method, path, **dic) __logger__.debug('----------Response-------------\n%s', dump.dump_all(response).decode('utf-8')) if response.status_code in allowed_status: successful = True break assert successful, (response.status_code, response.reason) return response
def process(self, a: list): __logger__.debug('Received arguments %s', a) __logger__.debug("Received arguments %s", a) args = self.parser.parse_args(a) return self.process_args(args)
def process_args(self, args): __logger__.debug("Parsed arguments %s", args) if not args.scene: raise ArgumentError return self.scenes[args.scene].process(args)