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)
def __init__(self, name, broker_url, heartbeat): Thread.__init__(self) self.timeout = 3 self.broker_url = broker_url self.notifier = _testNotifier() self.agent = Agent(name, _notifier=self.notifier, heartbeat_interval=heartbeat) # Dynamically construct a management database _schema = SchemaEventClass(_classId=SchemaClassId( "MyPackage", "MyClass", stype=SchemaClassId.TYPE_EVENT), _desc="A test event schema") # add properties _schema.add_property("prop-1", SchemaProperty(qmfTypes.TYPE_UINT8)) _schema.add_property("prop-2", SchemaProperty(qmfTypes.TYPE_LSTR)) # Add schema to Agent self.schema = _schema self.agent.register_object_class(_schema) self.running = False self.ready = Event()
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)
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)
def __init__(self, name, broker_url, heartbeat): Thread.__init__(self) self.notifier = _testNotifier() self.broker_url = broker_url self.agent = Agent(name, _notifier=self.notifier, heartbeat_interval=heartbeat, max_duration=10, default_duration=7, min_duration=5, min_interval=1, default_interval=2) # Management Database # - two different schema packages, # - two classes within one schema package # - multiple objects per schema package+class # - two "undescribed" objects # "package1/class1" _schema = SchemaObjectClass(_classId=SchemaClassId( "package1", "class1"), _desc="A test data schema - one", _object_id_names=["key"]) _schema.add_property("key", SchemaProperty(qmfTypes.TYPE_LSTR)) # note: count1 is continuous, count2 is not count1_prop = SchemaProperty.create(qmfTypes.TYPE_UINT32, continuous=True) _schema.add_property("count1", count1_prop) count2_prop = SchemaProperty.create(qmfTypes.TYPE_UINT32, continuous=False) _schema.add_property("count2", SchemaProperty(qmfTypes.TYPE_UINT32)) self.agent.register_object_class(_schema) _obj = QmfAgentData(self.agent, _values={"key": "p1c1_key1"}, _schema=_schema) _obj.set_value("count1", 0) _obj.set_value("count2", 0) self.agent.add_object(_obj) _obj = QmfAgentData(self.agent, _values={"key": "p1c1_key2"}, _schema=_schema) _obj.set_value("count1", 9) _obj.set_value("count2", 10) self.agent.add_object(_obj) # "package1/class2" _schema = SchemaObjectClass(_classId=SchemaClassId( "package1", "class2"), _desc="A test data schema - two", _object_id_names=["name"]) # add properties _schema.add_property("name", SchemaProperty(qmfTypes.TYPE_LSTR)) _schema.add_property("string1", SchemaProperty(qmfTypes.TYPE_LSTR)) self.agent.register_object_class(_schema) _obj = QmfAgentData(self.agent, _values={"name": "p1c2_name1"}, _schema=_schema) _obj.set_value("string1", "a data string") self.agent.add_object(_obj) _obj = QmfAgentData(self.agent, _values={"name": "p1c2_name2"}, _schema=_schema) _obj.set_value("string1", "another data string") self.agent.add_object(_obj) # "package2/class1" _schema = SchemaObjectClass( _classId=SchemaClassId("package2", "class1"), _desc="A test data schema - second package", _object_id_names=["key"]) _schema.add_property("key", SchemaProperty(qmfTypes.TYPE_LSTR)) _schema.add_property("counter", SchemaProperty(qmfTypes.TYPE_UINT32)) self.agent.register_object_class(_schema) _obj = QmfAgentData(self.agent, _values={"key": "p2c1_key1"}, _schema=_schema) _obj.set_value("counter", 0) self.agent.add_object(_obj) _obj = QmfAgentData(self.agent, _values={"key": "p2c1_key2"}, _schema=_schema) _obj.set_value("counter", 2112) self.agent.add_object(_obj) # add two "unstructured" objects to the Agent _obj = QmfAgentData(self.agent, _object_id="undesc-1") _obj.set_value("field1", "a value") _obj.set_value("field2", 2) _obj.set_value("field3", {"a": 1, "map": 2, "value": 3}) _obj.set_value("field4", ["a", "list", "value"]) self.agent.add_object(_obj) _obj = QmfAgentData(self.agent, _object_id="undesc-2") _obj.set_value("key-1", "a value") _obj.set_value("key-2", 2) self.agent.add_object(_obj) self.running = False self.ready = Event()
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)
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)
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)
def test_end(self): print("!!! end test") # # An example agent application # if __name__ == '__main__': _notifier = ExampleNotifier() _agent = Agent("qmf.testAgent", _notifier=_notifier) # Dynamically construct a class schema _schema = SchemaObjectClass(_classId=SchemaClassId("MyPackage", "MyClass"), _desc="A test data schema", _object_id_names=["index1", "index2"]) # add properties _schema.add_property("index1", SchemaProperty(qmfTypes.TYPE_UINT8)) _schema.add_property("index2", SchemaProperty(qmfTypes.TYPE_LSTR)) # these two properties are statistics _schema.add_property("query_count", SchemaProperty(qmfTypes.TYPE_UINT32)) _schema.add_property("method_call_count", SchemaProperty(qmfTypes.TYPE_UINT32)) # These two properties can be set via the method call _schema.add_property("set_string", SchemaProperty(qmfTypes.TYPE_LSTR)) _schema.add_property("set_int", SchemaProperty(qmfTypes.TYPE_UINT32))
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)
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)
def test_wildcard_schema_id(self): # create console # find all agents # synchronous query for all described objects by: # oid & wildcard schema_id # wildcard schema_id # 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 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) wild_schema_id = SchemaClassId("package1", "class1") objs = self.console.get_objects(_schema_id=wild_schema_id, _timeout=5) self.assertTrue(len(objs) == (self.agent_count * 2)) for obj in objs: self.assertTrue( obj.get_schema_class_id().get_package_name() == "package1") self.assertTrue( obj.get_schema_class_id().get_class_name() == "class1") wild_schema_id = SchemaClassId("package1", "class2") objs = self.console.get_objects(_schema_id=wild_schema_id, _timeout=5) self.assertTrue(len(objs) == self.agent_count) for obj in objs: self.assertTrue( obj.get_schema_class_id().get_package_name() == "package1") self.assertTrue( obj.get_schema_class_id().get_class_name() == "class2") self.assertTrue(obj.get_object_id() == "p1c2_name1") wild_schema_id = SchemaClassId("package2", "class1") objs = self.console.get_objects(_schema_id=wild_schema_id, _timeout=5) self.assertTrue(len(objs) == (self.agent_count * 2)) for obj in objs: self.assertTrue( obj.get_schema_class_id().get_package_name() == "package2") self.assertTrue( obj.get_schema_class_id().get_class_name() == "class1") wild_schema_id = SchemaClassId("package1", "class1") objs = self.console.get_objects(_schema_id=wild_schema_id, _object_id="p1c1_key2", _timeout=5) self.assertTrue(len(objs) == self.agent_count) for obj in objs: self.assertTrue( obj.get_schema_class_id().get_package_name() == "package1") self.assertTrue( obj.get_schema_class_id().get_class_name() == "class1") self.assertTrue(obj.get_object_id() == "p1c1_key2") # should fail objs = self.console.get_objects(_schema_id=wild_schema_id, _object_id="does not exist", _timeout=5) self.assertTrue(objs == None) wild_schema_id = SchemaClassId("package2", "class1") objs = self.console.get_objects(_schema_id=wild_schema_id, _object_id="p2c1_key2", _timeout=5) self.assertTrue(len(objs) == self.agent_count) for obj in objs: self.assertTrue( obj.get_schema_class_id().get_package_name() == "package2") self.assertTrue( obj.get_schema_class_id().get_class_name() == "class1") self.assertTrue(obj.get_object_id() == "p2c1_key2") # should fail wild_schema_id = SchemaClassId("package1", "bad-class") objs = self.console.get_objects(_schema_id=wild_schema_id, _object_id="p1c1_key2", _timeout=5) self.assertTrue(objs == None) self.console.destroy(10)
def __init__(self, name, broker_url, heartbeat): Thread.__init__(self) self.notifier = _testNotifier() self.broker_url = broker_url self.agent = Agent(name, _notifier=self.notifier, heartbeat_interval=heartbeat) # Dynamically construct a management database _schema = SchemaObjectClass(_classId=SchemaClassId( "MyPackage", "MyClass"), _desc="A test data schema", _object_id_names=["index1", "index2"]) # add properties _schema.add_property("index1", SchemaProperty(qmfTypes.TYPE_UINT8)) _schema.add_property("index2", SchemaProperty(qmfTypes.TYPE_LSTR)) # these two properties are statistics _schema.add_property("query_count", SchemaProperty(qmfTypes.TYPE_UINT32)) _schema.add_property("method_call_count", SchemaProperty(qmfTypes.TYPE_UINT32)) # These two properties can be set via the method call _schema.add_property("set_string", SchemaProperty(qmfTypes.TYPE_LSTR)) _schema.add_property("set_int", SchemaProperty(qmfTypes.TYPE_UINT32)) # add method _meth = SchemaMethod(_desc="Method to set string and int in object.") _meth.add_argument("arg_int", SchemaProperty(qmfTypes.TYPE_UINT32)) _meth.add_argument("arg_str", SchemaProperty(qmfTypes.TYPE_LSTR)) _schema.add_method("set_meth", _meth) # Add schema to Agent self.agent.register_object_class(_schema) # instantiate managed data objects matching the schema _obj1 = QmfAgentData(self.agent, _schema=_schema, _values={ "index1": 100, "index2": "a name" }) _obj1.set_value("set_string", "UNSET") _obj1.set_value("set_int", 0) _obj1.set_value("query_count", 0) _obj1.set_value("method_call_count", 0) self.agent.add_object(_obj1) self.agent.add_object( QmfAgentData(self.agent, _schema=_schema, _values={ "index1": 99, "index2": "another name", "set_string": "UNSET", "set_int": 0, "query_count": 0, "method_call_count": 0 })) self.agent.add_object( QmfAgentData(self.agent, _schema=_schema, _values={ "index1": 50, "index2": "my name", "set_string": "SET", "set_int": 0, "query_count": 0, "method_call_count": 0 })) # add an "unstructured" object to the Agent _obj2 = QmfAgentData(self.agent, _object_id="01545") _obj2.set_value("field1", "a value") _obj2.set_value("field2", 2) _obj2.set_value("field3", {"a": 1, "map": 2, "value": 3}) _obj2.set_value("field4", ["a", "list", "value"]) _obj2.set_value("index1", 50) self.agent.add_object(_obj2) _obj2 = QmfAgentData(self.agent, _object_id="01546") _obj2.set_value("field1", "a value") _obj2.set_value("field2", 3) _obj2.set_value("field3", {"a": 1, "map": 2, "value": 3}) _obj2.set_value("field4", ["a", "list", "value"]) _obj2.set_value("index1", 51) self.agent.add_object(_obj2) _obj2 = QmfAgentData(self.agent, _object_id="01544") _obj2.set_value("field1", "a value") _obj2.set_value("field2", 4) _obj2.set_value("field3", {"a": 1, "map": 2, "value": 3}) _obj2.set_value("field4", ["a", "list", "value"]) _obj2.set_value("index1", 49) self.agent.add_object(_obj2) _obj2 = QmfAgentData(self.agent, _object_id="01543") _obj2.set_value("field1", "a value") _obj2.set_value("field2", 4) _obj2.set_value("field3", {"a": 1, "map": 2, "value": 3}) _obj2.set_value("field4", ["a", "list", "value"]) _obj2.set_value("index1", 48) self.agent.add_object(_obj2) self.running = False self.ready = Event()
def __init__(self, name, broker_url, heartbeat): Thread.__init__(self) self.schema_count = _SCHEMAS_PER_AGENT self.obj_count = _OBJS_PER_AGENT self.notifier = _testNotifier() self.broker_url = broker_url self.agent = Agent(name, _notifier=self.notifier, heartbeat_interval=heartbeat, max_msg_size=_MAX_OBJS_PER_MSG) # Dynamically construct a management database for i in range(self.schema_count): _schema = SchemaObjectClass(_classId=SchemaClassId( "MyPackage", "MyClass-" + str(i)), _desc="A test data schema", _object_id_names=["index1", "index2"]) # add properties _schema.add_property("index1", SchemaProperty(qmfTypes.TYPE_UINT8)) _schema.add_property("index2", SchemaProperty(qmfTypes.TYPE_LSTR)) # these two properties are statistics _schema.add_property("query_count", SchemaProperty(qmfTypes.TYPE_UINT32)) _schema.add_property("method_call_count", SchemaProperty(qmfTypes.TYPE_UINT32)) # These two properties can be set via the method call _schema.add_property("set_string", SchemaProperty(qmfTypes.TYPE_LSTR)) _schema.add_property("set_int", SchemaProperty(qmfTypes.TYPE_UINT32)) # add method _meth = SchemaMethod( _desc="Method to set string and int in object.") _meth.add_argument("arg_int", SchemaProperty(qmfTypes.TYPE_UINT32)) _meth.add_argument("arg_str", SchemaProperty(qmfTypes.TYPE_LSTR)) _schema.add_method("set_meth", _meth) # Add schema to Agent self.agent.register_object_class(_schema) # instantiate managed data objects matching the schema for j in range(self.obj_count): self.agent.add_object( QmfAgentData(self.agent, _schema=_schema, _values={ "index1": j, "index2": "name-" + str(j), "set_string": "UNSET", "set_int": 0, "query_count": 0, "method_call_count": 0 })) self.running = False self.ready = Event()