Esempio n. 1
0
    def test_all_objects(self):
        # create console
        # find agents
        # synchronous query for all objects by schema_id
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                              agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for agent_app in self.agents:
            agent = self.console.find_agent(agent_app.agent.get_name(), timeout=3)
            self.assertTrue(agent and agent.get_name() == agent_app.agent.get_name())

            # get a list of all schema_ids
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_SCHEMA_ID)
            sid_list = self.console.do_query(agent, query)
            self.assertTrue(sid_list and len(sid_list) == _SCHEMAS_PER_AGENT)
            for sid in sid_list:
                query = QmfQuery.create_wildcard_object(sid)
                obj_list = self.console.do_query(agent, query)
                self.assertTrue(obj_list and
                                len(obj_list) == _OBJS_PER_AGENT)
                for obj in obj_list:
                    self.assertTrue(isinstance(obj,
                                               qmf2.console.QmfConsoleData))

        self.console.destroy(10)
Esempio n. 2
0
    def test_all_objects(self):
        # create console
        # find agents
        # synchronous query for all objects by schema_id
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for agent_app in self.agents:
            agent = self.console.find_agent(agent_app.agent.get_name(),
                                            timeout=3)
            self.assertTrue(agent
                            and agent.get_name() == agent_app.agent.get_name())

            # get a list of all schema_ids
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_SCHEMA_ID)
            sid_list = self.console.do_query(agent, query)
            self.assertTrue(sid_list and len(sid_list) == _SCHEMAS_PER_AGENT)
            for sid in sid_list:
                query = QmfQuery.create_wildcard_object(sid)
                obj_list = self.console.do_query(agent, query)
                self.assertTrue(obj_list and len(obj_list) == _OBJS_PER_AGENT)
                for obj in obj_list:
                    self.assertTrue(
                        isinstance(obj, qmf2.console.QmfConsoleData))

        self.console.destroy(10)
Esempio n. 3
0
    def test_described_obj(self):
        # create console
        # find agents
        # synchronous query for all objects in schema
        # method call on each object
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        i_count = 0
        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            query = QmfQuery.create_wildcard(QmfQuery.TARGET_SCHEMA_ID)

            sid_list = self.console.do_query(agent, query)
            self.assertTrue(sid_list and len(sid_list) == 1)
            for sid in sid_list:
                t_params = {QmfData.KEY_SCHEMA_ID: sid}
                query = QmfQuery.create_wildcard(QmfQuery.TARGET_OBJECT,
                                                _target_params=t_params)
                obj_list = self.console.do_query(agent, query)
                self.assertTrue(len(obj_list) == 2)
                for obj in obj_list:
                    cookie = "cookie-" + str(i_count)
                    i_count += 1
                    mr = obj.invoke_method( "set_meth", 
                                            {"arg_int": -99,
                                             "arg_str": "Now set!",
                                             "cookie": cookie},
                                            _reply_handle=cookie,
                                            _timeout=3)
                    self.assertTrue(mr)

        # done, now wait for async responses

        r_count = 0
        while self.notifier.wait_for_work(3):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                r_count += 1
                self.assertTrue(wi.get_type() == WorkItem.METHOD_RESPONSE)
                reply = wi.get_params()
                self.assertTrue(isinstance(reply, qmf2.console.MethodResult))
                self.assertTrue(reply.succeeded())
                self.assertTrue(reply.get_argument("cookie") == wi.get_handle())

                wi = self.console.get_next_workitem(timeout=0)

        self.assertTrue(r_count == i_count)

        self.console.destroy(10)
Esempio n. 4
0
    def test_predicate_match_integer(self):
        # create console
        # find agents
        # synchronous query for all objects with a value named
        #   "index1" which is < or equal to various values
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                              agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            # Query the unmanaged (no schema) objects

            # == 50
            query = QmfQuery.create_predicate(QmfQuery.TARGET_OBJECT,
                    [QmfQuery.AND,
                     [QmfQuery.EXISTS, [QmfQuery.QUOTE, "index1"]],
                     [QmfQuery.EQ, "index1", 50]])

            obj_list = self.console.do_query(agent, query)
            self.assertTrue(len(obj_list) == 1)
            self.assertTrue(obj_list[0].has_value("index1"))
            self.assertTrue(obj_list[0].get_value("index1") == 50)

            # <= 50
            query = QmfQuery.create_predicate(QmfQuery.TARGET_OBJECT,
                    [QmfQuery.AND,
                     [QmfQuery.EXISTS, [QmfQuery.QUOTE, "index1"]],
                     [QmfQuery.LE, "index1", 50]])

            obj_list = self.console.do_query(agent, query)
            self.assertTrue(len(obj_list) == 3)
            for obj in obj_list:
                self.assertTrue(obj.has_value("index1"))
                self.assertTrue(obj.get_value("index1") <= 50)


            # > 50
            query = QmfQuery.create_predicate(QmfQuery.TARGET_OBJECT,
                    [QmfQuery.AND,
                     [QmfQuery.EXISTS, [QmfQuery.QUOTE, "index1"]],
                     [QmfQuery.GT, "index1", 50]])

            obj_list = self.console.do_query(agent, query)
            self.assertTrue(len(obj_list) == 1)
            for obj in obj_list:
                self.assertTrue(obj.has_value("index1"))
                self.assertTrue(obj.get_value("index1") > 50)

        self.console.destroy(10)
Esempio n. 5
0
    def test_predicate_match_integer(self):
        # create console
        # find agents
        # synchronous query for all objects with a value named
        #   "index1" which is < or equal to various values
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            # Query the unmanaged (no schema) objects

            # == 50
            query = QmfQuery.create_predicate(QmfQuery.TARGET_OBJECT, [
                QmfQuery.AND, [QmfQuery.EXISTS, [QmfQuery.QUOTE, "index1"]],
                [QmfQuery.EQ, "index1", 50]
            ])

            obj_list = self.console.do_query(agent, query)
            self.assertTrue(len(obj_list) == 1)
            self.assertTrue(obj_list[0].has_value("index1"))
            self.assertTrue(obj_list[0].get_value("index1") == 50)

            # <= 50
            query = QmfQuery.create_predicate(QmfQuery.TARGET_OBJECT, [
                QmfQuery.AND, [QmfQuery.EXISTS, [QmfQuery.QUOTE, "index1"]],
                [QmfQuery.LE, "index1", 50]
            ])

            obj_list = self.console.do_query(agent, query)
            self.assertTrue(len(obj_list) == 3)
            for obj in obj_list:
                self.assertTrue(obj.has_value("index1"))
                self.assertTrue(obj.get_value("index1") <= 50)

            # > 50
            query = QmfQuery.create_predicate(QmfQuery.TARGET_OBJECT, [
                QmfQuery.AND, [QmfQuery.EXISTS, [QmfQuery.QUOTE, "index1"]],
                [QmfQuery.GT, "index1", 50]
            ])

            obj_list = self.console.do_query(agent, query)
            self.assertTrue(len(obj_list) == 1)
            for obj in obj_list:
                self.assertTrue(obj.has_value("index1"))
                self.assertTrue(obj.get_value("index1") > 50)

        self.console.destroy(10)
Esempio n. 6
0
    def test_all_oids(self):
        # create console
        # find agents
        # synchronous query for all schemas
        # synchronous query for all objects per schema
        # verify known object ids are returned
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                              agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            # first, find objects per schema
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_SCHEMA_ID)
            sid_list = self.console.do_query(agent, query)
            self.assertTrue(sid_list and len(sid_list) == 1)
            for sid in sid_list:
                t_params = {QmfData.KEY_SCHEMA_ID: sid}
                query = QmfQuery.create_wildcard(QmfQuery.TARGET_OBJECT_ID,
                                                _target_params=t_params)

                oid_list = self.console.do_query(agent, query)

                self.assertTrue(isinstance(oid_list, type([])), 
                                "Unexpected return type")
                self.assertTrue(len(oid_list) == 3, "Wrong count")
                self.assertTrue('100a name' in oid_list)
                self.assertTrue('99another name' in oid_list)
                self.assertTrue('50my name' in oid_list)
                self.assertTrue('01545' not in oid_list)


            # now, find all unmanaged objects (no schema)
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_OBJECT_ID)
            oid_list = self.console.do_query(agent, query)

            self.assertTrue(isinstance(oid_list, type([])), 
                            "Unexpected return type")
            self.assertTrue(len(oid_list) == 4, "Wrong count")
            self.assertTrue('100a name' not in oid_list)
            self.assertTrue('99another name' not in oid_list)
            self.assertTrue('01545' in oid_list)
            self.assertTrue('01544' in oid_list)
            self.assertTrue('01543' in oid_list)
            self.assertTrue('01546' in oid_list)

        self.console.destroy(10)
Esempio n. 7
0
    def test_all_oids(self):
        # create console
        # find agents
        # synchronous query for all schemas
        # synchronous query for all objects per schema
        # verify known object ids are returned
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            # first, find objects per schema
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_SCHEMA_ID)
            sid_list = self.console.do_query(agent, query)
            self.assertTrue(sid_list and len(sid_list) == 1)
            for sid in sid_list:
                t_params = {QmfData.KEY_SCHEMA_ID: sid}
                query = QmfQuery.create_wildcard(QmfQuery.TARGET_OBJECT_ID,
                                                 _target_params=t_params)

                oid_list = self.console.do_query(agent, query)

                self.assertTrue(isinstance(oid_list, type([])),
                                "Unexpected return type")
                self.assertTrue(len(oid_list) == 3, "Wrong count")
                self.assertTrue('100a name' in oid_list)
                self.assertTrue('99another name' in oid_list)
                self.assertTrue('50my name' in oid_list)
                self.assertTrue('01545' not in oid_list)

            # now, find all unmanaged objects (no schema)
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_OBJECT_ID)
            oid_list = self.console.do_query(agent, query)

            self.assertTrue(isinstance(oid_list, type([])),
                            "Unexpected return type")
            self.assertTrue(len(oid_list) == 4, "Wrong count")
            self.assertTrue('100a name' not in oid_list)
            self.assertTrue('99another name' not in oid_list)
            self.assertTrue('01545' in oid_list)
            self.assertTrue('01544' in oid_list)
            self.assertTrue('01543' in oid_list)
            self.assertTrue('01546' in oid_list)

        self.console.destroy(10)
Esempio n. 8
0
    def test_direct_oids(self):
        # create console
        # find agents
        # synchronous query for each objects
        # verify objects and schemas are correct
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                              agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            # first, find objects per schema
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_SCHEMA_ID)
            sid_list = self.console.do_query(agent, query)
            self.assertTrue(sid_list and len(sid_list) == 1)

            for oid in ['100a name', '99another name']:
                query = QmfQuery.create_id_object(oid, sid_list[0])
                obj_list = self.console.do_query(agent, query)

                self.assertTrue(isinstance(obj_list, type([])), 
                                "Unexpected return type")
                self.assertTrue(len(obj_list) == 1)
                obj = obj_list[0]
                self.assertTrue(isinstance(obj, QmfData))
                self.assertTrue(obj.get_object_id() == oid)
                self.assertTrue(obj.get_schema_class_id() == sid_list[0])
                schema_id = obj.get_schema_class_id()
                self.assertTrue(isinstance(schema_id, SchemaClassId))
                self.assertTrue(obj.is_described())

            # now find schema-less objects
            for oid in ['01545']:
                query = QmfQuery.create_id_object(oid)
                obj_list = self.console.do_query(agent, query)

                self.assertTrue(isinstance(obj_list, type([])), 
                                "Unexpected return type")
                self.assertTrue(len(obj_list) == 1)
                obj = obj_list[0]
                self.assertTrue(isinstance(obj, QmfData))
                self.assertTrue(obj.get_object_id() == oid)
                self.assertFalse(obj.is_described())

        self.console.destroy(10)
Esempio n. 9
0
    def test_direct_oids(self):
        # create console
        # find agents
        # synchronous query for each objects
        # verify objects and schemas are correct
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            # first, find objects per schema
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_SCHEMA_ID)
            sid_list = self.console.do_query(agent, query)
            self.assertTrue(sid_list and len(sid_list) == 1)

            for oid in ['100a name', '99another name']:
                query = QmfQuery.create_id_object(oid, sid_list[0])
                obj_list = self.console.do_query(agent, query)

                self.assertTrue(isinstance(obj_list, type([])),
                                "Unexpected return type")
                self.assertTrue(len(obj_list) == 1)
                obj = obj_list[0]
                self.assertTrue(isinstance(obj, QmfData))
                self.assertTrue(obj.get_object_id() == oid)
                self.assertTrue(obj.get_schema_class_id() == sid_list[0])
                schema_id = obj.get_schema_class_id()
                self.assertTrue(isinstance(schema_id, SchemaClassId))
                self.assertTrue(obj.is_described())

            # now find schema-less objects
            for oid in ['01545']:
                query = QmfQuery.create_id_object(oid)
                obj_list = self.console.do_query(agent, query)

                self.assertTrue(isinstance(obj_list, type([])),
                                "Unexpected return type")
                self.assertTrue(len(obj_list) == 1)
                obj = obj_list[0]
                self.assertTrue(isinstance(obj, QmfData))
                self.assertTrue(obj.get_object_id() == oid)
                self.assertFalse(obj.is_described())

        self.console.destroy(10)
Esempio n. 10
0
    def test_bad_method_no_schema(self):
        # create console
        # find agents
        # synchronous query for all objects with no schema
        # invalid method call on each object
        #  - should throw a ValueError
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            query = QmfQuery.create_wildcard(QmfQuery.TARGET_OBJECT)

            obj_list = self.console.do_query(agent, query)
            self.assertTrue(len(obj_list) == 1)
            for obj in obj_list:
                self.assertTrue(obj.get_schema_class_id() == None)
                mr = obj.invoke_method("unknown_meth", {
                    "arg1": -99,
                    "arg2": "Now set!"
                },
                                       _timeout=3)
                self.assertTrue(isinstance(mr, qmf2.console.MethodResult))
                self.assertFalse(mr.succeeded())
                self.assertTrue(isinstance(mr.get_exception(), QmfData))

        self.console.destroy(10)
Esempio n. 11
0
    def test_managed_obj(self):
        # create console
        # find agents
        # synchronous query for a managed object
        # method call on each object
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            query = QmfQuery.create_id(QmfQuery.TARGET_OBJECT, "01545")
            obj_list = self.console.do_query(agent, query)

            self.assertTrue(isinstance(obj_list, type([])))
            self.assertTrue(len(obj_list) == 1)
            obj = obj_list[0]

            mr = obj.invoke_method("a_method", {
                "arg1": 1,
                "arg2": "Now set!",
                "arg3": 1966
            },
                                   _timeout=3)
            self.assertTrue(isinstance(mr, qmf2.console.MethodResult))
            self.assertTrue(mr.succeeded())
            self.assertTrue(mr.get_argument("code") == 0)
            # @todo refresh and verify changes

        self.console.destroy(10)
Esempio n. 12
0
    def test_predicate_schema_id(self):
        # create console
        # find agents
        # synchronous query for all schema by package name
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                              agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            query = QmfQuery.create_predicate(QmfQuery.TARGET_SCHEMA,
                                              [QmfQuery.EQ,
                                               SchemaClassId.KEY_PACKAGE, 
                                               [QmfQuery.QUOTE, "MyPackage"]])

            schema_list = self.console.do_query(agent, query)
            self.assertTrue(len(schema_list))
            for schema in schema_list:
                self.assertTrue(schema.get_class_id().get_package_name() ==
                                "MyPackage")


        self.console.destroy(10)
Esempio n. 13
0
    def test_all_schema(self):
        # create console
        # find agents
        # synchronous query for all schemas
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for agent_app in self.agents:
            agent = self.console.find_agent(agent_app.agent.get_name(),
                                            timeout=3)
            self.assertTrue(agent
                            and agent.get_name() == agent_app.agent.get_name())

            # get a list of all schema_ids
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_SCHEMA)
            schema_list = self.console.do_query(agent, query)
            self.assertTrue(schema_list
                            and len(schema_list) == _SCHEMAS_PER_AGENT)
            for schema in schema_list:
                self.assertTrue(isinstance(schema, SchemaObjectClass))

        self.console.destroy(10)
Esempio n. 14
0
    def test_managed_obj(self):
        # create console
        # find agents
        # synchronous query for a managed object
        # method call on each object
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier, agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            query = QmfQuery.create_id(QmfQuery.TARGET_OBJECT, "01545")
            obj_list = self.console.do_query(agent, query)

            self.assertTrue(isinstance(obj_list, type([])))
            self.assertTrue(len(obj_list) == 1)
            obj = obj_list[0]

            mr = obj.invoke_method("a_method", {"arg1": 1, "arg2": "Now set!", "arg3": 1966}, _timeout=3)
            self.assertTrue(isinstance(mr, qmf2.console.MethodResult))
            self.assertTrue(mr.succeeded())
            self.assertTrue(mr.get_argument("code") == 0)
            # @todo refresh and verify changes

        self.console.destroy(10)
Esempio n. 15
0
    def test_all_schema_id(self):
        # create console
        # find agents
        # synchronous query for all schemas_ids
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for agent_app in self.agents:
            agent = self.console.find_agent(agent_app.agent.get_name(),
                                            timeout=3)
            self.assertTrue(agent
                            and agent.get_name() == agent_app.agent.get_name())

            # get a list of all schema_ids
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_SCHEMA_ID)
            sid_list = self.console.do_query(agent, query)
            self.assertTrue(sid_list and len(sid_list) == _SCHEMAS_PER_AGENT)
            for sid in sid_list:
                self.assertTrue(isinstance(sid, SchemaClassId))
                self.assertTrue(sid.get_package_name() == "MyPackage")
                self.assertTrue(
                    sid.get_class_name().split('-')[0] == "MyClass")

        self.console.destroy(10)
Esempio n. 16
0
    def test_all_schema_id(self):
        # create console
        # find agents
        # synchronous query for all schemas_ids
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                              agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for agent_app in self.agents:
            agent = self.console.find_agent(agent_app.agent.get_name(), timeout=3)
            self.assertTrue(agent and agent.get_name() == agent_app.agent.get_name())

            # get a list of all schema_ids
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_SCHEMA_ID)
            sid_list = self.console.do_query(agent, query)
            self.assertTrue(sid_list and len(sid_list) == _SCHEMAS_PER_AGENT)
            for sid in sid_list:
                self.assertTrue(isinstance(sid, SchemaClassId))
                self.assertTrue(sid.get_package_name() == "MyPackage")
                self.assertTrue(sid.get_class_name().split('-')[0] == "MyClass")

        self.console.destroy(10)
Esempio n. 17
0
    def test_bad_method_no_schema(self):
        # create console
        # find agents
        # synchronous query for all objects with no schema
        # invalid method call on each object
        #  - should throw a ValueError
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier, agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            query = QmfQuery.create_wildcard(QmfQuery.TARGET_OBJECT)

            obj_list = self.console.do_query(agent, query)
            self.assertTrue(len(obj_list) == 1)
            for obj in obj_list:
                self.assertTrue(obj.get_schema_class_id() == None)
                mr = obj.invoke_method("unknown_meth", {"arg1": -99, "arg2": "Now set!"}, _timeout=3)
                self.assertTrue(isinstance(mr, qmf2.console.MethodResult))
                self.assertFalse(mr.succeeded())
                self.assertTrue(isinstance(mr.get_exception(), QmfData))

        self.console.destroy(10)
Esempio n. 18
0
    def test_predicate_schema_id(self):
        # create console
        # find agents
        # synchronous query for all schema by package name
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            query = QmfQuery.create_predicate(QmfQuery.TARGET_SCHEMA, [
                QmfQuery.EQ, SchemaClassId.KEY_PACKAGE,
                [QmfQuery.QUOTE, "MyPackage"]
            ])

            schema_list = self.console.do_query(agent, query)
            self.assertTrue(len(schema_list))
            for schema in schema_list:
                self.assertTrue(
                    schema.get_class_id().get_package_name() == "MyPackage")

        self.console.destroy(10)
Esempio n. 19
0
    def test_described_obj(self):
        # create console
        # find agents
        # synchronous query for all objects in schema
        # method call on each object
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            query = QmfQuery.create_wildcard(QmfQuery.TARGET_SCHEMA_ID)

            sid_list = self.console.do_query(agent, query)
            self.assertTrue(sid_list and len(sid_list) == 1)
            for sid in sid_list:
                t_params = {QmfData.KEY_SCHEMA_ID: sid}
                query = QmfQuery.create_wildcard(QmfQuery.TARGET_OBJECT,
                                                 _target_params=t_params)
                obj_list = self.console.do_query(agent, query)
                self.assertTrue(len(obj_list) == 2)
                for obj in obj_list:
                    mr = obj.invoke_method("set_meth", {
                        "arg_int": -99,
                        "arg_str": "Now set!"
                    },
                                           _timeout=3)
                    self.assertTrue(isinstance(mr, qmf2.console.MethodResult))
                    self.assertTrue(mr.succeeded())
                    self.assertTrue(mr.get_argument("code") == 0)

                    self.assertTrue(obj.get_value("method_call_count") == 0)
                    self.assertTrue(obj.get_value("set_string") == "UNSET")
                    self.assertTrue(obj.get_value("set_int") == 0)

                    obj.refresh()

                    self.assertTrue(obj.get_value("method_call_count") == 1)
                    self.assertTrue(obj.get_value("set_string") == "Now set!")
                    self.assertTrue(obj.get_value("set_int") == -99)

        self.console.destroy(10)
Esempio n. 20
0
    def test_bad_method_schema(self):
        # create console
        # find agents
        # synchronous query for all objects with schema
        # invalid method call on each object
        #  - should throw a ValueError - NOT YET.
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            query = QmfQuery.create_wildcard(QmfQuery.TARGET_SCHEMA_ID)

            sid_list = self.console.do_query(agent, query)
            self.assertTrue(sid_list and len(sid_list) == 1)
            for sid in sid_list:

                t_params = {QmfData.KEY_SCHEMA_ID: sid}
                query = QmfQuery.create_predicate(QmfQuery.TARGET_OBJECT,
                                                  [QmfQuery.TRUE],
                                                  _target_params=t_params)

                obj_list = self.console.do_query(agent, query)
                self.assertTrue(len(obj_list) == 2)
                for obj in obj_list:
                    mr = obj.invoke_method("unknown_method", {
                        "arg1": -99,
                        "arg2": "Now set!"
                    },
                                           _timeout=3)
                    # self.failUnlessRaises(ValueError,
                    #                       obj.invoke_method,
                    #                       "unknown_meth",
                    #                       {"arg1": -99, "arg2": "Now set!"},
                    #                       _timeout=3)
                    self.assertTrue(isinstance(mr, qmf2.console.MethodResult))
                    self.assertFalse(mr.succeeded())
                    self.assertTrue(isinstance(mr.get_exception(), QmfData))

        self.console.destroy(10)
Esempio n. 21
0
    def test_predicate_match_string(self):
        # create console
        # find agents
        # synchronous query for all objects with a value named
        #   set_string which is < or equal to "UNSET"
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            # get the schema id for MyPackage:MyClass schema
            query = QmfQuery.create_predicate(QmfQuery.TARGET_SCHEMA_ID, [
                QmfQuery.AND,
                [
                    QmfQuery.EQ, SchemaClassId.KEY_PACKAGE,
                    [QmfQuery.QUOTE, "MyPackage"]
                ],
                [
                    QmfQuery.EQ, SchemaClassId.KEY_CLASS,
                    [QmfQuery.QUOTE, "MyClass"]
                ]
            ])
            sid_list = self.console.do_query(agent, query)
            self.assertTrue(len(sid_list) == 1)

            query = QmfQuery.create_predicate(
                QmfQuery.TARGET_OBJECT, [
                    QmfQuery.AND,
                    [QmfQuery.EXISTS, [QmfQuery.QUOTE, "set_string"]],
                    [QmfQuery.EQ, "set_string", [QmfQuery.QUOTE, "UNSET"]]
                ],
                _target_params={QmfData.KEY_SCHEMA_ID: sid_list[0]})
            obj_list = self.console.do_query(agent, query)
            self.assertTrue(len(obj_list) == 2)
            for obj in obj_list:
                self.assertTrue(obj.has_value("set_string"))
                self.assertTrue(obj.get_value("set_string") == "UNSET")

        self.console.destroy(10)
Esempio n. 22
0
    def test_query_expiration(self):
        # create console
        # find agents
        # kill the agents
        # send async query
        # wait for & verify expiration
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=30)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        # find the agents
        agents = []
        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)
            agents.append(agent)

        # now nuke the agents from orbit.  It's the only way to be sure.

        self.agent1.stop_app()
        self.agent1 = None
        self.agent2.stop_app()
        self.agent2 = None

        # now send queries to agents that no longer exist
        for agent in agents:
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_SCHEMA)
            rc = self.console.do_query(agent,
                                       query,
                                       _reply_handle=agent.get_name(),
                                       _timeout=2)
            self.assertTrue(rc)

        # done.  Now wait for async responses due to timeouts

        count = 0
        while self.notifier.wait_for_work(3):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                count += 1
                self.assertTrue(wi.get_type() == WorkItem.QUERY_COMPLETE)
                self.assertTrue(wi.get_handle() == "agent1"
                                or wi.get_handle() == "agent2")
                reply = wi.get_params()
                self.assertTrue(len(reply) == 0)  # empty

                self.console.release_workitem(wi)
                wi = self.console.get_next_workitem(timeout=0)

        self.assertTrue(count == 2)
        self.console.destroy(10)
Esempio n. 23
0
    def test_all_schemas(self):
        # create console
        # find agents
        # asynchronous query for all schemas
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        # test internal state using non-api calls:
        # no schemas present yet
        self.assertTrue(len(self.console._schema_cache) == 0)
        # end test

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            # send queries
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_SCHEMA)
            rc = self.console.do_query(agent, query, _reply_handle=aname)
            self.assertTrue(rc)

        # done.  Now wait for async responses

        count = 0
        while self.notifier.wait_for_work(3):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                count += 1
                self.assertTrue(wi.get_type() == WorkItem.QUERY_COMPLETE)
                self.assertTrue(wi.get_handle() == "agent1"
                                or wi.get_handle() == "agent2")
                reply = wi.get_params()
                self.assertTrue(len(reply) == 1)
                self.assertTrue(
                    isinstance(reply[0], qmf2.common.SchemaObjectClass))
                self.assertTrue(
                    reply[0].get_class_id().get_package_name() == "MyPackage")
                self.assertTrue(
                    reply[0].get_class_id().get_class_name() == "MyClass")
                self.console.release_workitem(wi)
                wi = self.console.get_next_workitem(timeout=0)

        self.assertTrue(count == 2)

        # test internal state using non-api calls:
        # schema has been learned
        self.assertTrue(len(self.console._schema_cache) == 1)
        # end test

        self.console.destroy(10)
Esempio n. 24
0
    def test_described_obj(self):
        # create console
        # find agents
        # synchronous query for all objects in schema
        # method call on each object
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier, agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            query = QmfQuery.create_wildcard(QmfQuery.TARGET_SCHEMA_ID)

            sid_list = self.console.do_query(agent, query)
            self.assertTrue(sid_list and len(sid_list) == 1)
            for sid in sid_list:
                t_params = {QmfData.KEY_SCHEMA_ID: sid}
                query = QmfQuery.create_wildcard(QmfQuery.TARGET_OBJECT, _target_params=t_params)
                obj_list = self.console.do_query(agent, query)
                self.assertTrue(len(obj_list) == 2)
                for obj in obj_list:
                    mr = obj.invoke_method("set_meth", {"arg_int": -99, "arg_str": "Now set!"}, _timeout=3)
                    self.assertTrue(isinstance(mr, qmf2.console.MethodResult))
                    self.assertTrue(mr.succeeded())
                    self.assertTrue(mr.get_argument("code") == 0)

                    self.assertTrue(obj.get_value("method_call_count") == 0)
                    self.assertTrue(obj.get_value("set_string") == "UNSET")
                    self.assertTrue(obj.get_value("set_int") == 0)

                    obj.refresh()

                    self.assertTrue(obj.get_value("method_call_count") == 1)
                    self.assertTrue(obj.get_value("set_string") == "Now set!")
                    self.assertTrue(obj.get_value("set_int") == -99)

        self.console.destroy(10)
Esempio n. 25
0
    def test_query_expiration(self):
        # create console
        # find agents
        # kill the agents
        # send async query
        # wait for & verify expiration
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                              agent_timeout=30)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        # find the agents
        agents = []
        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)
            agents.append(agent)

        # now nuke the agents from orbit.  It's the only way to be sure.

        self.agent1.stop_app()
        self.agent1 = None
        self.agent2.stop_app()
        self.agent2 = None

        # now send queries to agents that no longer exist
        for agent in agents:
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_SCHEMA)
            rc = self.console.do_query(agent, query,
                                       _reply_handle=agent.get_name(),
                                       _timeout=2)
            self.assertTrue(rc)

        # done.  Now wait for async responses due to timeouts

        count = 0
        while self.notifier.wait_for_work(3):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                count += 1
                self.assertTrue(wi.get_type() == WorkItem.QUERY_COMPLETE)
                self.assertTrue(wi.get_handle() == "agent1" or
                                wi.get_handle() == "agent2")
                reply = wi.get_params()
                self.assertTrue(len(reply) == 0)  # empty

                self.console.release_workitem(wi)
                wi = self.console.get_next_workitem(timeout=0)

        self.assertTrue(count == 2)
        self.console.destroy(10)
Esempio n. 26
0
    def test_managed_obj(self):
        # create console
        # find agents
        # synchronous query for a managed object
        # method call on each object
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                              agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        i_count = 0
        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            query = QmfQuery.create_id(QmfQuery.TARGET_OBJECT, "01545")
            obj_list = self.console.do_query(agent, query)

            self.assertTrue(isinstance(obj_list, type([])))
            self.assertTrue(len(obj_list) == 1)
            obj = obj_list[0]

            cookie = "cookie-" + str(i_count)
            i_count += 1
            mr = obj.invoke_method("a_method",
                                   {"arg1": 1,
                                    "arg2": "Now set!",
                                    "arg3": 1966,
                                    "cookie": cookie},
                                   _reply_handle=cookie,
                                   _timeout=3)
            self.assertTrue(mr)

        # done, now wait for async responses

        r_count = 0
        while self.notifier.wait_for_work(3):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                r_count += 1
                self.assertTrue(wi.get_type() == WorkItem.METHOD_RESPONSE)
                reply = wi.get_params()
                self.assertTrue(isinstance(reply, qmf2.console.MethodResult))
                self.assertTrue(reply.succeeded())
                self.assertTrue(reply.get_argument("cookie") == wi.get_handle())

                wi = self.console.get_next_workitem(timeout=0)

        self.assertTrue(r_count == i_count)

        self.console.destroy(10)
Esempio n. 27
0
    def test_bad_method_schema(self):
        # create console
        # find agents
        # synchronous query for all objects with schema
        # invalid method call on each object
        #  - should throw a ValueError - NOT YET.
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier, agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            query = QmfQuery.create_wildcard(QmfQuery.TARGET_SCHEMA_ID)

            sid_list = self.console.do_query(agent, query)
            self.assertTrue(sid_list and len(sid_list) == 1)
            for sid in sid_list:

                t_params = {QmfData.KEY_SCHEMA_ID: sid}
                query = QmfQuery.create_predicate(QmfQuery.TARGET_OBJECT, [QmfQuery.TRUE], _target_params=t_params)

                obj_list = self.console.do_query(agent, query)
                self.assertTrue(len(obj_list) == 2)
                for obj in obj_list:
                    mr = obj.invoke_method("unknown_method", {"arg1": -99, "arg2": "Now set!"}, _timeout=3)
                    # self.failUnlessRaises(ValueError,
                    #                       obj.invoke_method,
                    #                       "unknown_meth",
                    #                       {"arg1": -99, "arg2": "Now set!"},
                    #                       _timeout=3)
                    self.assertTrue(isinstance(mr, qmf2.console.MethodResult))
                    self.assertFalse(mr.succeeded())
                    self.assertTrue(isinstance(mr.get_exception(), QmfData))

        self.console.destroy(10)
Esempio n. 28
0
    def test_all_schemas(self):
        # create console
        # find agents
        # asynchronous query for all schemas
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                              agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        # test internal state using non-api calls:
        # no schemas present yet
        self.assertTrue(len(self.console._schema_cache) == 0)
        # end test

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            # send queries
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_SCHEMA)
            rc = self.console.do_query(agent, query, _reply_handle=aname)
            self.assertTrue(rc)

        # done.  Now wait for async responses

        count = 0
        while self.notifier.wait_for_work(3):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                count += 1
                self.assertTrue(wi.get_type() == WorkItem.QUERY_COMPLETE)
                self.assertTrue(wi.get_handle() == "agent1" or
                                wi.get_handle() == "agent2")
                reply = wi.get_params()
                self.assertTrue(len(reply) == 1)
                self.assertTrue(isinstance(reply[0], qmf2.common.SchemaObjectClass))
                self.assertTrue(reply[0].get_class_id().get_package_name() == "MyPackage")
                self.assertTrue(reply[0].get_class_id().get_class_name() == "MyClass")
                self.console.release_workitem(wi)
                wi = self.console.get_next_workitem(timeout=0)

        self.assertTrue(count == 2)

        # test internal state using non-api calls:
        # schema has been learned
        self.assertTrue(len(self.console._schema_cache) == 1)
        # end test

        self.console.destroy(10)
Esempio n. 29
0
    def test_predicate_match_string(self):
        # create console
        # find agents
        # synchronous query for all objects with a value named
        #   set_string which is < or equal to "UNSET"
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                              agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            # get the schema id for MyPackage:MyClass schema
            query = QmfQuery.create_predicate(QmfQuery.TARGET_SCHEMA_ID,
                                              [QmfQuery.AND,
                                               [QmfQuery.EQ, SchemaClassId.KEY_PACKAGE,
                                                [QmfQuery.QUOTE, "MyPackage"]],
                                               [QmfQuery.EQ, SchemaClassId.KEY_CLASS,
                                                [QmfQuery.QUOTE, "MyClass"]]])
            sid_list = self.console.do_query(agent, query)
            self.assertTrue(len(sid_list) == 1)

            query = QmfQuery.create_predicate(QmfQuery.TARGET_OBJECT,
                    [QmfQuery.AND,
                     [QmfQuery.EXISTS, [QmfQuery.QUOTE, "set_string"]],
                     [QmfQuery.EQ, "set_string", [QmfQuery.QUOTE, "UNSET"]]],
                    _target_params={QmfData.KEY_SCHEMA_ID: sid_list[0]})
            obj_list = self.console.do_query(agent, query)
            self.assertTrue(len(obj_list) == 2)
            for obj in obj_list:
                self.assertTrue(obj.has_value("set_string"))
                self.assertTrue(obj.get_value("set_string") == "UNSET")

        self.console.destroy(10)
Esempio n. 30
0
    def test_described_objs(self):
        # create console
        # find agents
        # asynchronous query for all schema-based objects
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            #
            t_params = {
                QmfData.KEY_SCHEMA_ID: SchemaClassId("MyPackage", "MyClass")
            }
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_OBJECT, t_params)
            #
            rc = self.console.do_query(agent, query, _reply_handle=aname)
            self.assertTrue(rc)

        # done.  Now wait for async responses

        count = 0
        while self.notifier.wait_for_work(3):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                count += 1
                self.assertTrue(wi.get_type() == WorkItem.QUERY_COMPLETE)
                self.assertTrue(wi.get_handle() == "agent1"
                                or wi.get_handle() == "agent2")
                reply = wi.get_params()
                self.assertTrue(len(reply) == 3)
                self.assertTrue(
                    isinstance(reply[0], qmf2.console.QmfConsoleData))
                self.assertTrue(reply[0].is_described())  # has schema
                self.console.release_workitem(wi)
                wi = self.console.get_next_workitem(timeout=0)

        self.assertTrue(count == 2)
        # @todo test if the console has learned the corresponding schemas....
        self.console.destroy(10)
Esempio n. 31
0
    def test_described_objs(self):
        # create console
        # find agents
        # asynchronous query for all schema-based objects
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                              agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            #
            t_params = {QmfData.KEY_SCHEMA_ID: SchemaClassId("MyPackage", "MyClass")}
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_OBJECT, t_params)
            #
            rc = self.console.do_query(agent, query, _reply_handle=aname)
            self.assertTrue(rc)

        # done.  Now wait for async responses

        count = 0
        while self.notifier.wait_for_work(3):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                count += 1
                self.assertTrue(wi.get_type() == WorkItem.QUERY_COMPLETE)
                self.assertTrue(wi.get_handle() == "agent1" or
                                wi.get_handle() == "agent2")
                reply = wi.get_params()
                self.assertTrue(len(reply) == 3)
                self.assertTrue(isinstance(reply[0], qmf2.console.QmfConsoleData))
                self.assertTrue(reply[0].is_described()) # has schema
                self.console.release_workitem(wi)
                wi = self.console.get_next_workitem(timeout=0)

        self.assertTrue(count == 2)
        # @todo test if the console has learned the corresponding schemas....
        self.console.destroy(10)
Esempio n. 32
0
    def test_packages(self):
        # create console
        # find agents
        # synchronous query all package names
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            query = QmfQuery.create_wildcard(QmfQuery.TARGET_PACKAGES)
            package_list = self.console.do_query(agent, query)
            self.assertTrue(len(package_list) == 1)
            self.assertTrue('MyPackage' in package_list)

        self.console.destroy(10)
Esempio n. 33
0
    def test_undescribed_objs(self):
        # create console
        # find agents
        # asynchronous query for all non-schema objects
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            # send queries
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_OBJECT)
            rc = self.console.do_query(agent, query, _reply_handle=aname)
            self.assertTrue(rc)

        # done.  Now wait for async responses

        count = 0
        while self.notifier.wait_for_work(3):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                count += 1
                self.assertTrue(wi.get_type() == WorkItem.QUERY_COMPLETE)
                self.assertTrue(wi.get_handle() == "agent1"
                                or wi.get_handle() == "agent2")
                reply = wi.get_params()
                self.assertTrue(len(reply) == 4)
                self.assertTrue(
                    isinstance(reply[0], qmf2.console.QmfConsoleData))
                self.assertFalse(reply[0].is_described())  # no schema
                self.console.release_workitem(wi)
                wi = self.console.get_next_workitem(timeout=0)

        self.assertTrue(count == 2)
        self.console.destroy(10)
Esempio n. 34
0
    def test_undescribed_objs(self):
        # create console
        # find agents
        # asynchronous query for all non-schema objects
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                              agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            # send queries
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_OBJECT)
            rc = self.console.do_query(agent, query, _reply_handle=aname)
            self.assertTrue(rc)

        # done.  Now wait for async responses

        count = 0
        while self.notifier.wait_for_work(3):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                count += 1
                self.assertTrue(wi.get_type() == WorkItem.QUERY_COMPLETE)
                self.assertTrue(wi.get_handle() == "agent1" or
                                wi.get_handle() == "agent2")
                reply = wi.get_params()
                self.assertTrue(len(reply) == 4)
                self.assertTrue(isinstance(reply[0], qmf2.console.QmfConsoleData))
                self.assertFalse(reply[0].is_described()) # no schema
                self.console.release_workitem(wi)
                wi = self.console.get_next_workitem(timeout=0)

        self.assertTrue(count == 2)
        self.console.destroy(10)
Esempio n. 35
0
    def test_packages(self):
        # create console
        # find agents
        # synchronous query all package names
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                              agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for aname in ["agent1", "agent2"]:
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            query = QmfQuery.create_wildcard(QmfQuery.TARGET_PACKAGES)
            package_list = self.console.do_query(agent, query)
            self.assertTrue(len(package_list) == 1)
            self.assertTrue('MyPackage' in package_list)


        self.console.destroy(10)
Esempio n. 36
0
    def test_all_schema(self):
        # create console
        # find agents
        # synchronous query for all schemas
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                              agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        for agent_app in self.agents:
            agent = self.console.find_agent(agent_app.agent.get_name(), timeout=3)
            self.assertTrue(agent and agent.get_name() == agent_app.agent.get_name())

            # get a list of all schema_ids
            query = QmfQuery.create_wildcard(QmfQuery.TARGET_SCHEMA)
            schema_list = self.console.do_query(agent, query)
            self.assertTrue(schema_list and 
                            len(schema_list) == _SCHEMAS_PER_AGENT) 
            for schema in schema_list:
                self.assertTrue(isinstance(schema, SchemaObjectClass))

        self.console.destroy(10)
Esempio n. 37
0
    def test_sync_periodic_publish_noncontinuous(self):
        # create console, find agent
        # subscribe to changes to any object in package1/class1
        # should succeed - verify 1 publish
        # Change noncontinuous property on each publish,
        # should only see 1 publish per each update 
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                              agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        subscriptions = []
        index = 0

        # query to match all objects in schema package1/class1
        sid = SchemaClassId.create("package1", "class1")
        t_params = {QmfData.KEY_SCHEMA_ID: sid}
        query = QmfQuery.create_wildcard(QmfQuery.TARGET_OBJECT,
                                         _target_params=t_params)
        # find an agent
        agent_app = self.agents[0]
        aname = agent_app.agent.get_name()
        agent = self.console.find_agent(aname, timeout=3)
        self.assertTrue(agent and agent.get_name() == aname)

        # setup subscription on agent

        sp = self.console.create_subscription(agent,
                                              query,
                                              "some-handle")
        self.assertTrue(isinstance(sp, qmf2.console.SubscribeParams))
        self.assertTrue(sp.succeeded())
        self.assertTrue(sp.get_error() == None)
        self.assertTrue(sp.get_duration() == 10)
        self.assertTrue(sp.get_publish_interval() == 2)

        # now wait for the (2 * interval) and count the updates
        r_count = 0
        sid = None
        while self.notifier.wait_for_work(4):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                r_count += 1
                self.assertTrue(wi.get_type() == WorkItem.SUBSCRIBE_INDICATION)
                self.assertTrue(wi.get_handle() == "some-handle")
                if r_count == 1:
                    # first indication - returns all matching objects
                    reply = wi.get_params()
                    self.assertTrue(isinstance(reply, type([])))
                    self.assertTrue(len(reply) == 2)
                    for obj in reply:
                        self.assertTrue(isinstance(obj, QmfData))
                        self.assertTrue(obj.get_object_id() == "p1c1_key2" or
                                        obj.get_object_id() == "p1c1_key1")
                        sid = obj.get_schema_class_id()
                        self.assertTrue(isinstance(sid, SchemaClassId))
                        self.assertTrue(sid.get_package_name() == "package1")
                        self.assertTrue(sid.get_class_name() == "class1")

                else:
                    # verify publish of modified object only!
                    reply = wi.get_params()
                    self.assertTrue(isinstance(reply, type([])))
                    self.assertTrue(len(reply) == 1)
                    obj = reply[0]
                    self.assertTrue(isinstance(obj, QmfData))
                    self.assertTrue(obj.get_object_id() == "p1c1_key2")
                    self.assertTrue(obj.get_value("count2") == r_count - 1)
                    # fail test if we receive more than expected
                    self.assertTrue(r_count < 30)


                # now update the noncontinuous field of one of the objects!
                if r_count < 20:
                    self.assertTrue(sid is not None)
                    test_obj = agent_app.agent.get_object("p1c1_key2", sid)
                    self.assertTrue(test_obj is not None)
                    test_obj.set_value("count2", r_count)

                self.console.release_workitem(wi)

                wi = self.console.get_next_workitem(timeout=0)

        # expect at least 1 publish per update
        self.assertTrue(r_count > 10)

        self.console.destroy(10)
Esempio n. 38
0
    def test_sync_refresh(self):
        # create console
        # find one agent
        # subscribe to changes to any object in package1/class1
        # after 3 data indications, refresh
        # verify > 5 more data indications received
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        # query to match object "p1c1_key2" in schema package1/class1
        sid = SchemaClassId.create("package1", "class1")
        query = QmfQuery.create_id_object("p1c1_key2", sid)

        agent_app = self.agents[0]
        aname = agent_app.agent.get_name()
        agent = self.console.find_agent(aname, timeout=3)
        self.assertTrue(agent and agent.get_name() == aname)

        # setup subscription on agent

        sp = self.console.create_subscription(agent, query, "my-handle")
        self.assertTrue(isinstance(sp, qmf2.console.SubscribeParams))
        self.assertTrue(sp.succeeded())
        self.assertTrue(sp.get_error() == None)

        # refresh after three subscribe indications, count all
        # indications to verify refresh worked
        r_count = 0
        while self.notifier.wait_for_work(4):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                r_count += 1
                self.assertTrue(wi.get_type() == WorkItem.SUBSCRIBE_INDICATION)
                reply = wi.get_params()
                self.assertTrue(isinstance(reply, type([])))
                self.assertTrue(len(reply) == 1)
                self.assertTrue(isinstance(reply[0], QmfData))
                self.assertTrue(reply[0].get_object_id() == "p1c1_key2")
                sid = reply[0].get_schema_class_id()
                self.assertTrue(isinstance(sid, SchemaClassId))
                self.assertTrue(sid.get_package_name() == "package1")
                self.assertTrue(sid.get_class_name() == "class1")
                self.assertTrue(wi.get_handle() == "my-handle")

                # count1 is continuous, touching it will force a
                # publish on the interval
                self.assertTrue(sid is not None)
                test_obj = agent_app.agent.get_object("p1c1_key2", sid)
                self.assertTrue(test_obj is not None)
                test_obj.set_value("count1", r_count)

                self.console.release_workitem(wi)

                if r_count == 3:
                    rp = self.console.refresh_subscription(
                        sp.get_subscription_id())
                    self.assertTrue(rp)

                wi = self.console.get_next_workitem(timeout=0)

        # expect 5 publish per subscription, more if refreshed
        self.assertTrue(r_count > 5)

        self.console.destroy(10)
Esempio n. 39
0
    def test_sync_refresh(self):
        # create console
        # find one agent
        # subscribe to changes to any object in package1/class1
        # after 3 data indications, refresh
        # verify > 5 more data indications received
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                              agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        # query to match object "p1c1_key2" in schema package1/class1
        sid = SchemaClassId.create("package1", "class1")
        query = QmfQuery.create_id_object("p1c1_key2", sid)

        agent_app = self.agents[0]
        aname = agent_app.agent.get_name()
        agent = self.console.find_agent(aname, timeout=3)
        self.assertTrue(agent and agent.get_name() == aname)

        # setup subscription on agent

        sp = self.console.create_subscription(agent,
                                              query,
                                              "my-handle")
        self.assertTrue(isinstance(sp, qmf2.console.SubscribeParams))
        self.assertTrue(sp.succeeded())
        self.assertTrue(sp.get_error() == None)

        # refresh after three subscribe indications, count all
        # indications to verify refresh worked
        r_count = 0
        while self.notifier.wait_for_work(4):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                r_count += 1
                self.assertTrue(wi.get_type() == WorkItem.SUBSCRIBE_INDICATION)
                reply = wi.get_params()
                self.assertTrue(isinstance(reply, type([])))
                self.assertTrue(len(reply) == 1)
                self.assertTrue(isinstance(reply[0], QmfData))
                self.assertTrue(reply[0].get_object_id() == "p1c1_key2")
                sid = reply[0].get_schema_class_id()
                self.assertTrue(isinstance(sid, SchemaClassId))
                self.assertTrue(sid.get_package_name() == "package1")
                self.assertTrue(sid.get_class_name() == "class1")
                self.assertTrue(wi.get_handle() == "my-handle")

                # count1 is continuous, touching it will force a
                # publish on the interval
                self.assertTrue(sid is not None)
                test_obj = agent_app.agent.get_object("p1c1_key2", sid)
                self.assertTrue(test_obj is not None)
                test_obj.set_value("count1", r_count)

                self.console.release_workitem(wi)

                if r_count == 3:
                    rp = self.console.refresh_subscription(sp.get_subscription_id())
                    self.assertTrue(rp)

                wi = self.console.get_next_workitem(timeout=0)

        # expect 5 publish per subscription, more if refreshed
        self.assertTrue(r_count > 5)

        self.console.destroy(10)
Esempio n. 40
0
    def test_async_cancel(self):
        # create console
        # find one agent
        # async subscribe to changes to any object in package1/class1
        # cancel after first data indication
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                              agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        # query to match object "p1c1_key2" in schema package1/class1
        sid = SchemaClassId.create("package1", "class1")
        query = QmfQuery.create_id_object("p1c1_key2", sid)

        agent_app = self.agents[0]
        aname = agent_app.agent.get_name()
        agent = self.console.find_agent(aname, timeout=3)
        self.assertTrue(agent and agent.get_name() == aname)

        # setup subscription on agent

        rc = self.console.create_subscription(agent,
                                              query,
                                              "my-handle",
                                              _blocking=False)
        self.assertTrue(rc)

        r_count = 0
        sp = None
        while self.notifier.wait_for_work(4):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                r_count += 1
                if wi.get_type() == WorkItem.SUBSCRIBE_RESPONSE:
                    self.assertTrue(wi.get_handle() == "my-handle")
                    sp = wi.get_params()
                    self.assertTrue(isinstance(sp, qmf2.console.SubscribeParams))
                    self.assertTrue(sp.succeeded())
                    self.assertTrue(sp.get_error() == None)
                else:
                    self.assertTrue(wi.get_type() ==
                                    WorkItem.SUBSCRIBE_INDICATION)
                    # sp better be set up by now!
                    self.assertTrue(isinstance(sp, qmf2.console.SubscribeParams))
                    reply = wi.get_params()
                    self.assertTrue(isinstance(reply, type([])))
                    self.assertTrue(len(reply) == 1)
                    self.assertTrue(isinstance(reply[0], QmfData))
                    self.assertTrue(reply[0].get_object_id() == "p1c1_key2")
                    sid = reply[0].get_schema_class_id()
                    self.assertTrue(isinstance(sid, SchemaClassId))
                    self.assertTrue(sid.get_package_name() == "package1")
                    self.assertTrue(sid.get_class_name() == "class1")
                    self.assertTrue(wi.get_handle() == "my-handle")

                    # count1 is continuous, touching it will force a
                    # publish on the interval
                    self.assertTrue(sid is not None)
                    test_obj = agent_app.agent.get_object("p1c1_key2", sid)
                    self.assertTrue(test_obj is not None)
                    test_obj.set_value("count1", r_count)

                if r_count == 3:
                    self.console.cancel_subscription(sp.get_subscription_id())

                self.console.release_workitem(wi)

                wi = self.console.get_next_workitem(timeout=0)

        # expect cancel after 3 replies
        self.assertTrue(r_count == 3)

        self.console.destroy(10)
Esempio n. 41
0
    def test_sync_by_schema(self):
        # create console
        # find all agents
        # subscribe to changes to any object in package1/class1
        # should succeed - verify 1 publish
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                              agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        subscriptions = []
        index = 0

        # query to match all objects in schema package1/class1
        sid = SchemaClassId.create("package1", "class1")
        t_params = {QmfData.KEY_SCHEMA_ID: sid}
        query = QmfQuery.create_wildcard(QmfQuery.TARGET_OBJECT,
                                         _target_params=t_params)
        for agent_app in self.agents:
            aname = agent_app.agent.get_name()
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            # now subscribe to agent

            sp = self.console.create_subscription(agent,
                                                  query,
                                                  index)
            self.assertTrue(isinstance(sp, qmf2.console.SubscribeParams))
            self.assertTrue(sp.succeeded())
            self.assertTrue(sp.get_error() == None)
            self.assertTrue(sp.get_duration() == 10)
            self.assertTrue(sp.get_publish_interval() == 2)

            subscriptions.append([sp, 0])
            index += 1

        # now wait for the (2 * interval) and count the updates
        r_count = 0
        while self.notifier.wait_for_work(4):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                r_count += 1
                self.assertTrue(wi.get_type() == WorkItem.SUBSCRIBE_INDICATION)
                reply = wi.get_params()
                self.assertTrue(isinstance(reply, type([])))
                self.assertTrue(len(reply) == 2)
                for obj in reply:
                    self.assertTrue(isinstance(obj, QmfData))
                    self.assertTrue(obj.get_object_id() == "p1c1_key2" or
                                    obj.get_object_id() == "p1c1_key1")
                sid = reply[0].get_schema_class_id()
                self.assertTrue(isinstance(sid, SchemaClassId))
                self.assertTrue(sid.get_package_name() == "package1")
                self.assertTrue(sid.get_class_name() == "class1")

                self.assertTrue(wi.get_handle() < len(subscriptions))
                subscriptions[wi.get_handle()][1] += 1

                self.console.release_workitem(wi)

                wi = self.console.get_next_workitem(timeout=0)

        # expect 1 publish per subscription
        self.assertTrue(r_count == 5)
        for ii in range(len(subscriptions)):
            self.assertTrue(subscriptions[ii][1] == 1)

        self.console.destroy(10)
Esempio n. 42
0
print("Starting Connection")
_c = Connection("localhost")
_c.connect()

print("Starting Console")

_notifier = ExampleNotifier()
_myConsole = Console(notifier=_notifier)
_myConsole.addConnection(_c)

# Allow discovery only for the agent named "qmf.testAgent"
# @todo: replace "manual" query construction with
# a formal class-based Query API
_query = QmfQuery.create_predicate(
    QmfQuery.TARGET_AGENT,
    QmfQueryPredicate(
        {QmfQuery.CMP_EQ: [QmfQuery.KEY_AGENT_NAME, "qmf.testAgent"]}))
_myConsole.enable_agent_discovery(_query)

_done = False
while not _done:
    #    try:
    _notifier.waitForWork()

    _wi = _myConsole.get_next_workitem(timeout=0)
    while _wi:
        print("!!! work item received %d:%s" %
              (_wi.get_type(), str(_wi.get_params())))

        if _wi.get_type() == _wi.AGENT_ADDED:
            _agent = _wi.get_params().get("agent")
Esempio n. 43
0
    def test_sync_by_obj_id_schema(self):
        # create console
        # find all agents
        # subscribe to changes to any object in package1/class1
        # should succeed
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                              agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        subscriptions = []
        index = 0

        # query to match object "p2c1_key2" in schema package2/class1
        sid = SchemaClassId.create("package2", "class1")
        query = QmfQuery.create_id_object("p2c1_key2", sid)

        for agent_app in self.agents:
            aname = agent_app.agent.get_name()
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            # now subscribe to agent

            sp = self.console.create_subscription(agent,
                                                  query,
                                                  index)
            self.assertTrue(isinstance(sp, qmf2.console.SubscribeParams))
            self.assertTrue(sp.succeeded())
            self.assertTrue(sp.get_error() == None)

            subscriptions.append([sp, 0])
            index += 1

        # now wait for all subscriptions to expire (2x interval w/o
        # indications)
        r_count = 0
        while self.notifier.wait_for_work(4):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                r_count += 1
                self.assertTrue(wi.get_type() == WorkItem.SUBSCRIBE_INDICATION)
                reply = wi.get_params()
                self.assertTrue(isinstance(reply, type([])))
                self.assertTrue(len(reply) == 1)
                self.assertTrue(isinstance(reply[0], QmfData))
                self.assertTrue(reply[0].get_object_id() == "p2c1_key2")
                sid = reply[0].get_schema_class_id()
                self.assertTrue(isinstance(sid, SchemaClassId))
                self.assertTrue(sid.get_package_name() == "package2")
                self.assertTrue(sid.get_class_name() == "class1")
                self.assertTrue(wi.get_handle() < len(subscriptions))
                subscriptions[wi.get_handle()][1] += 1

                self.console.release_workitem(wi)

                wi = self.console.get_next_workitem(timeout=0)

        # expect 1 publish per subscription
        self.assertTrue(r_count == 5)
        for ii in range(len(subscriptions)):
            self.assertTrue(subscriptions[ii][1] == 1)

        self.console.destroy(10)
Esempio n. 44
0
    def test_sync_by_schema(self):
        # create console
        # find all agents
        # subscribe to changes to any object in package1/class1
        # should succeed - verify 1 publish
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        subscriptions = []
        index = 0

        # query to match all objects in schema package1/class1
        sid = SchemaClassId.create("package1", "class1")
        t_params = {QmfData.KEY_SCHEMA_ID: sid}
        query = QmfQuery.create_wildcard(QmfQuery.TARGET_OBJECT,
                                         _target_params=t_params)
        for agent_app in self.agents:
            aname = agent_app.agent.get_name()
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            # now subscribe to agent

            sp = self.console.create_subscription(agent, query, index)
            self.assertTrue(isinstance(sp, qmf2.console.SubscribeParams))
            self.assertTrue(sp.succeeded())
            self.assertTrue(sp.get_error() == None)
            self.assertTrue(sp.get_duration() == 10)
            self.assertTrue(sp.get_publish_interval() == 2)

            subscriptions.append([sp, 0])
            index += 1

        # now wait for the (2 * interval) and count the updates
        r_count = 0
        while self.notifier.wait_for_work(4):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                r_count += 1
                self.assertTrue(wi.get_type() == WorkItem.SUBSCRIBE_INDICATION)
                reply = wi.get_params()
                self.assertTrue(isinstance(reply, type([])))
                self.assertTrue(len(reply) == 2)
                for obj in reply:
                    self.assertTrue(isinstance(obj, QmfData))
                    self.assertTrue(obj.get_object_id() == "p1c1_key2"
                                    or obj.get_object_id() == "p1c1_key1")
                sid = reply[0].get_schema_class_id()
                self.assertTrue(isinstance(sid, SchemaClassId))
                self.assertTrue(sid.get_package_name() == "package1")
                self.assertTrue(sid.get_class_name() == "class1")

                self.assertTrue(wi.get_handle() < len(subscriptions))
                subscriptions[wi.get_handle()][1] += 1

                self.console.release_workitem(wi)

                wi = self.console.get_next_workitem(timeout=0)

        # expect 1 publish per subscription
        self.assertTrue(r_count == 5)
        for ii in range(len(subscriptions)):
            self.assertTrue(subscriptions[ii][1] == 1)

        self.console.destroy(10)
Esempio n. 45
0
    def test_sync_periodic_publish_noncontinuous(self):
        # create console, find agent
        # subscribe to changes to any object in package1/class1
        # should succeed - verify 1 publish
        # Change noncontinuous property on each publish,
        # should only see 1 publish per each update
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        subscriptions = []
        index = 0

        # query to match all objects in schema package1/class1
        sid = SchemaClassId.create("package1", "class1")
        t_params = {QmfData.KEY_SCHEMA_ID: sid}
        query = QmfQuery.create_wildcard(QmfQuery.TARGET_OBJECT,
                                         _target_params=t_params)
        # find an agent
        agent_app = self.agents[0]
        aname = agent_app.agent.get_name()
        agent = self.console.find_agent(aname, timeout=3)
        self.assertTrue(agent and agent.get_name() == aname)

        # setup subscription on agent

        sp = self.console.create_subscription(agent, query, "some-handle")
        self.assertTrue(isinstance(sp, qmf2.console.SubscribeParams))
        self.assertTrue(sp.succeeded())
        self.assertTrue(sp.get_error() == None)
        self.assertTrue(sp.get_duration() == 10)
        self.assertTrue(sp.get_publish_interval() == 2)

        # now wait for the (2 * interval) and count the updates
        r_count = 0
        sid = None
        while self.notifier.wait_for_work(4):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                r_count += 1
                self.assertTrue(wi.get_type() == WorkItem.SUBSCRIBE_INDICATION)
                self.assertTrue(wi.get_handle() == "some-handle")
                if r_count == 1:
                    # first indication - returns all matching objects
                    reply = wi.get_params()
                    self.assertTrue(isinstance(reply, type([])))
                    self.assertTrue(len(reply) == 2)
                    for obj in reply:
                        self.assertTrue(isinstance(obj, QmfData))
                        self.assertTrue(obj.get_object_id() == "p1c1_key2"
                                        or obj.get_object_id() == "p1c1_key1")
                        sid = obj.get_schema_class_id()
                        self.assertTrue(isinstance(sid, SchemaClassId))
                        self.assertTrue(sid.get_package_name() == "package1")
                        self.assertTrue(sid.get_class_name() == "class1")

                else:
                    # verify publish of modified object only!
                    reply = wi.get_params()
                    self.assertTrue(isinstance(reply, type([])))
                    self.assertTrue(len(reply) == 1)
                    obj = reply[0]
                    self.assertTrue(isinstance(obj, QmfData))
                    self.assertTrue(obj.get_object_id() == "p1c1_key2")
                    self.assertTrue(obj.get_value("count2") == r_count - 1)
                    # fail test if we receive more than expected
                    self.assertTrue(r_count < 30)

                # now update the noncontinuous field of one of the objects!
                if r_count < 20:
                    self.assertTrue(sid is not None)
                    test_obj = agent_app.agent.get_object("p1c1_key2", sid)
                    self.assertTrue(test_obj is not None)
                    test_obj.set_value("count2", r_count)

                self.console.release_workitem(wi)

                wi = self.console.get_next_workitem(timeout=0)

        # expect at least 1 publish per update
        self.assertTrue(r_count > 10)

        self.console.destroy(10)
Esempio n. 46
0
    def test_async_cancel(self):
        # create console
        # find one agent
        # async subscribe to changes to any object in package1/class1
        # cancel after first data indication
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        # query to match object "p1c1_key2" in schema package1/class1
        sid = SchemaClassId.create("package1", "class1")
        query = QmfQuery.create_id_object("p1c1_key2", sid)

        agent_app = self.agents[0]
        aname = agent_app.agent.get_name()
        agent = self.console.find_agent(aname, timeout=3)
        self.assertTrue(agent and agent.get_name() == aname)

        # setup subscription on agent

        rc = self.console.create_subscription(agent,
                                              query,
                                              "my-handle",
                                              _blocking=False)
        self.assertTrue(rc)

        r_count = 0
        sp = None
        while self.notifier.wait_for_work(4):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                r_count += 1
                if wi.get_type() == WorkItem.SUBSCRIBE_RESPONSE:
                    self.assertTrue(wi.get_handle() == "my-handle")
                    sp = wi.get_params()
                    self.assertTrue(
                        isinstance(sp, qmf2.console.SubscribeParams))
                    self.assertTrue(sp.succeeded())
                    self.assertTrue(sp.get_error() == None)
                else:
                    self.assertTrue(
                        wi.get_type() == WorkItem.SUBSCRIBE_INDICATION)
                    # sp better be set up by now!
                    self.assertTrue(
                        isinstance(sp, qmf2.console.SubscribeParams))
                    reply = wi.get_params()
                    self.assertTrue(isinstance(reply, type([])))
                    self.assertTrue(len(reply) == 1)
                    self.assertTrue(isinstance(reply[0], QmfData))
                    self.assertTrue(reply[0].get_object_id() == "p1c1_key2")
                    sid = reply[0].get_schema_class_id()
                    self.assertTrue(isinstance(sid, SchemaClassId))
                    self.assertTrue(sid.get_package_name() == "package1")
                    self.assertTrue(sid.get_class_name() == "class1")
                    self.assertTrue(wi.get_handle() == "my-handle")

                    # count1 is continuous, touching it will force a
                    # publish on the interval
                    self.assertTrue(sid is not None)
                    test_obj = agent_app.agent.get_object("p1c1_key2", sid)
                    self.assertTrue(test_obj is not None)
                    test_obj.set_value("count1", r_count)

                if r_count == 3:
                    self.console.cancel_subscription(sp.get_subscription_id())

                self.console.release_workitem(wi)

                wi = self.console.get_next_workitem(timeout=0)

        # expect cancel after 3 replies
        self.assertTrue(r_count == 3)

        self.console.destroy(10)
Esempio n. 47
0
    def test_sync_by_obj_id_schema(self):
        # create console
        # find all agents
        # subscribe to changes to any object in package1/class1
        # should succeed
        self.notifier = _testNotifier()
        self.console = qmf2.console.Console(notifier=self.notifier,
                                            agent_timeout=3)
        self.conn = qpid.messaging.Connection(self.broker)
        self.conn.open()
        self.console.add_connection(self.conn)

        subscriptions = []
        index = 0

        # query to match object "p2c1_key2" in schema package2/class1
        sid = SchemaClassId.create("package2", "class1")
        query = QmfQuery.create_id_object("p2c1_key2", sid)

        for agent_app in self.agents:
            aname = agent_app.agent.get_name()
            agent = self.console.find_agent(aname, timeout=3)
            self.assertTrue(agent and agent.get_name() == aname)

            # now subscribe to agent

            sp = self.console.create_subscription(agent, query, index)
            self.assertTrue(isinstance(sp, qmf2.console.SubscribeParams))
            self.assertTrue(sp.succeeded())
            self.assertTrue(sp.get_error() == None)

            subscriptions.append([sp, 0])
            index += 1

        # now wait for all subscriptions to expire (2x interval w/o
        # indications)
        r_count = 0
        while self.notifier.wait_for_work(4):
            wi = self.console.get_next_workitem(timeout=0)
            while wi is not None:
                r_count += 1
                self.assertTrue(wi.get_type() == WorkItem.SUBSCRIBE_INDICATION)
                reply = wi.get_params()
                self.assertTrue(isinstance(reply, type([])))
                self.assertTrue(len(reply) == 1)
                self.assertTrue(isinstance(reply[0], QmfData))
                self.assertTrue(reply[0].get_object_id() == "p2c1_key2")
                sid = reply[0].get_schema_class_id()
                self.assertTrue(isinstance(sid, SchemaClassId))
                self.assertTrue(sid.get_package_name() == "package2")
                self.assertTrue(sid.get_class_name() == "class1")
                self.assertTrue(wi.get_handle() < len(subscriptions))
                subscriptions[wi.get_handle()][1] += 1

                self.console.release_workitem(wi)

                wi = self.console.get_next_workitem(timeout=0)

        # expect 1 publish per subscription
        self.assertTrue(r_count == 5)
        for ii in range(len(subscriptions)):
            self.assertTrue(subscriptions[ii][1] == 1)

        self.console.destroy(10)