Exemplo n.º 1
0
 def test_update_peers_view(self):
     logic = self.logic
     gui = self.app
     logic.customizer = MainWindowCustomizer(gui.main_window, logic)
     logic.customizer.new_task_dialog_customizer = Mock()
     peer = Mock()
     peer.address = "10.10.10.10"
     peer.port = 1031
     peer.key_id = "KEYID"
     peer.node_name = "NODE 1"
     peer2 = Mock()
     peer2.address = "10.10.10.20"
     peer2.port = 1034
     peer2.key_id = "KEYID2"
     peer2.node_name = "NODE 2"
     logic._update_peers_view(
         [DictSerializer.dump(peer),
          DictSerializer.dump(peer2)])
     table = logic.customizer.gui.ui.connectedPeersTable
     self.assertEqual(table.rowCount(), 2)
     self.assertEqual(table.item(0, 0).text(), "10.10.10.10")
     self.assertEqual(table.item(1, 0).text(), "10.10.10.20")
     self.assertEqual(table.item(0, 1).text(), "1031")
     self.assertEqual(table.item(1, 1).text(), "1034")
     self.assertEqual(table.item(0, 2).text(), "KEYID")
     self.assertEqual(table.item(1, 2).text(), "KEYID2")
     self.assertEqual(table.item(0, 3).text(), "NODE 1")
     self.assertEqual(table.item(1, 3).text(), "NODE 2")
Exemplo n.º 2
0
    def from_dict(dictionary):
        th = DictSerializer.load(dictionary, as_class=TaskHeader)
        th.last_checking = time.time()

        if isinstance(th.task_owner, dict):
            th.task_owner = DictSerializer.load(th.task_owner, as_class=Node)
        if hasattr(th, 'docker_images') and th.docker_images is not None:
            for i, di in enumerate(th.docker_images):
                if isinstance(di, dict):
                    th.docker_images[i] = DictSerializer.load(
                        di, as_class=DockerImage)
        return th
Exemplo n.º 3
0
    def test_properties(self):
        obj = MockSerializationSubject()
        dict_repr = DictSerializer.dump(obj)

        self.assertTrue('property_1' in dict_repr)
        self.assertTrue('property_2' in dict_repr)
        self.assertFalse('_property_3' in dict_repr)
        self.assertFalse('method_1' in dict_repr)
        self.assertFalse('_method_2' in dict_repr)

        deserialized = DictSerializer.load(dict_repr)
        assert_properties(deserialized, obj)
Exemplo n.º 4
0
    def test_serialization_result(self):
        obj = MockSerializationSubject()
        self.assertEqual(
            DictSerializer.dump(obj), {
                'property_1': {
                    'k': 'v',
                    'u': {
                        'property_1':
                        obj.property_1['u'].property_1,
                        'property_3':
                        'string',
                        'property_4': [
                            'list', 'of',
                            ('items', ), obj.property_1['u'].property_4[-1]
                        ],
                        DictCoder.cls_key:
                        ('tests.golem.core.test_simpleserializer'
                         '.MockSerializationInnerSubject')
                    }
                },
                'property_2': {
                    'property_1':
                    obj.property_2.property_1,
                    'property_3':
                    'string',
                    'property_4':
                    ['list', 'of', ('items', ), obj.property_2.property_4[-1]],
                    DictCoder.cls_key:
                    ('tests.golem.core.test_simpleserializer'
                     '.MockSerializationInnerSubject')
                },
                'property_4': [
                    'v', 1, (1, 2, 3), {
                        'property_1':
                        obj.property_4[-1].property_1,
                        'property_3':
                        'string',
                        'property_4': [
                            'list', 'of',
                            ('items', ), obj.property_4[-1].property_4[-1]
                        ],
                        DictCoder.cls_key:
                        ('tests.golem.core.test_simpleserializer'
                         '.MockSerializationInnerSubject')
                    }
                ],
                DictCoder.cls_key: ('tests.golem.core.test_simpleserializer'
                                    '.MockSerializationSubject')
            })

        self.assertFalse(
            DictCoder.cls_key in DictSerializer.dump(obj, typed=False))
Exemplo n.º 5
0
    def test_serialization_result(self):
        obj = MockSerializationSubject()
        self.assertEqual(
            DictSerializer.dump(obj), {
                u'property_1': {
                    u'k': u'v',
                    u'u': {
                        u'property_1':
                        obj.property_1[u'u'].property_1,
                        u'property_3':
                        u'string',
                        u'property_4': [
                            u'list', u'of',
                            (u'items', ), obj.property_1[u'u'].property_4[-1]
                        ],
                        DictCoder.cls_key:
                        u'test_simpleserializer.MockSerializationInnerSubject'
                    }
                },
                u'property_2': {
                    u'property_1':
                    obj.property_2.property_1,
                    u'property_3':
                    u'string',
                    u'property_4': [
                        u'list', u'of',
                        (u'items', ), obj.property_2.property_4[-1]
                    ],
                    DictCoder.cls_key:
                    u'test_simpleserializer.MockSerializationInnerSubject'
                },
                u'property_4': [
                    u'v', 1, (1, 2, 3), {
                        u'property_1':
                        obj.property_4[-1].property_1,
                        u'property_3':
                        u'string',
                        u'property_4': [
                            u'list', u'of',
                            (u'items', ), obj.property_4[-1].property_4[-1]
                        ],
                        DictCoder.cls_key:
                        u'test_simpleserializer.MockSerializationInnerSubject'
                    }
                ],
                DictCoder.cls_key:
                u'test_simpleserializer.MockSerializationSubject'
            })

        self.assertFalse(
            DictCoder.cls_key in DictSerializer.dump(obj, typed=False))
Exemplo n.º 6
0
 def create_task(self, t_dict):
     try:
         task = DictSerializer.load(t_dict)
         new_task = self.enqueue_new_task(task)
         return unicode(new_task.header.task_id)
     except Exception:
         log.exception("Cannot create task {}".format(t_dict))
Exemplo n.º 7
0
    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)
Exemplo n.º 8
0
 def _get_test_task_definition(cls) -> TaskDefinition:
     task_path = Path(__file__).parent / cls.TASK_FILE
     with open(task_path) as f:
         golem_path = get_golem_path()
         json_str = f.read().replace('$GOLEM_DIR',
                                     Path(golem_path).as_posix())
         return DictSerializer.load(json.loads(json_str))
Exemplo n.º 9
0
 def from_dict(dictionary: dict) -> 'TaskHeader':
     th: TaskHeader = DictSerializer.load(dictionary, as_class=TaskHeader)
     if isinstance(th.fixed_header, dict):
         th.fixed_header = TaskFixedHeader.from_dict(th.fixed_header)
     if isinstance(th.mask, dict):
         th.mask = Mask.from_dict(th.mask)
     return th
Exemplo n.º 10
0
    def test_load(self):
        client = self.client
        task_file_name = self._create_blender_task(client.get_dir_manager())

        def run_success(instance):
            instance.success_callback()

        def run_error(instance):
            instance.error_callback()

        with client_ctx(Tasks, client):

            with self._run_context(run_success):

                client.create_task.call_args = None
                client.create_task.called = False

                tasks = Tasks()
                tasks.load(task_file_name, True)

                call_args = client.create_task.call_args[0]
                assert len(call_args) == 1
                assert isinstance(DictSerializer.load(call_args[0]),
                                  BlenderRenderTask)

            with self._run_context(run_error):
                client.create_task.call_args = None
                client.create_task.called = False

                tasks = Tasks()
                tasks.load(task_file_name, True)

                call_args = client.create_task.call_args[0]

                assert len(call_args) == 1
                assert isinstance(DictSerializer.load(call_args[0]),
                                  BlenderRenderTask)

            with self._run_context(run_error):
                client.create_task.call_args = None
                client.create_task.called = False

                tasks = Tasks()

                with self.assertRaises(CommandException):
                    tasks.load(task_file_name, False)
Exemplo n.º 11
0
    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)
Exemplo n.º 12
0
    def test_create_task(self, *_):
        c = self.client
        c.enqueue_new_task = Mock()

        # create a task
        t = Task(TaskHeader("node_name", "task_id", "10.10.10.10", 123,
                            "owner_id", "DEFAULT"),
                 src_code="print('hello')")

        c.create_task(DictSerializer.dump(t))
        self.assertTrue(c.enqueue_new_task.called)
Exemplo n.º 13
0
    def format(self, result):
        result, result_type = self._initial_format(result)

        if result_type != CommandResult.NONE:

            if result_type == CommandResult.TABULAR:
                result = dict(headers=result[0], values=result[1])
            else:
                result = DictSerializer.dump(result, typed=False)

            if self.prettify:
                return json.dumps(result, indent=4, sort_keys=True)
            return json.dumps(result)
Exemplo n.º 14
0
    def test_serialization_as_class(self):

        obj = MockSerializationSubject()
        dict_repr = DictSerializer.dump(obj)

        self.assertTrue(DictCoder.cls_key in dict_repr)
        self.assertTrue('property_1' in dict_repr)
        self.assertTrue('property_2' in dict_repr)
        self.assertTrue(
            isinstance(DictSerializer.load(dict_repr),
                       MockSerializationSubject))

        dict_repr = DictSerializer.dump(obj, typed=False)

        self.assertFalse(DictCoder.cls_key in dict_repr)
        self.assertTrue('property_1' in dict_repr)
        self.assertTrue('property_2' in dict_repr)
        self.assertTrue(isinstance(DictSerializer.load(dict_repr), dict))
        self.assertTrue(
            isinstance(
                DictSerializer.load(dict_repr,
                                    as_class=MockSerializationSubject),
                MockSerializationSubject))
Exemplo n.º 15
0
    def _run_test_task(self, t_dict):
        def on_success(*args, **kwargs):
            self.task_tester = None
            self._publish(Task.evt_task_test_status, TaskTestStatus.success,
                          *args, **kwargs)

        def on_error(*args, **kwargs):
            self.task_tester = None
            self._publish(Task.evt_task_test_status, TaskTestStatus.error,
                          *args, **kwargs)

        t = DictSerializer.load(t_dict)
        self.task_tester = TaskTester(t, self.datadir, on_success, on_error)
        self.task_tester.run()
        self._publish(Task.evt_task_test_status, TaskTestStatus.started, True)
Exemplo n.º 16
0
    def test_node(self, *_):
        c = self.client
        self.assertIsInstance(c.get_node(), dict)
        self.assertIsInstance(DictSerializer.load(c.get_node()), Node)

        self.assertIsInstance(c.get_node_key(), unicode)
        self.assertIsNotNone(c.get_node_key())

        c.node.key = None

        self.assertNotIsInstance(c.get_node_key(), unicode)
        self.assertIsNone(c.get_node_key())

        self.assertIsInstance(c.get_public_key(), bytes)
        self.assertEqual(c.get_public_key(), c.keys_auth.public_key)
Exemplo n.º 17
0
 def build_and_serialize_task(self, task_state, cbk=None):
     tb = self.get_builder(task_state)
     t = Task.build_task(tb)
     t.header.max_price = str(t.header.max_price)
     t_serialized = DictSerializer.dump(t)
     if 'task_definition' in t_serialized:
         t_serialized_def = t_serialized['task_definition']
         t_serialized_def['resources'] = list(t_serialized_def['resources'])
         if 'max_price' in t_serialized_def:
             t_serialized_def['max_price'] = str(
                 t_serialized_def['max_price'])
     from pprint import pformat
     logger.debug('task serialized: %s', pformat(t_serialized))
     if cbk:
         cbk(t)
     return t_serialized
Exemplo n.º 18
0
    def from_dict(dictionary) -> 'TaskFixedHeader':
        if 'subtasks_count' not in dictionary:
            logger.debug(
                "Subtasks count missing. Implicit 1. dictionary=%r",
                dictionary,
            )
            dictionary['subtasks_count'] = 1
        th: TaskFixedHeader = \
            DictSerializer.load(dictionary, as_class=TaskFixedHeader)
        th.last_checking = time.time()

        if isinstance(th.task_owner, dict):
            th.task_owner = Node.from_dict(th.task_owner)

        th.update_checksum()
        return th
Exemplo n.º 19
0
    def task_status_changed(self, task_id):
        if task_id in self.tasks:
            ts_dict = yield self.client.query_task_state(task_id)
            ts = DictSerializer.load(ts_dict)
            if not isinstance(ts, TaskState):
                raise TypeError(
                    "Incorrect task state type: {}. Should be TaskState".
                    format(ts))
            self.tasks[task_id].task_state = ts
            self.customizer.update_tasks(self.tasks)
            if ts.status in task_to_remove_status:
                self.client.delete_task(task_id)
        else:
            logger.warning("Unknown task_id {}".format(task_id))

        if self.customizer.current_task_highlighted.definition.task_id == task_id:
            self.customizer.update_task_additional_info(self.tasks[task_id])
Exemplo n.º 20
0
    def test_task_status_changed(self):
        task_state = TaskState()
        task_dict = DictSerializer.dump(task_state)

        logic = GuiApplicationLogic()
        logic.tasks = dict(task_id=task_state, wrong_task=None)

        def get_logic_task(task_id):
            deferred = Deferred()
            task = logic.tasks.get(task_id)
            deferred.callback(DictSerializer.dump(task))
            return deferred

        logic.client = Mock()
        logic.client.query_task_state = Mock()
        logic.client.query_task_state.side_effect = get_logic_task

        logic.customizer = Mock()

        logic.task_status_changed('wrong_task')
        assert not logic.customizer.update_tasks.called
        assert logic.client.query_task_state.called

        logic.client.query_task_state.called = False
        logic.customizer.current_task_highlighted.definition.task_id = \
            str(uuid.uuid4())
        logic.task_status_changed(str(uuid.uuid4()))
        assert not logic.client.query_task_state.called
        assert not logic.customizer.update_task_additional_info.called

        logic.customizer.current_task_highlighted.definition.task_id = 'task_id'
        logic.task_status_changed(str(uuid.uuid4()))
        assert not logic.client.query_task_state.called
        assert not logic.customizer.update_task_additional_info.called

        logic.task_status_changed('task_id')
        assert logic.client.query_task_state.called
        assert logic.customizer.update_task_additional_info.called
        assert not logic.client.delete_task.called

        task_state.status = task_to_remove_status[0]
        logic.task_status_changed('task_id')
        assert logic.client.query_task_state.called
        assert logic.customizer.update_task_additional_info.called
        assert logic.client.delete_task.called
Exemplo n.º 21
0
    def format(self, result):
        result, result_type = self._initial_format(result)

        if result_type != CommandResult.NONE:

            if result_type == CommandResult.TABULAR:
                return tabulate(result[1], headers=result[0], tablefmt="simple")

            elif isinstance(result, basestring):
                return result

            elif isinstance(result, CommandException):
                return repr(result)

            result = DictSerializer.dump(result, typed=False)

            if self.prettify:
                return yaml.safe_dump(result, allow_unicode=True, default_flow_style=False)
            return result
Exemplo n.º 22
0
    def register_client(self, client):
        # client is golem.rpc.session.Client
        datadir = yield client.get_datadir()
        config_dict = yield client.get_settings()
        client_id = yield client.get_key_id()
        payment_address = yield client.get_payment_address()
        description = yield client.get_description()

        config = DictSerializer.load(config_dict)

        self.client = client
        self.datadir = datadir
        self.node_name = config.node_name
        self.dir_manager = DirManager(self.datadir)

        self.customizer.init_config()
        self.customizer.set_options(config, client_id, payment_address,
                                    description)

        if not self.node_name:
            self.customizer.prompt_node_name(self.node_name)
Exemplo n.º 23
0
 def resolve_call(alias, *args, **kwargs):
     if alias == aliases.Environment.datadir:
         return self.path
     elif alias == aliases.Environment.opts:
         return DictSerializer.dump(ClientConfigDescriptor())
     elif alias == aliases.Environment.opt_description:
         return u'test description'
     elif alias == aliases.Payments.ident:
         return u'0xdeadbeef'
     elif alias == aliases.Crypto.key_id:
         return u'0xbadfad'
     elif alias == aliases.Task.tasks_stats:
         return dict(in_network=0,
                     supported=0,
                     subtasks_computed=0,
                     subtasks_with_errors=0,
                     subtasks_with_timeout=0)
     elif alias == aliases.Payments.balance:
         return 0, 0, 0
     elif alias == aliases.Network.peers_connected:
         return []
     elif alias == aliases.Computation.status:
         return u''
     return 1
Exemplo n.º 24
0
 def get_settings(self):
     return DictSerializer.dump(self.config_desc)
Exemplo n.º 25
0
 def to_dict(self):
     return DictSerializer.dump(self, typed=False)
Exemplo n.º 26
0
 def update_settings(self, settings_dict, run_benchmarks=False):
     cfg_desc = DictSerializer.load(settings_dict)
     self.change_config(cfg_desc, run_benchmarks)
Exemplo n.º 27
0
 def query_task_state(self, task_id):
     state = self.task_server.task_manager.query_task_state(task_id)
     if state:
         return DictSerializer.dump(state)
Exemplo n.º 28
0
 def get_known_tasks(self):
     headers = {}
     for key, header in self.task_server.task_keeper.task_headers.iteritems(
     ):  # noqa
         headers[unicode(key)] = DictSerializer.dump(header)
     return headers
Exemplo n.º 29
0
 def get_config(self):
     config_dict = yield self.client.get_settings()
     returnValue(DictSerializer.load(config_dict))
Exemplo n.º 30
0
 def change_config(self, cfg_desc, run_benchmarks=False):
     cfg_dict = DictSerializer.dump(cfg_desc)
     yield self.client.update_settings(cfg_dict,
                                       run_benchmarks=run_benchmarks)
     self.node_name = yield self.client.get_setting('node_name')
     self.customizer.set_name(u"{}".format(self.node_name))