def setUp(self):
"""
Startup the container and start the agent.
"""
super(DataSetQualificationTestCase, self).setUp()
self.instrument_agent_manager = InstrumentAgentClient()
self.instrument_agent_manager.start_container(
deploy_file=self.test_config.container_deploy_file)
self.container = self.instrument_agent_manager.container
gevent.sleep(5)
log.debug("Packet Config: %s", self.test_config.agent_packet_config)
self.data_subscribers = InstrumentAgentDataSubscribers(
packet_config=self.test_config.agent_packet_config, )
self.event_subscribers = InstrumentAgentEventSubscribers(
instrument_agent_resource_id=self.test_config.agent_resource_id)
self.init_dataset_agent_client()
self.event_subscribers.events_received = []
self.data_subscribers.start_data_subscribers()
log.debug("********* setUp complete. Begin Testing *********")
self.addCleanup(self._end_test)
def setUp(self):
"""
Startup the container and start the agent.
"""
super(DataSetQualificationTestCase, self).setUp()
self.instrument_agent_manager = InstrumentAgentClient()
self.instrument_agent_manager.start_container(deploy_file=self.test_config.container_deploy_file)
self.container = self.instrument_agent_manager.container
log.debug("Packet Config: %s", self.test_config.agent_packet_config)
self.data_subscribers = InstrumentAgentDataSubscribers(
packet_config=self.test_config.agent_packet_config,
)
self.event_subscribers = InstrumentAgentEventSubscribers(instrument_agent_resource_id=self.test_config.agent_resource_id)
self.init_dataset_agent_client()
self.event_subscribers.events_received = []
self.data_subscribers.start_data_subscribers()
log.debug("********* setUp complete. Begin Testing *********")
self.addCleanup(self._end_test)
def start_container(self):
"""
Start up the capability container, port agent and the IA client
"""
self.init_comm_config()
self.init_port_agent()
self.instrument_agent_manager = InstrumentAgentClient();
self.instrument_agent_manager.start_container()
self.init_instrument_agent_client()
def setUp(self):
"""
@brief Setup test cases.
"""
log.debug("InstrumentDriverQualificationTestCase setUp")
InstrumentDriverTestCase.setUp(self)
self.port_agent = self.test_config.port_agent
self.instrument_agent_manager = InstrumentAgentClient();
self.instrument_agent_manager.start_container(deploy_file=self.test_config.container_deploy_file)
self.container = self.instrument_agent_manager.container
self.data_subscribers = InstrumentAgentDataSubscribers(
packet_config=self.test_config.instrument_agent_packet_config,
encoding=self.test_config.instrument_agent_stream_encoding,
stream_definition=self.test_config.instrument_agent_stream_definition
)
self.event_subscribers = InstrumentAgentEventSubscribers()
self.init_instrument_agent_client()
def setUp(self):
"""
@brief Setup test cases.
"""
log.debug("#ROGER# does setUp get called?")
InstrumentDriverTestCase.setUp(self)
self.port_agent = self.test_config.port_agent
self.instrument_agent_manager = InstrumentAgentClient();
self.instrument_agent_manager.start_container(deploy_file=self.test_config.container_deploy_file)
self.container = self.instrument_agent_manager.container
log.debug("#ROGER# in setUp self.test_config.instrument_agent_packet_config = " + str(self.test_config.instrument_agent_packet_config))
self.data_subscribers = InstrumentAgentDataSubscribers(
packet_config=self.test_config.instrument_agent_packet_config,
encoding=self.test_config.instrument_agent_stream_encoding,
stream_definition=self.test_config.instrument_agent_stream_definition
)
log.debug("InstrumentDriverQualificationTestCase setUp Problem BELOW")
self.event_subscribers = InstrumentAgentEventSubscribers(instrument_agent_resource_id=self.test_config.instrument_agent_resource_id)
log.debug("InstrumentDriverQualificationTestCase setUp Problem ABOVE")
self.init_instrument_agent_client()
class DataSetQualificationTestCase(DataSetTestCase):
"""
Base class for dataset driver unit tests
"""
def setUp(self):
"""
Startup the container and start the agent.
"""
super(DataSetQualificationTestCase, self).setUp()
self.instrument_agent_manager = InstrumentAgentClient()
self.instrument_agent_manager.start_container(
deploy_file=self.test_config.container_deploy_file)
self.container = self.instrument_agent_manager.container
log.debug("Packet Config: %s", self.test_config.agent_packet_config)
self.data_subscribers = InstrumentAgentDataSubscribers(
packet_config=self.test_config.agent_packet_config, )
self.event_subscribers = InstrumentAgentEventSubscribers(
instrument_agent_resource_id=self.test_config.agent_resource_id)
self.init_dataset_agent_client()
self.event_subscribers.events_received = []
self.data_subscribers.start_data_subscribers()
log.debug("********* setUp complete. Begin Testing *********")
self.addCleanup(self._end_test)
def _end_test(self):
"""
Cleanup after the test completes or fails
"""
log.debug("Starting test cleanup")
self.assert_reset()
self.event_subscribers.stop()
self.data_subscribers.stop_data_subscribers()
self.instrument_agent_manager.stop_container()
log.debug("Test complete and all cleaned up.")
def init_dataset_agent_client(self):
log.info("Start Dataset Agent Client")
# Start instrument agent client.
self.instrument_agent_manager.start_client(
name=self.test_config.agent_name,
module=self.test_config.agent_module,
cls=self.test_config.agent_class,
config=self._agent_config(),
resource_id=self.test_config.agent_resource_id,
deploy_file=self.test_config.container_deploy_file,
bootmode='reset')
self.dataset_agent_client = self.instrument_agent_manager.instrument_agent_client
def get_samples(self, stream_name, sample_count=1, timeout=10):
"""
listen on a stream until 'sample_count' samples are read and return
a list of all samples read. If the required number of samples aren't
read then throw an exception.
Note that this method does not clear the sample queue for the stream.
This should be done explicitly by the caller. However, samples that
are consumed by this method are removed.
@raise SampleTimeout - if the required number of samples aren't read
"""
result = []
start_time = time.time()
i = 1
log.debug("Fetch %d sample(s) from stream '%s'" %
(sample_count, stream_name))
while (len(result) < sample_count):
if (self.data_subscribers.samples_received.has_key(stream_name)
and len(
self.data_subscribers.samples_received.get(
stream_name))):
log.trace("get_samples() received sample #%d!", i)
result.append(
self.data_subscribers.samples_received[stream_name].pop(0))
i += 1
# Check for timeout
if (start_time + timeout < time.time()):
raise SampleTimeout()
if (not self.data_subscribers.samples_received.has_key(stream_name)
or len(
self.data_subscribers.samples_received.get(
stream_name)) == 0):
log.debug(
"No samples in the queue, sleep for a bit to let the queue fill up"
)
gevent.sleep(.2)
log.debug("get_samples() complete. returning %d records",
sample_count)
return result
def assert_sample_queue_size(self, stream_name, size):
"""
Verify that a queue has size samples in it.
"""
if (not self.data_subscribers.samples_received.has_key(stream_name)
and size == 0):
return
self.assertTrue(
self.data_subscribers.samples_received.has_key(stream_name),
msg="Sample queue does not exists")
self.assertEqual(
len(self.data_subscribers.samples_received.get(stream_name)), size)
def assert_data_values(self, particles, dataset_definition_file):
"""
Verify particles match the particles defined in the definition file
"""
rs_file = self._get_source_data_file(dataset_definition_file)
rs = ResultSet(rs_file)
self.assertTrue(rs.verify(particles))
def assert_initialize(self, final_state=ResourceAgentState.STREAMING):
'''
Walk through DSA states to get to streaming mode from uninitialized
'''
log.debug("Initialize DataSet agent")
cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE)
retval = self.dataset_agent_client.execute_agent(cmd)
state = self.dataset_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.INACTIVE)
log.info("Sent INITIALIZE; DSA state = %s", state)
log.debug("DataSet agent go active")
cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE)
retval = self.dataset_agent_client.execute_agent(cmd)
state = self.dataset_agent_client.get_agent_state()
log.info("Sent GO_ACTIVE; DSA state = %s", state)
self.assertEqual(state, ResourceAgentState.IDLE)
log.debug("DataSet agent run")
cmd = AgentCommand(command=ResourceAgentEvent.RUN)
retval = self.dataset_agent_client.execute_agent(cmd)
state = self.dataset_agent_client.get_agent_state()
log.info("Sent RUN; DSA state = %s", state)
self.assertEqual(state, ResourceAgentState.COMMAND)
if final_state == ResourceAgentState.STREAMING:
self.assert_start_sampling()
def assert_stop_sampling(self):
'''
transition to command. Must be called from streaming
'''
state = self.dataset_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.STREAMING)
log.debug("DataSet agent stop sampling")
cmd = AgentCommand(command=DriverEvent.STOP_AUTOSAMPLE)
retval = self.dataset_agent_client.execute_resource(cmd)
state = self.dataset_agent_client.get_agent_state()
log.info("Sent START SAMPLING; DSA state = %s", state)
self.assertEqual(state, ResourceAgentState.COMMAND)
def assert_start_sampling(self):
'''
transition to sampling. Must be called from command
'''
state = self.dataset_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.COMMAND)
log.debug("DataSet agent start sampling")
cmd = AgentCommand(command=DriverEvent.START_AUTOSAMPLE)
retval = self.dataset_agent_client.execute_resource(cmd)
state = self.dataset_agent_client.get_agent_state()
log.info("Sent START SAMPLING; DSA state = %s", state)
self.assertEqual(state, ResourceAgentState.STREAMING)
def assert_reset(self):
'''
Put the instrument back in uninitialized
'''
agent_state = self.dataset_agent_client.get_agent_state()
log.debug("Resetting agent: current state: %s", agent_state)
if agent_state != ResourceAgentState.UNINITIALIZED:
cmd = AgentCommand(command=ResourceAgentEvent.RESET)
retval = self.dataset_agent_client.execute_agent(cmd)
state = self.dataset_agent_client.get_agent_state()
log.debug("Resetting agent: final state: %s", state)
def assert_agent_state(self, target_state):
"""
Verify the current agent state
@param target_state: What we expect the agent state to be
"""
state = self.dataset_agent_client.get_agent_state()
self.assertEqual(state, target_state)
def assert_agent_command(self, command, args=None, timeout=None):
"""
Verify an agent command
@param command: driver command to execute
@param args: kwargs to pass to the agent command object
"""
cmd = AgentCommand(command=command, kwargs=args)
retval = self.instrument_agent_client.execute_agent(cmd,
timeout=timeout)
def assert_resource_command(self, command, args=None, timeout=None):
"""
Verify a resource command
@param command: driver command to execute
@param args: kwargs to pass to the agent command object
"""
cmd = AgentCommand(command=command, kwargs=args)
retval = self.dataset_agent_client.execute_resource(cmd)
def assert_state_change(self, target_agent_state, timeout=10):
"""
Verify the agent and resource states change as expected within the timeout
Fail if the state doesn't change to the expected state.
@param target_agent_state: State we expect the agent to be in
@param timeout: how long to wait for the driver to change states
"""
to = gevent.Timeout(timeout)
to.start()
done = False
agent_state = None
try:
while (not done):
agent_state = self.dataset_agent_client.get_agent_state()
log.error("Current agent state: %s", agent_state)
if (agent_state == target_agent_state):
log.debug("Current state match: %s", agent_state)
done = True
if not done:
log.debug(
"state mismatch, waiting for state to transition.")
gevent.sleep(1)
except Timeout:
log.error(
"Failed to transition agent state to %s, current state: %s",
target_agent_state, agent_state)
self.fail("Failed to transition state.")
finally:
to.cancel()
def assert_event_received(self, event_object_type, timeout=10):
"""
Verify an event has been received of a sepecific type
@param event_object_type: Event object we are looking for
@param timeout: how long to wait
"""
to = gevent.Timeout(timeout)
to.start()
done = False
try:
while (not done):
for event in self.event_subscribers.events_received:
log.debug("Event: %s", event)
if isinstance(event, event_object_type):
done = True
if not done:
log.debug(
"target event not detected, sleep a bit to let events happen"
)
gevent.sleep(1)
except Timeout:
log.error("Failed to find event in queue: %s", event_object_type)
log.error("Current event queue: %s",
self.event_subscribers._events_received)
self.fail("%s event not detected")
finally:
to.cancel()
log.info("Expected event detected: %s", event)
def test_initialize(self):
"""
Test that we can start the container and initialize the dataset agent.
"""
self.assert_initialize()
self.assert_stop_sampling()
self.assert_reset()
def test_resource_parameters(self):
"""
verify we can get a resource parameter lists and get/set parameters.
"""
def sort_capabilities(caps_list):
'''
sort a return value into capability buckets.
@retval agt_cmds, agt_pars, res_cmds, res_iface, res_pars
'''
agt_cmds = []
agt_pars = []
res_cmds = []
res_iface = []
res_pars = []
if len(caps_list) > 0 and isinstance(caps_list[0],
AgentCapability):
agt_cmds = [
x.name for x in caps_list
if x.cap_type == CapabilityType.AGT_CMD
]
agt_pars = [
x.name for x in caps_list
if x.cap_type == CapabilityType.AGT_PAR
]
res_cmds = [
x.name for x in caps_list
if x.cap_type == CapabilityType.RES_CMD
]
#res_iface = [x.name for x in caps_list if x.cap_type==CapabilityType.RES_IFACE]
res_pars = [
x.name for x in caps_list
if x.cap_type == CapabilityType.RES_PAR
]
elif len(caps_list) > 0 and isinstance(caps_list[0], dict):
agt_cmds = [
x['name'] for x in caps_list
if x['cap_type'] == CapabilityType.AGT_CMD
]
agt_pars = [
x['name'] for x in caps_list
if x['cap_type'] == CapabilityType.AGT_PAR
]
res_cmds = [
x['name'] for x in caps_list
if x['cap_type'] == CapabilityType.RES_CMD
]
#res_iface = [x['name'] for x in caps_list if x['cap_type']==CapabilityType.RES_IFACE]
res_pars = [
x['name'] for x in caps_list
if x['cap_type'] == CapabilityType.RES_PAR
]
agt_cmds.sort()
agt_pars.sort()
res_cmds.sort()
res_iface.sort()
res_pars.sort()
return agt_cmds, agt_pars, res_cmds, res_iface, res_pars
log.debug("Initialize the agent")
expected_params = [
DriverParameter.BATCHED_PARTICLE_COUNT,
DriverParameter.PUBLISHER_POLLING_INTERVAL,
DriverParameter.RECORDS_PER_SECOND
]
self.assert_initialize(final_state=ResourceAgentState.COMMAND)
log.debug("Call get capabilities")
retval = self.dataset_agent_client.get_capabilities()
log.debug("Capabilities: %s", retval)
agt_cmds, agt_pars, res_cmds, res_iface, res_pars = sort_capabilities(
retval)
self.assertEqual(sorted(res_pars), sorted(expected_params))
self.dataset_agent_client.set_resource(
{DriverParameter.RECORDS_PER_SECOND: 20})
reply = self.dataset_agent_client.get_resource(DriverParameter.ALL)
log.debug("Get Resource Result: %s", reply)
def test_missing_directory(self):
"""
Test starting the driver when the data directory doesn't exists. This
should prevent the driver from going into streaming mode. When the
directory is created then we should be able to transition into streaming.
"""
self.remove_sample_dir()
self.assert_initialize(final_state=ResourceAgentState.COMMAND)
self.event_subscribers.clear_events()
self.assert_resource_command(DriverEvent.START_AUTOSAMPLE)
self.assert_state_change(ResourceAgentState.LOST_CONNECTION, 90)
self.assert_event_received(ResourceAgentConnectionLostErrorEvent, 10)
self.create_data_dir()
# Should automatically retry connect and transition to streaming
self.assert_state_change(ResourceAgentState.STREAMING, 90)
def test_harvester_new_file_exception(self):
"""
Test an exception raised after the driver is started during
the file read.
exception callback called.
"""
config = self._driver_config(
)['startup_config']['harvester']['pattern']
filename = config.replace("*", "foo")
self.assert_new_file_exception(filename)
def assert_new_file_exception(self, filename):
self.clear_sample_data()
self.create_sample_data(filename, mode=000)
self.assert_initialize(final_state=ResourceAgentState.COMMAND)
self.event_subscribers.clear_events()
self.assert_resource_command(DriverEvent.START_AUTOSAMPLE)
self.assert_state_change(ResourceAgentState.LOST_CONNECTION, 90)
self.assert_event_received(ResourceAgentConnectionLostErrorEvent, 10)
self.clear_sample_data()
self.create_sample_data(filename)
# Should automatically retry connect and transition to streaming
self.assert_state_change(ResourceAgentState.STREAMING, 90)
class DataSetQualificationTestCase(DataSetTestCase):
"""
Base class for dataset driver unit tests
"""
def setUp(self):
"""
Startup the container and start the agent.
"""
super(DataSetQualificationTestCase, self).setUp()
self.instrument_agent_manager = InstrumentAgentClient()
self.instrument_agent_manager.start_container(deploy_file=self.test_config.container_deploy_file)
self.container = self.instrument_agent_manager.container
log.debug("Packet Config: %s", self.test_config.agent_packet_config)
self.data_subscribers = InstrumentAgentDataSubscribers(
packet_config=self.test_config.agent_packet_config,
)
self.event_subscribers = InstrumentAgentEventSubscribers(instrument_agent_resource_id=self.test_config.agent_resource_id)
self.init_dataset_agent_client()
self.event_subscribers.events_received = []
self.data_subscribers.start_data_subscribers()
log.debug("********* setUp complete. Begin Testing *********")
self.addCleanup(self._end_test)
def _end_test(self):
"""
Cleanup after the test completes or fails
"""
log.debug("Starting test cleanup")
self.assert_reset()
self.event_subscribers.stop()
self.data_subscribers.stop_data_subscribers()
self.instrument_agent_manager.stop_container()
log.debug("Test complete and all cleaned up.")
def init_dataset_agent_client(self):
log.info("Start Dataset Agent Client")
# Start instrument agent client.
self.instrument_agent_manager.start_client(
name=self.test_config.agent_name,
module=self.test_config.agent_module,
cls=self.test_config.agent_class,
config=self._agent_config(),
resource_id=self.test_config.agent_resource_id,
deploy_file=self.test_config.container_deploy_file,
bootmode='reset'
)
self.dataset_agent_client = self.instrument_agent_manager.instrument_agent_client
def get_samples(self, stream_name, sample_count = 1, timeout = 10):
"""
listen on a stream until 'sample_count' samples are read and return
a list of all samples read. If the required number of samples aren't
read then throw an exception.
Note that this method does not clear the sample queue for the stream.
This should be done explicitly by the caller. However, samples that
are consumed by this method are removed.
@raise SampleTimeout - if the required number of samples aren't read
"""
result = []
start_time = time.time()
i = 1
log.debug("Fetch %d sample(s) from stream '%s'" % (sample_count, stream_name))
while(len(result) < sample_count):
if(self.data_subscribers.samples_received.has_key(stream_name) and
len(self.data_subscribers.samples_received.get(stream_name))):
log.trace("get_samples() received sample #%d!", i)
result.append(self.data_subscribers.samples_received[stream_name].pop(0))
i += 1
# Check for timeout
if(start_time + timeout < time.time()):
raise SampleTimeout()
if(not self.data_subscribers.samples_received.has_key(stream_name) or
len(self.data_subscribers.samples_received.get(stream_name)) == 0):
log.debug("No samples in the queue, sleep for a bit to let the queue fill up")
gevent.sleep(.2)
log.debug("get_samples() complete. returning %d records", sample_count)
return result
def assert_sample_queue_size(self, stream_name, size):
"""
Verify that a queue has size samples in it.
"""
if(not self.data_subscribers.samples_received.has_key(stream_name) and size == 0):
return
self.assertTrue(self.data_subscribers.samples_received.has_key(stream_name), msg="Sample queue does not exists")
self.assertEqual(len(self.data_subscribers.samples_received.get(stream_name)), size)
def assert_data_values(self, particles, dataset_definition_file):
"""
Verify particles match the particles defined in the definition file
"""
rs_file = self._get_source_data_file(dataset_definition_file)
rs = ResultSet(rs_file)
self.assertTrue(rs.verify(particles))
def assert_initialize(self, final_state = ResourceAgentState.STREAMING):
'''
Walk through DSA states to get to streaming mode from uninitialized
'''
log.debug("Initialize DataSet agent")
cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE)
retval = self.dataset_agent_client.execute_agent(cmd)
state = self.dataset_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.INACTIVE)
log.info("Sent INITIALIZE; DSA state = %s", state)
log.debug("DataSet agent go active")
cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE)
retval = self.dataset_agent_client.execute_agent(cmd)
state = self.dataset_agent_client.get_agent_state()
log.info("Sent GO_ACTIVE; DSA state = %s", state)
self.assertEqual(state, ResourceAgentState.IDLE)
log.debug("DataSet agent run")
cmd = AgentCommand(command=ResourceAgentEvent.RUN)
retval = self.dataset_agent_client.execute_agent(cmd)
state = self.dataset_agent_client.get_agent_state()
log.info("Sent RUN; DSA state = %s", state)
self.assertEqual(state, ResourceAgentState.COMMAND)
if final_state == ResourceAgentState.STREAMING:
self.assert_start_sampling()
def assert_stop_sampling(self):
'''
transition to command. Must be called from streaming
'''
state = self.dataset_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.STREAMING)
log.debug("DataSet agent stop sampling")
cmd = AgentCommand(command=DriverEvent.STOP_AUTOSAMPLE)
retval = self.dataset_agent_client.execute_resource(cmd)
state = self.dataset_agent_client.get_agent_state()
log.info("Sent START SAMPLING; DSA state = %s", state)
self.assertEqual(state, ResourceAgentState.COMMAND)
def assert_start_sampling(self):
'''
transition to sampling. Must be called from command
'''
state = self.dataset_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.COMMAND)
log.debug("DataSet agent start sampling")
cmd = AgentCommand(command=DriverEvent.START_AUTOSAMPLE)
retval = self.dataset_agent_client.execute_resource(cmd)
state = self.dataset_agent_client.get_agent_state()
log.info("Sent START SAMPLING; DSA state = %s", state)
self.assertEqual(state, ResourceAgentState.STREAMING)
def assert_reset(self):
'''
Put the instrument back in uninitialized
'''
agent_state = self.dataset_agent_client.get_agent_state()
log.debug("Resetting agent: current state: %s", agent_state)
if agent_state != ResourceAgentState.UNINITIALIZED:
cmd = AgentCommand(command=ResourceAgentEvent.RESET)
retval = self.dataset_agent_client.execute_agent(cmd)
state = self.dataset_agent_client.get_agent_state()
log.debug("Resetting agent: final state: %s", state)
def assert_agent_state(self, target_state):
"""
Verify the current agent state
@param target_state: What we expect the agent state to be
"""
state = self.dataset_agent_client.get_agent_state()
self.assertEqual(state, target_state)
def assert_agent_command(self, command, args=None, timeout=None):
"""
Verify an agent command
@param command: driver command to execute
@param args: kwargs to pass to the agent command object
"""
cmd = AgentCommand(command=command, kwargs=args)
retval = self.instrument_agent_client.execute_agent(cmd, timeout=timeout)
def assert_resource_command(self, command, args=None, timeout=None):
"""
Verify a resource command
@param command: driver command to execute
@param args: kwargs to pass to the agent command object
"""
cmd = AgentCommand(command=command, kwargs=args)
retval = self.dataset_agent_client.execute_resource(cmd)
def assert_state_change(self, target_agent_state, timeout=10):
"""
Verify the agent and resource states change as expected within the timeout
Fail if the state doesn't change to the expected state.
@param target_agent_state: State we expect the agent to be in
@param timeout: how long to wait for the driver to change states
"""
to = gevent.Timeout(timeout)
to.start()
done = False
agent_state = None
try:
while(not done):
agent_state = self.dataset_agent_client.get_agent_state()
log.error("Current agent state: %s", agent_state)
if(agent_state == target_agent_state):
log.debug("Current state match: %s", agent_state)
done = True
if not done:
log.debug("state mismatch, waiting for state to transition.")
gevent.sleep(1)
except Timeout:
log.error("Failed to transition agent state to %s, current state: %s", target_agent_state, agent_state)
self.fail("Failed to transition state.")
finally:
to.cancel()
def assert_event_received(self, event_object_type, timeout=10):
"""
Verify an event has been received of a sepecific type
@param event_object_type: Event object we are looking for
@param timeout: how long to wait
"""
to = gevent.Timeout(timeout)
to.start()
done = False
try:
while(not done):
for event in self.event_subscribers.events_received:
log.debug("Event: %s", event)
if isinstance(event, event_object_type):
done = True
if not done:
log.debug("target event not detected, sleep a bit to let events happen")
gevent.sleep(1)
except Timeout:
log.error("Failed to find event in queue: %s", event_object_type)
log.error("Current event queue: %s", self.event_subscribers._events_received)
self.fail("%s event not detected")
finally:
to.cancel()
log.info("Expected event detected: %s", event)
def test_initialize(self):
"""
Test that we can start the container and initialize the dataset agent.
"""
self.assert_initialize()
self.assert_stop_sampling()
self.assert_reset()
def test_resource_parameters(self):
"""
verify we can get a resource parameter lists and get/set parameters.
"""
def sort_capabilities(caps_list):
'''
sort a return value into capability buckets.
@retval agt_cmds, agt_pars, res_cmds, res_iface, res_pars
'''
agt_cmds = []
agt_pars = []
res_cmds = []
res_iface = []
res_pars = []
if len(caps_list)>0 and isinstance(caps_list[0], AgentCapability):
agt_cmds = [x.name for x in caps_list if x.cap_type==CapabilityType.AGT_CMD]
agt_pars = [x.name for x in caps_list if x.cap_type==CapabilityType.AGT_PAR]
res_cmds = [x.name for x in caps_list if x.cap_type==CapabilityType.RES_CMD]
#res_iface = [x.name for x in caps_list if x.cap_type==CapabilityType.RES_IFACE]
res_pars = [x.name for x in caps_list if x.cap_type==CapabilityType.RES_PAR]
elif len(caps_list)>0 and isinstance(caps_list[0], dict):
agt_cmds = [x['name'] for x in caps_list if x['cap_type']==CapabilityType.AGT_CMD]
agt_pars = [x['name'] for x in caps_list if x['cap_type']==CapabilityType.AGT_PAR]
res_cmds = [x['name'] for x in caps_list if x['cap_type']==CapabilityType.RES_CMD]
#res_iface = [x['name'] for x in caps_list if x['cap_type']==CapabilityType.RES_IFACE]
res_pars = [x['name'] for x in caps_list if x['cap_type']==CapabilityType.RES_PAR]
agt_cmds.sort()
agt_pars.sort()
res_cmds.sort()
res_iface.sort()
res_pars.sort()
return agt_cmds, agt_pars, res_cmds, res_iface, res_pars
log.debug("Initialize the agent")
expected_params = [DriverParameter.BATCHED_PARTICLE_COUNT, DriverParameter.PUBLISHER_POLLING_INTERVAL, DriverParameter.RECORDS_PER_SECOND]
self.assert_initialize(final_state=ResourceAgentState.COMMAND)
log.debug("Call get capabilities")
retval = self.dataset_agent_client.get_capabilities()
log.debug("Capabilities: %s", retval)
agt_cmds, agt_pars, res_cmds, res_iface, res_pars = sort_capabilities(retval)
self.assertEqual(sorted(res_pars), sorted(expected_params))
self.dataset_agent_client.set_resource({DriverParameter.RECORDS_PER_SECOND: 20})
reply = self.dataset_agent_client.get_resource(DriverParameter.ALL)
log.debug("Get Resource Result: %s", reply)
def test_missing_directory(self):
"""
Test starting the driver when the data directory doesn't exists. This
should prevent the driver from going into streaming mode. When the
directory is created then we should be able to transition into streaming.
"""
self.remove_sample_dir()
self.assert_initialize(final_state=ResourceAgentState.COMMAND)
self.event_subscribers.clear_events()
self.assert_resource_command(DriverEvent.START_AUTOSAMPLE)
self.assert_state_change(ResourceAgentState.LOST_CONNECTION, 90)
self.assert_event_received(ResourceAgentConnectionLostErrorEvent, 10)
self.create_data_dir()
# Should automatically retry connect and transition to streaming
self.assert_state_change(ResourceAgentState.STREAMING, 90)
def test_harvester_new_file_exception(self):
"""
Test an exception raised after the driver is started during
the file read.
exception callback called.
"""
config = self._driver_config()['startup_config']['harvester']['pattern']
filename = config.replace("*", "foo")
self.assert_new_file_exception(filename)
def assert_new_file_exception(self, filename):
self.clear_sample_data()
self.create_sample_data(filename, mode=000)
self.assert_initialize(final_state=ResourceAgentState.COMMAND)
self.event_subscribers.clear_events()
self.assert_resource_command(DriverEvent.START_AUTOSAMPLE)
self.assert_state_change(ResourceAgentState.LOST_CONNECTION, 90)
self.assert_event_received(ResourceAgentConnectionLostErrorEvent, 10)
self.clear_sample_data()
self.create_sample_data(filename)
# Should automatically retry connect and transition to streaming
self.assert_state_change(ResourceAgentState.STREAMING, 90)
class InstrumentDriverQualificationTestCase(InstrumentDriverTestCase):
@classmethod
def setUpClass(cls):
cls.init_port_agent()
@classmethod
def tearDownClass(cls):
cls.stop_port_agent()
def setUp(self):
"""
@brief Setup test cases.
"""
log.debug("InstrumentDriverQualificationTestCase setUp")
InstrumentDriverTestCase.setUp(self)
self.port_agent = self.test_config.port_agent
self.instrument_agent_manager = InstrumentAgentClient();
self.instrument_agent_manager.start_container(deploy_file=self.test_config.container_deploy_file)
self.container = self.instrument_agent_manager.container
self.data_subscribers = InstrumentAgentDataSubscribers(
packet_config=self.test_config.instrument_agent_packet_config,
encoding=self.test_config.instrument_agent_stream_encoding,
stream_definition=self.test_config.instrument_agent_stream_definition
)
self.event_subscribers = InstrumentAgentEventSubscribers()
self.init_instrument_agent_client()
def init_instrument_agent_client(self):
log.info("Start Instrument Agent Client")
# A callback for processing subscribed-to data.
'''
def consume_data(message, headers):
log.info('Subscriber received data message: %s.', str(message))
self.samples_received.append(message)
if self.no_samples and self.no_samples == len(self.samples_received):
self.async_data_result.set()
'''
# Driver config
driver_config = {
'dvr_mod' : self.test_config.driver_module,
'dvr_cls' : self.test_config.driver_class,
'process_type' : self.test_config.driver_process_type,
'workdir' : self.test_config.working_dir,
'comms_config' : self.port_agent_comm_config()
}
# Create agent config.
agent_config = {
'driver_config' : driver_config,
'stream_config' : self.data_subscribers.stream_config,
'agent' : {'resource_id': self.test_config.instrument_agent_resource_id},
'test_mode' : True ## Enable a poison pill. If the spawning process dies
## shutdown the daemon process.
}
# Start instrument agent client.
self.instrument_agent_manager.start_client(
name=self.test_config.instrument_agent_name,
module=self.test_config.instrument_agent_module,
cls=self.test_config.instrument_agent_class,
config=agent_config,
resource_id=self.test_config.instrument_agent_resource_id,
deploy_file=self.test_config.container_deploy_file
)
self.instrument_agent_client = self.instrument_agent_manager.instrument_agent_client
def tearDown(self):
"""
@brief Test teardown
"""
log.debug("InstrumentDriverQualificationTestCase tearDown")
self.instrument_agent_manager.stop_container()
InstrumentDriverTestCase.tearDown(self)
def test_common_qualification(self):
self.assertTrue(1)
def test_instrument_agent_common_state_model_lifecycle(self):
"""
@brief Test agent state transitions.
This test verifies that the instrument agent can
properly command the instrument through the following states.
@todo Once direct access settles down and works again, re-enable direct access.
KNOWN COMMANDS -> RESULTANT STATES:
* power_up -> UNINITIALIZED
* power_down -> POWERED_DOWN
* initialize -> INACTIVE
* reset -> UNINITIALIZED
* go_active -> IDLE
* go_inactive -> INACTIVE
* run -> OBSERVATORY
* clear -> IDLE
* pause -> STOPPED
* resume -> OBSERVATORY
* go_streaming -> STREAMING
* go_direct_access -> DIRECT_ACCESS
* go_observatory -> OBSERVATORY
* get_current_state -> gives current state.
* start_transaction (NA)
* end_transaction (NA)
STATES ACHIEVED:
* InstrumentAgentState.POWERED_DOWN
* InstrumentAgentState.UNINITIALIZED
* InstrumentAgentState.INACTIVE
* InstrumentAgentState.IDLE
* InstrumentAgentState.OBSERVATORY
* InstrumentAgentState.STREAMING
* InstrumentAgentState.DIRECT_ACCESS
* InstrumentAgentState.STOPPED
above that are common to all devices go into common,
others go into instrument specific
?? when we get it, we can add:
?? get_current_capabilitys <- instrument specific
A side effect of this testing is verification that the
events emitted by the agent conform to those expected
by the system.
"""
cmd = AgentCommand(command='power_down')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.POWERED_DOWN)
cmd = AgentCommand(command='power_up')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.UNINITIALIZED)
cmd = AgentCommand(command='initialize')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.INACTIVE)
cmd = AgentCommand(command='go_active')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.IDLE)
log.debug("Instrument active. Verify RQ-634")
cmd = AgentCommand(command='go_inactive')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.INACTIVE)
# ...and put it back to where it should be...
cmd = AgentCommand(command='go_active')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.IDLE)
cmd = AgentCommand(command='run')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.OBSERVATORY)
# Begin streaming.
cmd = AgentCommand(command='go_streaming')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.STREAMING)
log.debug("Enterered streaming mode. Verify RQ-636")
# Halt streaming.
cmd = AgentCommand(command='go_observatory')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.OBSERVATORY)
# go direct access
cmd = AgentCommand(command='go_direct_access',
kwargs={'session_type':DirectAccessTypes.telnet,
#kwargs={'session_type':DirectAccessTypes.vsp,
'session_timeout':600,
'inactivity_timeout':600})
retval = self.instrument_agent_client.execute_agent(cmd)
log.debug("5***** go_direct_access retval=" + str(retval.result))
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.DIRECT_ACCESS)
# Halt DA.
cmd = AgentCommand(command='go_observatory')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.OBSERVATORY)
cmd = AgentCommand(command='pause')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.STOPPED)
cmd = AgentCommand(command='resume')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.OBSERVATORY)
cmd = AgentCommand(command='clear')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.IDLE)
cmd = AgentCommand(command='run')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.OBSERVATORY)
cmd = AgentCommand(command='pause')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.STOPPED)
cmd = AgentCommand(command='clear')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.IDLE)
cmd = AgentCommand(command='reset')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.UNINITIALIZED)
def test_instrument_agent_to_instrument_driver_connectivity(self):
"""
@brief This test verifies that the instrument agent can
talk to the instrument driver.
The intent of this is to be a ping to the driver
layer.
"""
log.debug("IA client = " + str(self.instrument_agent_client))
cmd = AgentCommand(command='power_down')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.POWERED_DOWN)
cmd = AgentCommand(command='power_up')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.UNINITIALIZED)
cmd = AgentCommand(command='initialize')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
cmd = AgentCommand(command='go_layer_ping')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.LAYER_PING)
log.debug("***** If i get here i am in LAYER_PING state....")
cmd = AgentCommand(command='helo_agent', kwargs={'message': 'PING-AGENT'})
retval = self.instrument_agent_client.execute_agent(cmd)
self.assertEqual(retval.result, "PONG-PING-AGENT")
cmd = AgentCommand(command='helo_driver', kwargs={'message': 'PING-DRIVER'})
retval = self.instrument_agent_client.execute_agent(cmd)
self.assertEqual(retval.result, 'process_echo: PING-DRIVER')
cmd = AgentCommand(command='go_inactive')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
log.debug("***** retval2 = " + str(retval))
self.assertEqual(state, InstrumentAgentState.INACTIVE)
log.debug("***** If i get here i am in POWERED_DOWN state....")
def test_instrument_error_code_enum(self):
"""
@brief check InstErrorCode for consistency
"""
self.assertTrue(self.check_for_reused_values(InstErrorCode))
pass
def test_driver_connection_state_enum(self):
"""
@brief check DriverConnectionState for consistency
@todo this check should also be a device specific for drivers like Trhph
"""
# self.assertEqual(TrhphDriverState.UNCONFIGURED, DriverConnectionState.UNCONFIGURED)
# self.assertEqual(TrhphDriverState.DISCONNECTED, DriverConnectionState.DISCONNECTED)
# self.assertEqual(TrhphDriverState.CONNECTED, DriverConnectionState.CONNECTED)
self.assertTrue(self.check_for_reused_values(DriverConnectionState))
def test_instrument_agent_event_enum(self):
self.assertTrue(self.check_for_reused_values(InstrumentAgentEvent))
def test_instrument_agent_state_enum(self):
self.assertTrue(self.check_for_reused_values(InstrumentAgentState))
def check_for_reused_values(self, obj):
"""
@author Roger Unwin
@brief verifies that no two definitions resolve to the same value.
@returns True if no reused values
"""
match = 0
outer_match = 0
for i in [v for v in dir(obj) if not callable(getattr(obj,v))]:
if i.startswith('_') == False:
outer_match = outer_match + 1
for j in [x for x in dir(obj) if not callable(getattr(obj,x))]:
if i.startswith('_') == False:
if getattr(obj, i) == getattr(obj, j):
match = match + 1
log.debug(str(i) + " == " + j + " (Looking for reused values)")
# If this assert fails, then two of the enumerations have an identical value...
return match == outer_match
def test_driver_async_event_enum(self):
"""
@ brief ProtocolState enum test
1. test that SBE37ProtocolState matches the expected enums from DriverProtocolState.
2. test that multiple distinct states do not resolve back to the same string.
"""
self.assertTrue(self.check_for_reused_values(DriverAsyncEvent))
@unittest.skip("Transaction management not yet implemented")
def test_transaction_management_messages(self):
"""
@brief This tests the start_transaction and
end_transaction methods.
https://confluence.oceanobservatories.org/display/syseng/CIAD+MI+SV+Instrument+Agent+Interface#CIADMISVInstrumentAgentInterface-Transactionmanagementmessages
* start_transaction(acq_timeout,exp_timeout)
* end_transaction(transaction_id)
* transaction_id
See: ion/services/mi/instrument_agent.py
UPDATE: stub it out fill in later when its available ... place holder
TODO:
"""
pass
def de_dupe(self, list_in):
unique_set = Set(item for item in list_in)
return [(item) for item in unique_set]
def test_driver_notification_messages(self):
"""
@brief This tests event messages from the driver. The following
test moves the IA through all its states. As it does this,
event messages are generated and caught. These messages
are then compared with a list of expected messages to
insure that the proper messages have been generated.
"""
# Clear off any events from before this test so we have consistent state
self._events_received = []
expected_events = []
expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_POWERED_DOWN')
expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_UNINITIALIZED')
expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_INACTIVE')
expected_events.append('New driver state: DRIVER_STATE_DISCONNECTED')
expected_events.append('New driver state: DRIVER_STATE_DISCONNECTED')
expected_events.append('New driver state: DRIVER_STATE_UNKNOWN')
expected_events.append('New driver configuration:')
expected_events.append('New driver state: DRIVER_STATE_COMMAND')
expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_IDLE')
expected_events.append('New driver state: DRIVER_STATE_DISCONNECTED')
expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_INACTIVE')
expected_events.append('New driver state: DRIVER_STATE_UNCONFIGURED')
expected_events.append('New driver state: DRIVER_STATE_DISCONNECTED')
expected_events.append('New driver state: DRIVER_STATE_DISCONNECTED')
expected_events.append('New driver state: DRIVER_STATE_UNKNOWN')
expected_events.append('New driver configuration:')
expected_events.append('New driver state: DRIVER_STATE_COMMAND')
expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_IDLE')
expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_OBSERVATORY')
expected_events.append('New driver state: DRIVER_STATE_AUTOSAMPLE')
expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_STREAMING')
expected_events.append('New driver configuration:')
expected_events.append('New driver state: DRIVER_STATE_COMMAND')
expected_events.append('New driver state: DRIVER_STATE_DIRECT_ACCESS')
expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_DIRECT_ACCESS')
expected_events.append('New driver state: DRIVER_STATE_COMMAND')
expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_OBSERVATORY')
expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_STOPPED')
expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_OBSERVATORY')
expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_IDLE')
expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_OBSERVATORY')
expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_STOPPED')
expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_IDLE')
expected_events.append('New driver state: DRIVER_STATE_DISCONNECTED')
expected_events.append('New driver state: DRIVER_STATE_UNCONFIGURED')
expected_events.append('Agent entered state: INSTRUMENT_AGENT_STATE_UNINITIALIZED')
cmd = AgentCommand(command='power_down')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='power_up')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='initialize')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='go_active')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='go_inactive')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='go_active')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='run')
retval = self.instrument_agent_client.execute_agent(cmd)
# Begin streaming.
cmd = AgentCommand(command='go_streaming')
retval = self.instrument_agent_client.execute_agent(cmd)
# Halt streaming.
cmd = AgentCommand(command='go_observatory')
retval = self.instrument_agent_client.execute_agent(cmd)
# go direct access
cmd = AgentCommand(command='go_direct_access',
kwargs={'session_type':DirectAccessTypes.telnet,
#kwargs={'session_type':DirectAccessTypes.vsp,
'session_timeout':600,
'inactivity_timeout':600})
retval = self.instrument_agent_client.execute_agent(cmd)
log.debug("RETVAL = " + str(retval))
# Halt DA.
cmd = AgentCommand(command='go_observatory')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='pause')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='resume')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='clear')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='run')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='pause')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='clear')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='reset')
retval = self.instrument_agent_client.execute_agent(cmd)
raw_events = []
log.warn("ROGER *********************EVENTS " + str(self.event_subscribers.events_received))
for x in self.event_subscribers.events_received:
if x.description.find("New driver configuration:") >= 0:
raw_events.append("New driver configuration:")
log.warn("ROGER *********************APPENDING " + "New driver configuration:")
else:
raw_events.append(str(x.description))
log.warn("ROGER *********************APPENDING " + str(x.description))
log.debug("raw_events[] = " + str(raw_events))
for x in sorted(raw_events):
log.debug(str(x) + " ?in (expected_events) = " + str(x in expected_events))
self.assertTrue(x in expected_events)
for x in sorted(expected_events):
log.debug(str(x) + " ?in (raw_events) = " + str(x in raw_events))
# in incomplete drivers, 2 of the states are not reached.
if x != "New driver configuration:" and x != 'New driver state: DRIVER_STATE_AUTOSAMPLE':
self.assertTrue(x in raw_events)
# assert we got the expected number of events
num_expected = len(self.de_dupe(expected_events))
num_actual = len(self.de_dupe(raw_events))
self.assertTrue(num_actual <= num_expected)
# in incomplete drivers, 2 of the states are not reached.
# ("New driver configuration:" and 'New driver state: DRIVER_STATE_AUTOSAMPLE')
self.assertTrue(num_actual >= (num_expected - 2))
# FAIL AssertionError: 37 != 38
pass
def test_instrument_driver_to_physical_instrument_interoperability(self):
"""
@Brief this test is the integreation test test_connect
but run through the agent.
On a seabird sbe37 this results in a ds and dc command being sent.
"""
cmd = AgentCommand(command='initialize')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.INACTIVE)
cmd = AgentCommand(command='go_active')
retval = self.instrument_agent_client.execute_agent(cmd)
# Test the driver is configured for comms.
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.IDLE)
pass
@unittest.skip("Driver.get_device_signature not yet implemented")
def test_get_device_signature(self):
"""
@Brief this test will call get_device_signature once that is
implemented in the driver
"""
pass
def test_initialize(self):
"""
Test agent initialize command. This causes creation of
driver process and transition to inactive.
"""
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.UNINITIALIZED)
cmd = AgentCommand(command='initialize')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.INACTIVE)
cmd = AgentCommand(command='reset')
retval = self.instrument_agent_client.execute_agent(cmd)
cmd = AgentCommand(command='get_current_state')
retval = self.instrument_agent_client.execute_agent(cmd)
state = retval.result
self.assertEqual(state, InstrumentAgentState.UNINITIALIZED)
class DataSetQualificationTestCase(DataSetTestCase):
"""
Base class for dataset driver unit tests
"""
def setUp(self):
"""
Startup the container and start the agent.
"""
super(DataSetQualificationTestCase, self).setUp()
self.instrument_agent_manager = InstrumentAgentClient()
self.instrument_agent_manager.start_container(deploy_file=self.test_config.container_deploy_file)
self.container = self.instrument_agent_manager.container
gevent.sleep(5)
log.debug("Packet Config: %s", self.test_config.agent_packet_config)
self.data_subscribers = InstrumentAgentDataSubscribers(
packet_config=self.test_config.agent_packet_config,
)
self.event_subscribers = InstrumentAgentEventSubscribers(instrument_agent_resource_id=self.test_config.agent_resource_id)
self.init_dataset_agent_client()
self.event_subscribers.events_received = []
self.data_subscribers.start_data_subscribers()
log.debug("********* setUp complete. Begin Testing *********")
self.addCleanup(self._end_test)
def _end_test(self):
"""
Cleanup after the test completes or fails
"""
self.assert_reset()
self.event_subscribers.stop()
self.data_subscribers.stop_data_subscribers()
self.instrument_agent_manager.stop_container()
log.debug("Test complete and all cleaned up.")
def init_dataset_agent_client(self):
log.info("Start Dataset Agent Client")
# Start instrument agent client.
self.instrument_agent_manager.start_client(
name=self.test_config.agent_name,
module=self.test_config.agent_module,
cls=self.test_config.agent_class,
config=self._agent_config(),
resource_id=self.test_config.agent_resource_id,
deploy_file=self.test_config.container_deploy_file,
bootmode='reset'
)
self.dataset_agent_client = self.instrument_agent_manager.instrument_agent_client
def get_samples(self, stream_name, sample_count = 1, timeout = 10):
"""
listen on a stream until 'sample_count' samples are read and return
a list of all samples read. If the required number of samples aren't
read then throw an exception.
Note that this method does not clear the sample queue for the stream.
This should be done explicitly by the caller. However, samples that
are consumed by this method are removed.
@raise SampleTimeout - if the required number of samples aren't read
"""
result = []
start_time = time.time()
i = 1
log.debug("Fetch %d sample(s) from stream '%s'" % (sample_count, stream_name))
while(len(result) < sample_count):
if(self.data_subscribers.samples_received.has_key(stream_name) and
len(self.data_subscribers.samples_received.get(stream_name))):
log.trace("get_samples() received sample #%d!", i)
result.append(self.data_subscribers.samples_received[stream_name].pop())
i += 1
# Check for timeout
if(start_time + timeout < time.time()):
raise SampleTimeout()
if(not self.data_subscribers.samples_received.has_key(stream_name) or
len(self.data_subscribers.samples_received.get(stream_name)) == 0):
log.debug("No samples in the queue, sleep for a bit to let the queue fill up")
gevent.sleep(.2)
log.debug("get_samples() complete. returning %d records", sample_count)
return result
def assert_sample_queue_size(self, stream_name, size):
"""
Verify that a queue has size samples in it.
"""
if(not self.data_subscribers.samples_received.has_key(stream_name) and size == 0):
return
self.assertTrue(self.data_subscribers.samples_received.has_key(stream_name), msg="Sample queue does not exists")
self.assertEqual(len(self.data_subscribers.samples_received.get(stream_name)), size)
def assert_data_values(self, particles, dataset_definition_file):
"""
Verify particles match the particles defined in the definition file
"""
rs_file = self._get_source_data_file(dataset_definition_file)
rs = ResultSet(rs_file)
self.assertTrue(rs.verify(particles))
def assert_initialize(self, final_state = ResourceAgentState.STREAMING):
'''
Walk through DSA states to get to streaming mode from uninitialized
'''
log.debug("Initialize DataSet agent")
cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE)
retval = self.dataset_agent_client.execute_agent(cmd)
state = self.dataset_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.INACTIVE)
log.info("Sent INITIALIZE; DSA state = %s", state)
log.debug("DataSet agent go active")
cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE)
retval = self.dataset_agent_client.execute_agent(cmd)
state = self.dataset_agent_client.get_agent_state()
log.info("Sent GO_ACTIVE; DSA state = %s", state)
self.assertEqual(state, ResourceAgentState.IDLE)
log.debug("DataSet agent run")
cmd = AgentCommand(command=ResourceAgentEvent.RUN)
retval = self.dataset_agent_client.execute_agent(cmd)
state = self.dataset_agent_client.get_agent_state()
log.info("Sent RUN; DSA state = %s", state)
self.assertEqual(state, ResourceAgentState.COMMAND)
if final_state == ResourceAgentState.STREAMING:
self.assert_start_sampling()
def assert_stop_sampling(self):
'''
transition to command. Must be called from streaming
'''
state = self.dataset_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.STREAMING)
log.debug("DataSet agent stop sampling")
cmd = AgentCommand(command=DriverEvent.STOP_AUTOSAMPLE)
retval = self.dataset_agent_client.execute_resource(cmd)
state = self.dataset_agent_client.get_agent_state()
log.info("Sent START SAMPLING; DSA state = %s", state)
self.assertEqual(state, ResourceAgentState.COMMAND)
def assert_start_sampling(self):
'''
transition to sampling. Must be called from command
'''
state = self.dataset_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.COMMAND)
log.debug("DataSet agent start sampling")
cmd = AgentCommand(command=DriverEvent.START_AUTOSAMPLE)
retval = self.dataset_agent_client.execute_resource(cmd)
state = self.dataset_agent_client.get_agent_state()
log.info("Sent START SAMPLING; DSA state = %s", state)
self.assertEqual(state, ResourceAgentState.STREAMING)
def assert_reset(self):
'''
Put the instrument back in uninitialized
'''
agent_state = self.dataset_agent_client.get_agent_state()
if agent_state != ResourceAgentState.UNINITIALIZED:
cmd = AgentCommand(command=ResourceAgentEvent.RESET)
retval = self.dataset_agent_client.execute_agent(cmd)
state = self.dataset_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.UNINITIALIZED)
def assert_agent_state(self, target_state):
"""
Verify the current agent state
@param target_state: What we expect the agent state to be
"""
state = self.dataset_agent_client.get_agent_state()
self.assertEqual(state, target_state)
def assert_agent_command(self, command, args=None, timeout=None):
"""
Verify an agent command
@param command: driver command to execute
@param args: kwargs to pass to the agent command object
"""
cmd = AgentCommand(command=command, kwargs=args)
retval = self.instrument_agent_client.execute_agent(cmd, timeout=timeout)
def assert_resource_command(self, command, args=None, timeout=None):
"""
Verify a resource command
@param command: driver command to execute
@param args: kwargs to pass to the agent command object
"""
cmd = AgentCommand(command=command, kwargs=args)
retval = self.dataset_agent_client.execute_resource(cmd)
def assert_state_change(self, target_agent_state, timeout=10):
"""
Verify the agent and resource states change as expected within the timeout
Fail if the state doesn't change to the expected state.
@param target_agent_state: State we expect the agent to be in
@param timeout: how long to wait for the driver to change states
"""
to = gevent.Timeout(timeout)
to.start()
done = False
agent_state = None
try:
while(not done):
agent_state = self.dataset_agent_client.get_agent_state()
log.error("Current agent state: %s", agent_state)
if(agent_state == target_agent_state):
log.debug("Current state match: %s", agent_state)
done = True
if not done:
log.debug("state mismatch, waiting for state to transition.")
gevent.sleep(1)
except Timeout:
log.error("Failed to transition agent state to %s, current state: %s", target_agent_state, agent_state)
self.fail("Failed to transition state.")
finally:
to.cancel()
def assert_event_received(self, event_object_type, timeout=10):
"""
Verify an event has been received of a sepecific type
@param event_object_type: Event object we are looking for
@param timeout: how long to wait
"""
to = gevent.Timeout(timeout)
to.start()
done = False
try:
while(not done):
for event in self.event_subscribers.events_received:
log.debug("Event: %s", event)
if isinstance(event, event_object_type):
done = True
if not done:
log.debug("target event not detected, sleep a bit to let events happen")
gevent.sleep(1)
except Timeout:
log.error("Failed to find event in queue: %s", event_object_type)
log.error("Current event queue: %s", self.event_subscribers._events_received)
self.fail("%s event not detected")
finally:
to.cancel()
log.info("Expected event detected: %s", event)
def setUp(self):
"""
Setup the test case
"""
self.ia_client = InstrumentAgentClient()
class TestIAStart(MiUnitTest):
"""
Test the instrument agent startup
"""
def setUp(self):
"""
Setup the test case
"""
self.ia_client = InstrumentAgentClient()
def test_container_rabbitmq(self):
"""
Test that rabbitmq can be started
@TODO This test should start/stop rabbitmq and couch in setup, as it leaves the system in a bad state.
"""
self.ia_client.start_rabbitmq_server()
pid = self.ia_client._read_pidfile(
self.ia_client._pid_filename("rabbitmq"))
self.assertTrue(pid)
self.ia_client.start_rabbitmq_server()
new_pid = self.ia_client._read_pidfile(
self.ia_client._pid_filename("rabbitmq"))
self.assertEqual(pid, new_pid)
self.ia_client.stop_rabbitmq_server()
pid = self.ia_client._read_pidfile(
self.ia_client._pid_filename("rabbitmq"))
self.assertFalse(pid)
def test_container_couchdb(self):
"""Test that couchdb can be started"""
self.ia_client.start_couchdb()
pid = self.ia_client._read_pidfile(
self.ia_client._pid_filename("couchdb"))
self.assertTrue(pid)
self.ia_client.start_couchdb()
new_pid = self.ia_client._read_pidfile(
self.ia_client._pid_filename("couchdb"))
self.assertEqual(pid, new_pid)
self.ia_client.stop_couchdb()
pid = self.ia_client._read_pidfile(
self.ia_client._pid_filename("couchdb"))
self.assertFalse(pid)
def test_container_start(self):
"""Test that a container can be started"""
self.ia_client.start_container()
self.assertTrue(self.ia_client.container)
self.ia_client.stop_container()
self.assertFalse(self.ia_client.container)
def test_data_subscriber(self):
"""
Test that we can build data subscribers using the packet config from the IDK
"""
data_subscriber = InstrumentAgentDataSubscribers()
class DirectAccessServer():
"""
Main class for running the start driver process.
"""
port_agent = None
instrument_agent_manager = None
instrument_agent_client = None
monitor_process = None
def __init__(self, launch_monitor=False):
"""
Setup the direct access server
"""
# Currently we are pulling the driver config information from the driver tests. There is a better way to do
# this, but we are time crunched. TODO: Fix this!
generator = DriverGenerator(Metadata())
__import__(generator.test_modulename())
self.test_config = InstrumentDriverTestConfig()
# Test to ensure we have initialized our test config
if not self.test_config.initialized:
raise TestNotInitialized(msg="Tests non initialized. Missing InstrumentDriverTestCase.initalize(...)?")
self.launch_monitor = launch_monitor
def __del__(self):
"""
Destructor to cleanup all the processes we started to run DA
"""
log.info("tearing down agents and containers")
log.debug("killing the capability container")
if self.instrument_agent_manager:
self.instrument_agent_manager.stop_container()
log.debug("killing the port agent")
if self.port_agent:
self.port_agent.stop()
if self.monitor_process:
log.debug("killing the monitor process")
self.monitor_process.kill()
def start_container(self):
"""
Start up the capability container, port agent and the IA client
"""
self.init_comm_config()
self.init_port_agent()
self.instrument_agent_manager = InstrumentAgentClient();
self.instrument_agent_manager.start_container()
self.init_instrument_agent_client()
def comm_config_file(self):
"""
@brief Return the path the the driver comm config yaml file.
@return if comm_config.yml exists return the full path
"""
repo_dir = Config().get('working_repo')
driver_path = self.test_config.driver_module
p = re.compile('\.')
driver_path = p.sub('/', driver_path)
abs_path = "%s/%s/%s" % (repo_dir, os.path.dirname(driver_path), CommConfig.config_filename())
log.debug(abs_path)
return abs_path
def init_comm_config(self):
"""
@brief Create the comm config object by reading the comm_config.yml file.
"""
log.info("Initialize comm config")
config_file = self.comm_config_file()
log.debug( " -- reading comm config from: %s" % config_file )
if not os.path.exists(config_file):
raise TestNoCommConfig(msg="Missing comm config. Try running start_driver or switch_driver")
self.comm_config = CommConfig.get_config_from_file(config_file)
def init_port_agent(self):
"""
@brief Launch the driver process and driver client. This is used in the
integration and qualification tests. The port agent abstracts the physical
interface with the instrument.
@retval return the pid to the logger process
"""
log.info("Startup Port Agent")
config = {
'device_addr' : self.comm_config.device_addr,
'device_port' : self.comm_config.device_port,
'command_port': self.comm_config.command_port,
'data_port': self.comm_config.data_port,
'process_type': PortAgentProcessType.UNIX,
'log_level': 5,
}
self.port_agent = PortAgentProcess.launch_process(config, timeout = 60,
test_mode = True)
port = self.port_agent.get_data_port()
pid = self.port_agent.get_pid()
log.info('Started port agent pid %s listening at port %s' % (pid, port))
if self.launch_monitor:
self.logfile = self.port_agent.port_agent.logfname
log.info('Started port agent pid %s listening at port %s' % (pid, port))
log.info("data log: %s" % self.logfile)
self.monitor_process = launch_data_monitor(self.logfile)
def stop_port_agent(self):
"""
Stop the port agent.
"""
if self.port_agent:
self.port_agent.stop()
if self.monitor_process:
self.monitor_process.kill()
def init_instrument_agent_client(self):
"""
Start up the instrument agent client.
"""
log.info("Start Instrument Agent Client")
# Port config
port = self.port_agent.get_data_port()
port_config = {
'addr': 'localhost',
'port': port
}
# Driver config
driver_config = {
'dvr_mod' : self.test_config.driver_module,
'dvr_cls' : self.test_config.driver_class,
'process_type' : self.test_config.driver_process_type,
'workdir' : self.test_config.working_dir,
'comms_config' : port_config
}
# Create agent config.
agent_config = {
'driver_config' : driver_config,
'stream_config' : {},
'agent' : {'resource_id': self.test_config.instrument_agent_resource_id},
'test_mode' : True ## Enable a poison pill. If the spawning process dies
## shutdown the daemon process.
}
# Start instrument agent client.
self.instrument_agent_manager.start_client(
name=self.test_config.instrument_agent_name,
module=self.test_config.instrument_agent_module,
cls=self.test_config.instrument_agent_class,
config=agent_config,
resource_id=self.test_config.instrument_agent_resource_id,
deploy_file=self.test_config.container_deploy_file
)
self.instrument_agent_client = self.instrument_agent_manager.instrument_agent_client
def _start_da(self, type):
"""
The actual work to start up a DA session.
"""
self.start_container()
log.info("--- Starting DA server ---")
#cmd = AgentCommand(command=ResourceAgentEvent.POWER_DOWN)
#retval = self.instrument_agent_client.execute_agent(cmd)
#log.debug("retval: %s", retval)
#cmd = AgentCommand(command=ResourceAgentEvent.GET_RESOURCE_STATE)
#retval = self.instrument_agent_client.execute_agent(cmd)
#log.debug("retval: %s", retval)
#cmd = AgentCommand(command=ResourceAgentEvent.POWER_UP)
#retval = self.instrument_agent_client.execute_agent(cmd)
#log.debug("retval: %s", retval)
#cmd = AgentCommand(command=ResourceAgentEvent.GET_RESOURCE_STATE)
#retval = self.instrument_agent_client.execute_agent(cmd)
#log.debug("retval: %s", retval)
cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE)
retval = self.instrument_agent_client.execute_agent(cmd)
log.debug("retval: %s", retval)
cmd = AgentCommand(command=ResourceAgentEvent.GET_RESOURCE_STATE)
retval = self.instrument_agent_client.execute_agent(cmd)
log.debug("retval: %s", retval)
cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE)
retval = self.instrument_agent_client.execute_agent(cmd)
log.debug("retval: %s", retval)
cmd = AgentCommand(command=ResourceAgentEvent.GET_RESOURCE_STATE)
retval = self.instrument_agent_client.execute_agent(cmd)
log.debug("retval: %s", retval)
cmd = AgentCommand(command=ResourceAgentEvent.RUN)
retval = self.instrument_agent_client.execute_agent(cmd)
log.debug("retval: %s", retval)
cmd = AgentCommand(command=ResourceAgentEvent.GET_RESOURCE_STATE)
retval = self.instrument_agent_client.execute_agent(cmd)
log.debug("retval: %s", retval)
cmd = AgentCommand(command=ResourceAgentEvent.GO_DIRECT_ACCESS,
kwargs={'session_type': type,
'session_timeout': TIMEOUT,
'inactivity_timeout': TIMEOUT})
retval = self.instrument_agent_client.execute_agent(cmd)
log.debug("retval: %s", retval)
ip_address = retval.result['ip_address']
port= retval.result['port']
token= retval.result['token']
cmd = AgentCommand(command=ResourceAgentEvent.GET_RESOURCE_STATE)
retval = self.instrument_agent_client.execute_agent(cmd)
log.debug("retval: %s", retval)
ia_state = retval.result
log.debug("IA State: %s", ia_state)
if ia_state == DriverProtocolState.DIRECT_ACCESS:
print "Direct access server started, IP: %s Port: %s" % (ip_address, port)
if token:
print "Token: %s" % token
while ia_state == DriverProtocolState.DIRECT_ACCESS:
cmd = AgentCommand(command=ResourceAgentEvent.GET_RESOURCE_STATE)
retval = self.instrument_agent_client.execute_agent(cmd)
ia_state = retval.result
gevent.sleep(.1)
else:
log.error("Failed to start DA server (%s)" % ia_state)
def start_telnet_server(self):
"""
@brief Run the telnet server
"""
self._start_da(DirectAccessTypes.telnet)
def start_vps_server(self):
"""
@brief run the vps server
"""
self._start_da(DirectAccessTypes.vsp)
def setUp(self):
"""
Setup the test case
"""
self.ia_client = InstrumentAgentClient()
class TestIAStart(unittest.TestCase):
"""
Test the instrument agent startup
"""
def setUp(self):
"""
Setup the test case
"""
self.ia_client = InstrumentAgentClient()
def test_container_rabbitmq(self):
"""Test that rabbitmq can be started"""
self.ia_client.start_rabbitmq_server()
pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("rabbitmq"))
self.assertTrue(pid)
self.ia_client.start_rabbitmq_server()
new_pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("rabbitmq"))
self.assertEqual(pid, new_pid)
self.ia_client.stop_rabbitmq_server()
pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("rabbitmq"))
self.assertFalse(pid)
def test_container_couchdb(self):
"""Test that couchdb can be started"""
self.ia_client.start_couchdb()
pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("couchdb"))
self.assertTrue(pid)
self.ia_client.start_couchdb()
new_pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("couchdb"))
self.assertEqual(pid, new_pid)
self.ia_client.stop_couchdb()
pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("couchdb"))
self.assertFalse(pid)
def test_container_start(self):
"""Test that a container can be started"""
self.ia_client.start_container()
self.assertTrue(self.ia_client.container)
self.ia_client.stop_container()
self.assertFalse(self.ia_client.container)
class DataSetQualificationTestCase(DataSetTestCase):
"""
Base class for dataset driver unit tests
"""
def setUp(self):
"""
Startup the container and start the agent.
"""
super(DataSetQualificationTestCase, self).setUp()
self.instrument_agent_manager = InstrumentAgentClient()
self.instrument_agent_manager.start_container(
deploy_file=self.test_config.container_deploy_file)
self.container = self.instrument_agent_manager.container
gevent.sleep(5)
log.debug("Packet Config: %s", self.test_config.agent_packet_config)
self.data_subscribers = InstrumentAgentDataSubscribers(
packet_config=self.test_config.agent_packet_config, )
self.event_subscribers = InstrumentAgentEventSubscribers(
instrument_agent_resource_id=self.test_config.agent_resource_id)
self.init_dataset_agent_client()
self.event_subscribers.events_received = []
self.data_subscribers.start_data_subscribers()
log.debug("********* setUp complete. Begin Testing *********")
self.addCleanup(self._end_test)
def _end_test(self):
"""
Cleanup after the test completes or fails
"""
self.assert_reset()
self.event_subscribers.stop()
self.data_subscribers.stop_data_subscribers()
self.instrument_agent_manager.stop_container()
log.debug("Test complete and all cleaned up.")
def init_dataset_agent_client(self):
log.info("Start Dataset Agent Client")
# Start instrument agent client.
self.instrument_agent_manager.start_client(
name=self.test_config.agent_name,
module=self.test_config.agent_module,
cls=self.test_config.agent_class,
config=self._agent_config(),
resource_id=self.test_config.agent_resource_id,
deploy_file=self.test_config.container_deploy_file,
bootmode='reset')
self.dataset_agent_client = self.instrument_agent_manager.instrument_agent_client
def get_samples(self, stream_name, sample_count=1, timeout=10):
"""
listen on a stream until 'sample_count' samples are read and return
a list of all samples read. If the required number of samples aren't
read then throw an exception.
Note that this method does not clear the sample queue for the stream.
This should be done explicitly by the caller. However, samples that
are consumed by this method are removed.
@raise SampleTimeout - if the required number of samples aren't read
"""
result = []
start_time = time.time()
i = 1
log.debug("Fetch %d sample(s) from stream '%s'" %
(sample_count, stream_name))
while (len(result) < sample_count):
if (self.data_subscribers.samples_received.has_key(stream_name)
and len(
self.data_subscribers.samples_received.get(
stream_name))):
log.trace("get_samples() received sample #%d!", i)
result.append(
self.data_subscribers.samples_received[stream_name].pop())
i += 1
# Check for timeout
if (start_time + timeout < time.time()):
raise SampleTimeout()
if (not self.data_subscribers.samples_received.has_key(stream_name)
or len(
self.data_subscribers.samples_received.get(
stream_name)) == 0):
log.debug(
"No samples in the queue, sleep for a bit to let the queue fill up"
)
gevent.sleep(.2)
log.debug("get_samples() complete. returning %d records",
sample_count)
return result
def assert_sample_queue_size(self, stream_name, size):
"""
Verify that a queue has size samples in it.
"""
if (not self.data_subscribers.samples_received.has_key(stream_name)
and size == 0):
return
self.assertTrue(
self.data_subscribers.samples_received.has_key(stream_name),
msg="Sample queue does not exists")
self.assertEqual(
len(self.data_subscribers.samples_received.get(stream_name)), size)
def assert_data_values(self, particles, dataset_definition_file):
"""
Verify particles match the particles defined in the definition file
"""
rs_file = self._get_source_data_file(dataset_definition_file)
rs = ResultSet(rs_file)
self.assertTrue(rs.verify(particles))
def assert_initialize(self, final_state=ResourceAgentState.STREAMING):
'''
Walk through DSA states to get to streaming mode from uninitialized
'''
log.debug("Initialize DataSet agent")
cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE)
retval = self.dataset_agent_client.execute_agent(cmd)
state = self.dataset_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.INACTIVE)
log.info("Sent INITIALIZE; DSA state = %s", state)
log.debug("DataSet agent go active")
cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE)
retval = self.dataset_agent_client.execute_agent(cmd)
state = self.dataset_agent_client.get_agent_state()
log.info("Sent GO_ACTIVE; DSA state = %s", state)
self.assertEqual(state, ResourceAgentState.IDLE)
log.debug("DataSet agent run")
cmd = AgentCommand(command=ResourceAgentEvent.RUN)
retval = self.dataset_agent_client.execute_agent(cmd)
state = self.dataset_agent_client.get_agent_state()
log.info("Sent RUN; DSA state = %s", state)
self.assertEqual(state, ResourceAgentState.COMMAND)
if final_state == ResourceAgentState.STREAMING:
self.assert_start_sampling()
def assert_stop_sampling(self):
'''
transition to command. Must be called from streaming
'''
state = self.dataset_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.STREAMING)
log.debug("DataSet agent stop sampling")
cmd = AgentCommand(command=DriverEvent.STOP_AUTOSAMPLE)
retval = self.dataset_agent_client.execute_resource(cmd)
state = self.dataset_agent_client.get_agent_state()
log.info("Sent START SAMPLING; DSA state = %s", state)
self.assertEqual(state, ResourceAgentState.COMMAND)
def assert_start_sampling(self):
'''
transition to sampling. Must be called from command
'''
state = self.dataset_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.COMMAND)
log.debug("DataSet agent start sampling")
cmd = AgentCommand(command=DriverEvent.START_AUTOSAMPLE)
retval = self.dataset_agent_client.execute_resource(cmd)
state = self.dataset_agent_client.get_agent_state()
log.info("Sent START SAMPLING; DSA state = %s", state)
self.assertEqual(state, ResourceAgentState.STREAMING)
def assert_reset(self):
'''
Put the instrument back in uninitialized
'''
agent_state = self.dataset_agent_client.get_agent_state()
if agent_state != ResourceAgentState.UNINITIALIZED:
cmd = AgentCommand(command=ResourceAgentEvent.RESET)
retval = self.dataset_agent_client.execute_agent(cmd)
state = self.dataset_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.UNINITIALIZED)
def assert_agent_state(self, target_state):
"""
Verify the current agent state
@param target_state: What we expect the agent state to be
"""
state = self.dataset_agent_client.get_agent_state()
self.assertEqual(state, target_state)
def assert_agent_command(self, command, args=None, timeout=None):
"""
Verify an agent command
@param command: driver command to execute
@param args: kwargs to pass to the agent command object
"""
cmd = AgentCommand(command=command, kwargs=args)
retval = self.instrument_agent_client.execute_agent(cmd,
timeout=timeout)
def assert_resource_command(self, command, args=None, timeout=None):
"""
Verify a resource command
@param command: driver command to execute
@param args: kwargs to pass to the agent command object
"""
cmd = AgentCommand(command=command, kwargs=args)
retval = self.dataset_agent_client.execute_resource(cmd)
def assert_state_change(self, target_agent_state, timeout=10):
"""
Verify the agent and resource states change as expected within the timeout
Fail if the state doesn't change to the expected state.
@param target_agent_state: State we expect the agent to be in
@param timeout: how long to wait for the driver to change states
"""
to = gevent.Timeout(timeout)
to.start()
done = False
agent_state = None
try:
while (not done):
agent_state = self.dataset_agent_client.get_agent_state()
log.error("Current agent state: %s", agent_state)
if (agent_state == target_agent_state):
log.debug("Current state match: %s", agent_state)
done = True
if not done:
log.debug(
"state mismatch, waiting for state to transition.")
gevent.sleep(1)
except Timeout:
log.error(
"Failed to transition agent state to %s, current state: %s",
target_agent_state, agent_state)
self.fail("Failed to transition state.")
finally:
to.cancel()
def assert_event_received(self, event_object_type, timeout=10):
"""
Verify an event has been received of a sepecific type
@param event_object_type: Event object we are looking for
@param timeout: how long to wait
"""
to = gevent.Timeout(timeout)
to.start()
done = False
try:
while (not done):
for event in self.event_subscribers.events_received:
log.debug("Event: %s", event)
if isinstance(event, event_object_type):
done = True
if not done:
log.debug(
"target event not detected, sleep a bit to let events happen"
)
gevent.sleep(1)
except Timeout:
log.error("Failed to find event in queue: %s", event_object_type)
log.error("Current event queue: %s",
self.event_subscribers._events_received)
self.fail("%s event not detected")
finally:
to.cancel()
log.info("Expected event detected: %s", event)
class InstrumentDriverQualificationTestCase(InstrumentDriverTestCase):
@classmethod
def setUpClass(cls):
cls.init_port_agent()
@classmethod
def tearDownClass(cls):
cls.stop_port_agent()
def setUp(self):
"""
@brief Setup test cases.
"""
log.debug("#ROGER# does setUp get called?")
InstrumentDriverTestCase.setUp(self)
self.port_agent = self.test_config.port_agent
self.instrument_agent_manager = InstrumentAgentClient();
self.instrument_agent_manager.start_container(deploy_file=self.test_config.container_deploy_file)
self.container = self.instrument_agent_manager.container
log.debug("#ROGER# in setUp self.test_config.instrument_agent_packet_config = " + str(self.test_config.instrument_agent_packet_config))
self.data_subscribers = InstrumentAgentDataSubscribers(
packet_config=self.test_config.instrument_agent_packet_config,
encoding=self.test_config.instrument_agent_stream_encoding,
stream_definition=self.test_config.instrument_agent_stream_definition
)
log.debug("InstrumentDriverQualificationTestCase setUp Problem BELOW")
self.event_subscribers = InstrumentAgentEventSubscribers(instrument_agent_resource_id=self.test_config.instrument_agent_resource_id)
log.debug("InstrumentDriverQualificationTestCase setUp Problem ABOVE")
self.init_instrument_agent_client()
def init_instrument_agent_client(self):
log.info("Start Instrument Agent Client")
# Driver config
driver_config = {
'dvr_mod' : self.test_config.driver_module,
'dvr_cls' : self.test_config.driver_class,
'workdir' : self.test_config.working_dir,
'process_type' : self.test_config.driver_process_type,
'comms_config' : self.port_agent_comm_config()
}
# Create agent config.
agent_config = {
'driver_config' : driver_config,
'stream_config' : self.data_subscribers.stream_config,
'agent' : {'resource_id': self.test_config.instrument_agent_resource_id},
'test_mode' : True ## Enable a poison pill. If the spawning process dies
## shutdown the daemon process.
}
# ROGER message_headers
# Start instrument agent client.
self.instrument_agent_manager.start_client(
name=self.test_config.instrument_agent_name,
module=self.test_config.instrument_agent_module,
cls=self.test_config.instrument_agent_class,
config=agent_config,
resource_id=self.test_config.instrument_agent_resource_id,
deploy_file=self.test_config.container_deploy_file
)
self.instrument_agent_client = self.instrument_agent_manager.instrument_agent_client
def tearDown(self):
"""
@brief Test teardown
"""
log.debug("InstrumentDriverQualificationTestCase tearDown")
self.instrument_agent_manager.stop_container()
InstrumentDriverTestCase.tearDown(self)
def test_common_qualification(self):
self.assertTrue(1)
# FIXED
@patch.dict(CFG, {'endpoint':{'receive':{'timeout': 1200}}})
def test_instrument_agent_common_state_model_lifecycle(self):
"""
@brief Test agent state transitions.
This test verifies that the instrument agent can
properly command the instrument through the following states.
@todo Once direct access settles down and works again, re-enable direct access.
COMMANDS TESTED
*ResourceAgentEvent.INITIALIZE
*ResourceAgentEvent.RESET
*ResourceAgentEvent.GO_ACTIVE
*ResourceAgentEvent.RUN
*ResourceAgentEvent.PAUSE
*ResourceAgentEvent.RESUME
*ResourceAgentEvent.GO_COMMAND
*ResourceAgentEvent.GO_DIRECT_ACCESS
*ResourceAgentEvent.GO_INACTIVE
*ResourceAgentEvent.PING_RESOURCE
*ResourceAgentEvent.CLEAR
COMMANDS NOT TESTED
* ResourceAgentEvent.GET_RESOURCE_STATE
* ResourceAgentEvent.GET_RESOURCE
* ResourceAgentEvent.SET_RESOURCE
* ResourceAgentEvent.EXECUTE_RESOURCE
STATES ACHIEVED:
* ResourceAgentState.UNINITIALIZED
* ResourceAgentState.INACTIVE
* ResourceAgentState.IDLE'
* ResourceAgentState.STOPPED
* ResourceAgentState.COMMAND
* ResourceAgentState.DIRECT_ACCESS
STATES NOT ACHIEVED:
* ResourceAgentState.STREAMING
* ResourceAgentState.TEST
* ResourceAgentState.CALIBRATE
* ResourceAgentState.BUSY
"""
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.UNINITIALIZED)
cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.INACTIVE)
cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.IDLE)
cmd = AgentCommand(command=ResourceAgentEvent.GO_INACTIVE)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.INACTIVE)
cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.IDLE)
# Works but doesnt return anything useful when i tried.
#cmd = AgentCommand(command=ResourceAgentEvent.GET_RESOURCE_STATE)
#retval = self.instrument_agent_client.execute_agent(cmd)
# works!
retval = self.instrument_agent_client.ping_resource()
retval = self.instrument_agent_client.ping_agent()
cmd = AgentCommand(command=ResourceAgentEvent.PING_RESOURCE)
retval = self.instrument_agent_client.execute_agent(cmd)
self.assertTrue("ping from resource ppid" in retval.result)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.IDLE)
cmd = AgentCommand(command=ResourceAgentEvent.RUN)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.COMMAND)
cmd = AgentCommand(command=ResourceAgentEvent.RESET)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.UNINITIALIZED)
cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.INACTIVE)
cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.IDLE)
cmd = AgentCommand(command=ResourceAgentEvent.RUN)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.COMMAND)
cmd = AgentCommand(command=ResourceAgentEvent.PAUSE)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.STOPPED)
cmd = AgentCommand(command=ResourceAgentEvent.RESUME)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.COMMAND)
cmd = AgentCommand(command=ResourceAgentEvent.CLEAR)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.IDLE)
cmd = AgentCommand(command=ResourceAgentEvent.RUN)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.COMMAND)
cmd = AgentCommand(command=ResourceAgentEvent.GO_DIRECT_ACCESS,
#kwargs={'session_type': DirectAccessTypes.telnet,
kwargs={'session_type':DirectAccessTypes.vsp,
'session_timeout':600,
'inactivity_timeout':600})
retval = self.instrument_agent_client.execute_agent(cmd)
# assert it is as long as expected 4149CB23-AF1D-43DF-8688-DDCD2B8E435E
self.assertTrue(36 == len(retval.result['token']))
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.DIRECT_ACCESS)
cmd = AgentCommand(command=ResourceAgentEvent.GO_COMMAND)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.COMMAND)
cmd = AgentCommand(command=ResourceAgentEvent.RESET)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.UNINITIALIZED)
# FIXED
def test_instrument_agent_to_instrument_driver_connectivity(self):
"""
@brief This test verifies that the instrument agent can
talk to the instrument driver.
The intent of this is to be a ping to the driver
layer.
"""
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.UNINITIALIZED)
cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.INACTIVE)
cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.IDLE)
retval = self.instrument_agent_client.ping_resource()
log.debug("RETVAL = " + str(type(retval)))
self.assertTrue("ping from resource ppid" in retval)
self.assertTrue("time:" in retval)
retval = self.instrument_agent_client.ping_agent()
log.debug("RETVAL = " + str(type(retval)))
self.assertTrue("ping from InstrumentAgent" in retval)
self.assertTrue("time:" in retval)
cmd = AgentCommand(command=ResourceAgentEvent.GO_INACTIVE)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.INACTIVE)
def test_instrument_error_code_enum(self):
"""
@brief check InstErrorCode for consistency
@todo did InstErrorCode become redundant in the last refactor?
"""
self.assertTrue(self.check_for_reused_values(InstErrorCode))
pass
def test_driver_connection_state_enum(self):
"""
@brief check DriverConnectionState for consistency
@todo this check should also be a device specific for drivers like Trhph
"""
# self.assertEqual(TrhphDriverState.UNCONFIGURED, DriverConnectionState.UNCONFIGURED)
# self.assertEqual(TrhphDriverState.DISCONNECTED, DriverConnectionState.DISCONNECTED)
# self.assertEqual(TrhphDriverState.CONNECTED, DriverConnectionState.CONNECTED)
self.assertTrue(self.check_for_reused_values(DriverConnectionState))
# FIXED
def test_resource_agent_event_enum(self):
self.assertTrue(self.check_for_reused_values(ResourceAgentEvent))
# FIXED
def test_resource_agent_state_enum(self):
self.assertTrue(self.check_for_reused_values(ResourceAgentState))
def check_for_reused_values(self, obj):
"""
@author Roger Unwin
@brief verifies that no two definitions resolve to the same value.
@returns True if no reused values
"""
match = 0
outer_match = 0
for i in [v for v in dir(obj) if not callable(getattr(obj,v))]:
if i.startswith('_') == False:
outer_match = outer_match + 1
for j in [x for x in dir(obj) if not callable(getattr(obj,x))]:
if i.startswith('_') == False:
if getattr(obj, i) == getattr(obj, j):
match = match + 1
log.debug(str(i) + " == " + j + " (Looking for reused values)")
# If this assert fails, then two of the enumerations have an identical value...
return match == outer_match
def test_driver_async_event_enum(self):
"""
@ brief ProtocolState enum test
1. test that SBE37ProtocolState matches the expected enums from DriverProtocolState.
2. test that multiple distinct states do not resolve back to the same string.
"""
self.assertTrue(self.check_for_reused_values(DriverAsyncEvent))
@unittest.skip("Transaction management not yet implemented")
def test_transaction_management_messages(self):
"""
@brief This tests the start_transaction and
end_transaction methods.
https://confluence.oceanobservatories.org/display/syseng/CIAD+MI+SV+Instrument+Agent+Interface#CIADMISVInstrumentAgentInterface-Transactionmanagementmessages
* start_transaction(acq_timeout,exp_timeout)
* end_transaction(transaction_id)
* transaction_id
See: ion/services/mi/instrument_agent.py
UPDATE: stub it out fill in later when its available ... place holder
TODO:
"""
pass
def de_dupe(self, list_in):
unique_set = Set(item for item in list_in)
return [(item) for item in unique_set]
@patch.dict(CFG, {'endpoint':{'receive':{'timeout': 1200}}})
def test_driver_notification_messages(self):
"""
@brief This tests event messages from the driver. The following
test moves the IA through all its states. As it does this,
event messages are generated and caught. These messages
are then compared with a list of expected messages to
insure that the proper messages have been generated.
"""
# Clear off any events from before this test so we have consistent state
self.event_subscribers.events_received = []
expected_events = [
'AgentState=RESOURCE_AGENT_STATE_INACTIVE',
'AgentCommand=RESOURCE_AGENT_EVENT_INITIALIZE',
'ResourceState=DRIVER_STATE_DISCONNECTED',
'ResourceState=DRIVER_STATE_DISCONNECTED',
'ResourceState=DRIVER_STATE_UNKNOWN',
'ResourceConfig',
'ResourceState=DRIVER_STATE_COMMAND',
'AgentState=RESOURCE_AGENT_STATE_IDLE',
'AgentCommand=RESOURCE_AGENT_EVENT_GO_ACTIVE',
'AgentState=RESOURCE_AGENT_STATE_COMMAND',
'AgentCommand=RESOURCE_AGENT_EVENT_RUN',
'AgentCommand=RESOURCE_AGENT_PING_RESOURCE',
'ResourceState=DRIVER_STATE_DISCONNECTED',
'ResourceState=DRIVER_STATE_UNCONFIGURED',
'AgentState=RESOURCE_AGENT_STATE_UNINITIALIZED',
'AgentCommand=RESOURCE_AGENT_EVENT_RESET',
'AgentState=RESOURCE_AGENT_STATE_INACTIVE',
'AgentCommand=RESOURCE_AGENT_EVENT_INITIALIZE',
'ResourceState=DRIVER_STATE_DISCONNECTED',
'ResourceState=DRIVER_STATE_DISCONNECTED',
'ResourceState=DRIVER_STATE_UNKNOWN',
'ResourceConfig',
'ResourceState=DRIVER_STATE_COMMAND',
'AgentState=RESOURCE_AGENT_STATE_IDLE',
'AgentCommand=RESOURCE_AGENT_EVENT_GO_ACTIVE',
'AgentState=RESOURCE_AGENT_STATE_COMMAND',
'AgentCommand=RESOURCE_AGENT_EVENT_RUN',
'AgentState=RESOURCE_AGENT_STATE_STOPPED',
'AgentCommand=RESOURCE_AGENT_EVENT_PAUSE',
'AgentState=RESOURCE_AGENT_STATE_COMMAND',
'AgentCommand=RESOURCE_AGENT_EVENT_RESUME',
'AgentState=RESOURCE_AGENT_STATE_IDLE',
'AgentCommand=RESOURCE_AGENT_EVENT_CLEAR',
'AgentState=RESOURCE_AGENT_STATE_COMMAND',
'AgentCommand=RESOURCE_AGENT_EVENT_RUN',
'AgentState=RESOUCE_AGENT_STATE_DIRECT_ACCESS',
'AgentCommand=RESOURCE_AGENT_EVENT_GO_DIRECT_ACCESS',
'ResourceState=DRIVER_STATE_DIRECT_ACCESS',
'ResourceState=DRIVER_STATE_COMMAND',
'AgentState=RESOURCE_AGENT_STATE_COMMAND',
'AgentCommand=RESOURCE_AGENT_EVENT_GO_COMMAND',
'ResourceState=DRIVER_STATE_DISCONNECTED',
'ResourceState=DRIVER_STATE_UNCONFIGURED',
'AgentState=RESOURCE_AGENT_STATE_UNINITIALIZED',
'AgentCommand=RESOURCE_AGENT_EVENT_RESET'
]
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.UNINITIALIZED)
cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.INACTIVE)
cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.IDLE)
cmd = AgentCommand(command=ResourceAgentEvent.RUN)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.COMMAND)
retval = self.instrument_agent_client.ping_resource()
retval = self.instrument_agent_client.ping_agent()
cmd = AgentCommand(command=ResourceAgentEvent.PING_RESOURCE)
retval = self.instrument_agent_client.execute_agent(cmd)
self.assertTrue("ping from resource ppid" in retval.result)
#cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE)
#retval = self.instrument_agent_client.execute_agent(cmd)
#state = self.instrument_agent_client.get_agent_state()
#self.assertEqual(state, ResourceAgentState.IDLE)
#cmd = AgentCommand(command=ResourceAgentEvent.RUN)
#retval = self.instrument_agent_client.execute_agent(cmd)
#state = self.instrument_agent_client.get_agent_state()
#self.assertEqual(state, ResourceAgentState.COMMAND)
cmd = AgentCommand(command=ResourceAgentEvent.RESET)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.UNINITIALIZED)
cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.INACTIVE)
cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.IDLE)
cmd = AgentCommand(command=ResourceAgentEvent.RUN)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.COMMAND)
cmd = AgentCommand(command=ResourceAgentEvent.PAUSE)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.STOPPED)
cmd = AgentCommand(command=ResourceAgentEvent.RESUME)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.COMMAND)
cmd = AgentCommand(command=ResourceAgentEvent.CLEAR)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.IDLE)
cmd = AgentCommand(command=ResourceAgentEvent.RUN)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.COMMAND)
cmd = AgentCommand(command=ResourceAgentEvent.GO_DIRECT_ACCESS,
#kwargs={'session_type': DirectAccessTypes.telnet,
kwargs={'session_type':DirectAccessTypes.vsp,
'session_timeout':600,
'inactivity_timeout':600})
retval = self.instrument_agent_client.execute_agent(cmd)
# assert it is as long as expected 4149CB23-AF1D-43DF-8688-DDCD2B8E435E
self.assertTrue(36 == len(retval.result['token']))
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.DIRECT_ACCESS)
cmd = AgentCommand(command=ResourceAgentEvent.GO_COMMAND)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.COMMAND)
cmd = AgentCommand(command=ResourceAgentEvent.RESET)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.UNINITIALIZED)
#
# Refactor changed it so no description is ever present.
# go with state instead i guess...
#
log.debug("ROGERROGER got to the end!")
raw_events = []
for x in self.event_subscribers.events_received:
if str(type(x)) == "<class 'interface.objects.ResourceAgentCommandEvent'>":
log.debug(str(type(x)) + " ++********************* AgentCommand=" + str(x.execute_command))
raw_events.append("AgentCommand=" + str(x.execute_command))
elif str(type(x)) == "<class 'interface.objects.ResourceAgentResourceStateEvent'>":
log.debug(str(type(x)) + " ++********************* ResourceState=" + str(x.state))
raw_events.append("ResourceState=" + str(x.state))
elif str(type(x)) == "<class 'interface.objects.ResourceAgentStateEvent'>":
log.debug(str(type(x)) + " ++********************* AgentState=" + str(x.state))
raw_events.append("AgentState=" + str(x.state))
elif str(type(x)) == "<class 'interface.objects.ResourceAgentResourceConfigEvent'>":
log.debug(str(type(x)) + " ++********************* ResourceConfig")
raw_events.append("ResourceConfig")
else:
log.debug(str(type(x)) + " ++********************* " + str(x))
for x in sorted(raw_events):
log.debug(str(x) + " ?in (expected_events) = " + str(x in expected_events))
self.assertTrue(x in expected_events)
for x in sorted(expected_events):
log.debug(str(x) + " ?in (raw_events) = " + str(x in raw_events))
self.assertTrue(x in raw_events)
# assert we got the expected number of events
num_expected = len(self.de_dupe(expected_events))
num_actual = len(self.de_dupe(raw_events))
log.debug("num_expected = " + str(num_expected) + " num_actual = " + str(num_actual))
self.assertTrue(num_actual == num_expected)
pass
def test_instrument_driver_to_physical_instrument_interoperability(self):
"""
@Brief this test is the integreation test test_connect
but run through the agent.
On a seabird sbe37 this results in a ds and dc command being sent.
"""
cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.INACTIVE)
cmd = AgentCommand(command=ResourceAgentEvent.GO_ACTIVE)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.IDLE)
@unittest.skip("Driver.get_device_signature not yet implemented")
def test_get_device_signature(self):
"""
@Brief this test will call get_device_signature once that is
implemented in the driver
"""
pass
def test_initialize(self):
"""
Test agent initialize command. This causes creation of
driver process and transition to inactive.
"""
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.UNINITIALIZED)
cmd = AgentCommand(command=ResourceAgentEvent.INITIALIZE)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.INACTIVE)
cmd = AgentCommand(command=ResourceAgentEvent.RESET)
retval = self.instrument_agent_client.execute_agent(cmd)
state = self.instrument_agent_client.get_agent_state()
self.assertEqual(state, ResourceAgentState.UNINITIALIZED)
class TestIAStart(MiUnitTest):
"""
Test the instrument agent startup
"""
def setUp(self):
"""
Setup the test case
"""
self.ia_client = InstrumentAgentClient()
def test_container_rabbitmq(self):
"""
Test that rabbitmq can be started
@TODO This test should start/stop rabbitmq and couch in setup, as it leaves the system in a bad state.
"""
self.ia_client.start_rabbitmq_server()
pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("rabbitmq"))
self.assertTrue(pid)
self.ia_client.start_rabbitmq_server()
new_pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("rabbitmq"))
self.assertEqual(pid, new_pid)
self.ia_client.stop_rabbitmq_server()
pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("rabbitmq"))
self.assertFalse(pid)
def test_container_couchdb(self):
"""Test that couchdb can be started"""
self.ia_client.start_couchdb()
pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("couchdb"))
self.assertTrue(pid)
self.ia_client.start_couchdb()
new_pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("couchdb"))
self.assertEqual(pid, new_pid)
self.ia_client.stop_couchdb()
pid = self.ia_client._read_pidfile(self.ia_client._pid_filename("couchdb"))
self.assertFalse(pid)
def test_container_start(self):
"""Test that a container can be started"""
self.ia_client.start_container()
self.assertTrue(self.ia_client.container)
self.ia_client.stop_container()
self.assertFalse(self.ia_client.container)
def test_data_subscriber(self):
"""
Test that we can build data subscribers using the packet config from the IDK
"""
data_subscriber = InstrumentAgentDataSubscribers()
