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)
