def create(self, file_name: str, force: bool = False) -> Any: with open(file_name) as f: task_id, error = self.__create_from_json(f.read(), force=force) if error: if task_id: return CommandResult( error="task {} failed: {}".format(task_id, error)) return CommandResult(error=error) return task_id
def load(self, file_name, skip_test): try: definition = self.__read_from_file(file_name) except Exception as exc: return CommandResult( error="Error reading task from file '{}': {}".format( file_name, exc)) if hasattr(definition, 'resources'): definition.resources = { os.path.normpath(res) for res in definition.resources } datadir = sync_wait(Tasks.client.get_datadir()) # TODO: unify GUI and CLI logic rendering_task_state = TaskDesc() rendering_task_state.definition = definition rendering_task_state.task_state.status = TaskStatus.starting if not Tasks.application_logic: Tasks.application_logic = CommandAppLogic.instantiate( Tasks.client, datadir) task_builder = Tasks.application_logic.get_builder( rendering_task_state) task = Task.build_task(task_builder) rendering_task_state.task_state.outputs = task.get_output_names() rendering_task_state.task_state.total_subtasks = task.get_total_tasks() task.header.task_id = str(uuid.uuid4()) if not skip_test: test_task = Task.build_task(task_builder) test_task.header.task_id = str(uuid.uuid4()) queue = Queue() TaskTester(test_task, datadir, success_callback=lambda *a, **kw: queue.put(True), error_callback=lambda *a, **kw: queue.put(a)).run() test_result = queue.get() if test_result is not True: return CommandResult( error="Test failed: {}".format(test_result)) task_dict = DictSerializer.dump(task) task_def = task_dict['task_definition'] task_def['resources'] = list(task_def.get('task_definition', [])) deferred = Tasks.client.create_task(task_dict) return sync_wait(deferred, timeout=1800)
def connect(self, ip, port_): try: sa = SocketAddress(ip, int(port_)) Network.client.connect((sa.address, sa.port)) except Exception as exc: return CommandResult( error="Cannot connect to {}:{}: {}".format(ip, port_, exc))
def show(self, id, sort, current): deferred = Tasks.client.get_tasks(id) result = sync_wait(deferred) if not id: values = [] if current: result = [ t for t in result if TaskStatus(t['status']).is_active() ] for task in result: values.append([ task['id'], Tasks.__format_seconds(task['time_remaining']), str(task['subtasks_count']), task['status'], Tasks.__progress_str(task['progress']) ]) return CommandResult.to_tabular(Tasks.task_table_headers, values, sort=sort) if isinstance(result, dict): result['time_remaining'] = \ Tasks.__format_seconds(result['time_remaining']) result['progress'] = Tasks.__progress_str(result['progress']) return result
def test_command_formatter(self): formatter = CommandFormatter() for prettify in [True, False]: formatter.prettify = prettify self.assertIsNone(formatter.format(None)) self.assertIsNone(formatter.format('')) self.assertEqual(formatter.format('Some text'), 'Some text') if not prettify: self.assertEqual(formatter.format(formatter), DictSerializer.dump(formatter, typed=False)) table_headers = ['First', 'Second', 'Third'] table_values = [ ['value 1', 'value 2', 'value 3'], ['value 1', 'value 2', 'value 3'], ['value 1', 'value 2', 'value 3'], ] tabular_result = CommandResult.to_tabular(table_headers, table_values) tabular_repr = formatter.format(tabular_result) tabular_data_repr = formatter.format(tabular_result.from_tabular()) self.assertIsNotNone(tabular_repr) self.assertIsNotNone(tabular_data_repr) self.assertNotEqual(tabular_data_repr, tabular_repr)
def payments(sort, status): deferred = payments.client.get_payments_list() result = sync_wait(deferred) or [] values = [] if status is not None: result = filter_by_status(result, status) for payment in result: payment_value = float(payment["value"]) payment_fee = payment["fee"] or "" if payment_fee: payment_fee = __value(payment_fee, "ETH") entry = [ to_unicode(payment["subtask"]), to_unicode(payment["payee"]), to_unicode(payment["status"]), __value(payment_value, "GNT"), to_unicode(payment_fee) ] values.append(entry) return CommandResult.to_tabular(payments_table_headers, values, sort=sort)
def payments(sort): deferred = payments.client.get_payments_list() result = sync_wait(deferred) or [] values = [] for payment in result: payment_value = float(payment["value"]) payment_fee = payment["fee"] or u"" if payment_fee: payment_fee = u"{:.1f}%".format(float(payment_fee) * 100 / payment_value) entry = [ payment["subtask"], payment["payee"].encode('hex'), __status(payment), __value(payment_value), payment_fee ] values.append(entry) return CommandResult.to_tabular(payments_table_headers, values, sort=sort)
def test_command_result(self): for data in ['result', '']: result = CommandResult(data) self.assertIs(result.type, CommandResult.PLAIN) with self.assertRaises(TypeError): result.from_tabular() result = CommandResult() self.assertIs(result.type, CommandResult.NONE) with self.assertRaises(TypeError): result.from_tabular() with self.assertRaises(CommandException): CommandResult(error=1)
def set(self, key, value): if not key or key not in Settings.settings: return CommandResult(error=Settings.invalid_key_message) setting = Settings.settings[key] try: value = setting.converter(value) if not setting.validator(value): raise Exception(value) except Exception as exc: return CommandResult( error="Invalid value for {} " "(should be {}): {}".format(key, setting.type, exc)) else: return sync_wait(Settings.client.update_setting(key, value))
def clear(self, provider, requestor): if not provider and not requestor: return CommandResult(error="Target role was not specified " "(provider / requestor)") clear = Resources.client.clear_dir if requestor: return sync_wait(clear(DirectoryType.RECEIVED), timeout=None) elif provider: return sync_wait(clear(DirectoryType.DISTRIBUTED), timeout=None)
def __peers(peers, sort, full): values = [] for peer in peers: values.append([ str(peer['address']), str(peer['port']), Network.__key_id(peer['key_id'], full), unicode(peer['node_name']) ]) return CommandResult.to_tabular(Network.node_table_headers, values, sort=sort)
def incomes(sort): deferred = incomes.client.get_incomes_list() result = sync_wait(deferred) or [] values = [] for income in result: entry = [ income["payer"].encode('hex'), __status(income), __value(float(income["value"])), str(income["block_number"]) ] values.append(entry) return CommandResult.to_tabular(payments_table_headers, values, sort=sort)
def subtasks(self, id, sort): values = [] deferred = Tasks.client.get_subtasks(id) result = sync_wait(deferred) if isinstance(result, list): for subtask in result: values.append([ subtask['node_name'], subtask['subtask_id'], str(subtask['time_remaining']), subtask['status'], Tasks.__progress_str(subtask['progress']) ]) return CommandResult.to_tabular(Tasks.subtask_table_headers, values, sort=sort)
def test_command_formatter_table_format(self): formatter = CommandFormatter() table_headers = ['First', 'Second', 'Third'] table_values = [ ['value 1', 'value 2', 'value 3'], ['value 1', 'value 2', 'value 3'], ['value 1', 'value 2', 'value 3'], ] tabular_result = CommandResult.to_tabular(table_headers, table_values) tabular_repr = formatter.format(tabular_result) tabular_data_repr = formatter.format(tabular_result.from_tabular()) self.assertIsNotNone(tabular_repr) self.assertIsNotNone(tabular_data_repr) self.assertNotEqual(tabular_data_repr, tabular_repr)
def incomes(sort, status): deferred = incomes.client.get_incomes_list() result = sync_wait(deferred) or [] values = [] if status is not None: result = filter_by_status(result, status) for income in result: entry = [ to_unicode(income["payer"]), to_unicode(income["status"]), __value(float(income["value"]), "GNT"), ] values.append(entry) return CommandResult.to_tabular(incomes_table_headers, values, sort=sort)
def __peers(peers, sort, full): values = [] for p in peers: addr = Network.__one_of(p, 'address', 'pub_addr') port = Network.__one_of(p, 'port', 'p2p_pub_port', 'p2p_prv_port') key = Network.__one_of(p, 'key_id', 'key') values.append([ str(addr), str(port), Network.__key_id(key, full), str(p['node_name']), ]) return CommandResult.to_tabular(Network.node_table_headers, values, sort=sort)
def show(self, sort): deferred = Environments.client.get_environments() result = sync_wait(deferred) or [] values = [] for env in result: values.append([ env['id'], str(env['supported']), str(env['accepted']), str(env['performance']), env['description'] ]) return CommandResult.to_tabular(Environments.table_headers, values, sort=sort)
def test_tabular(self): headers = ['1', '2', '3'] values = [ ['d', 'b', 'f'], ['a', 'e', 'c'], ] tabular = CommandResult.to_tabular(headers, values) self.assertEqual(tabular.data, (headers, values)) self.assertEqual(tabular.type, CommandResult.TABULAR) self.assertEqual(tabular.from_tabular(), (headers, values)) tabular = CommandResult.to_tabular(headers, values, sort='4') self.assertEqual(tabular.from_tabular()[1], values) tabular = CommandResult.to_tabular(headers, values, sort='1') self.assertNotEqual(tabular.from_tabular()[1], values) self.assertEqual(tabular.from_tabular()[1], [ ['a', 'e', 'c'], ['d', 'b', 'f'], ]) tabular = CommandResult.to_tabular(headers, values, sort='2') self.assertEqual(tabular.from_tabular()[1], values) tabular = CommandResult.to_tabular(headers, values, sort='3') self.assertNotEqual(tabular.from_tabular()[1], values) self.assertEqual(tabular.from_tabular()[1], [ ['a', 'e', 'c'], ['d', 'b', 'f'], ]) CommandResult.type = CommandResult.NONE with self.assertRaises(TypeError): CommandResult.from_tabular() CommandResult.type = CommandResult.TABULAR
def show(self, id, sort): deferred = Tasks.client.get_tasks(id) result = sync_wait(deferred) if not id: values = [] for task in result or []: values.append([ task['id'], str(task['time_remaining']), str(task['subtasks']), task['status'], Tasks.__progress_str(task['progress']) ]) return CommandResult.to_tabular(Tasks.task_table_headers, values, sort=sort) if isinstance(result, dict): result['progress'] = Tasks.__progress_str(result['progress']) return result
def unsupport(self, last_days): deferred = Tasks.client.get_unsupport_reasons(int(last_days)) result = sync_wait(deferred) values = [[r['reason'], r['ntasks'], r['avg']] for r in result] return CommandResult.to_tabular(Tasks.unsupport_reasons_table_headers, values)
def show(self): res = sync_wait(Resources.client.get_res_dirs_sizes(), timeout=None) return CommandResult.to_tabular(list(res.keys()), [list(res.values())])
def restart(self, id, force: bool = False): deferred = Tasks.client._call('comp.task.restart', id, force=force) # noqa pylint: disable=protected-access new_task_id, error = sync_wait(deferred) if error: return CommandResult(error=error) return new_task_id
def rpc(self, vargs): vargs = list(vargs) alias = vargs.pop(0) status = sync_wait(self.client._call(alias, *vargs)) # noqa pylint: disable=protected-access return CommandResult(status)