def send_evt_msg(zmq_driver_process): """ Await events on the driver process event queue and publish them on a ZMQ PUB socket to the driver process client. """ context = zmq.Context() sock = context.socket(zmq.PUB) sock.bind(zmq_driver_process.event_host_string) mi_logger.info('Driver process event socket bound to %s', zmq_driver_process.event_host_string) zmq_driver_process.stop_evt_thread = False while not zmq_driver_process.stop_evt_thread: try: evt = zmq_driver_process.events.pop(0) mi_logger.debug('Event thread sending event %s', str(evt)) while evt: try: sock.send_pyobj(evt, flags=zmq.NOBLOCK) evt = None mi_logger.debug('Event sent!') except zmq.ZMQError: time.sleep(.1) except IndexError: time.sleep(.1) sock.close() context.term() mi_logger.info('Driver process event socket closed')
def recv_cmd_msg(zmq_driver_process): """ Await commands on a ZMQ REP socket, forwaring them to the driver for processing and returning the result. """ context = zmq.Context() sock = context.socket(zmq.REP) sock.bind(zmq_driver_process.cmd_host_string) mi_logger.info('Driver process cmd socket bound to %s', zmq_driver_process.cmd_host_string) zmq_driver_process.stop_cmd_thread = False while not zmq_driver_process.stop_cmd_thread: try: msg = sock.recv_pyobj(flags=zmq.NOBLOCK) mi_logger.debug('Processing message %s', str(msg)) reply = zmq_driver_process.cmd_driver(msg) while True: try: sock.send_pyobj(reply) break except zmq.ZMQError: time.sleep(.1) except zmq.ZMQError: time.sleep(.1) sock.close() context.term() mi_logger.info('Driver process cmd socket closed.')
def recv_cmd_msg(zmq_driver_process): """ Await commands on a ZMQ REP socket, forwaring them to the driver for processing and returning the result. """ context = zmq.Context() sock = context.socket(zmq.REP) zmq_driver_process.cmd_port = sock.bind_to_random_port(zmq_driver_process.cmd_host_string) mi_logger.info("Driver process cmd socket bound to %i", zmq_driver_process.cmd_port) file(zmq_driver_process.cmd_port_fname, "w+").write(str(zmq_driver_process.cmd_port) + "\n") zmq_driver_process.stop_cmd_thread = False while not zmq_driver_process.stop_cmd_thread: try: msg = sock.recv_pyobj(flags=zmq.NOBLOCK) mi_logger.debug("Processing message %s", str(msg)) reply = zmq_driver_process.cmd_driver(msg) while True: try: sock.send_pyobj(reply, flags=zmq.NOBLOCK) break except zmq.ZMQError: time.sleep(0.1) if zmq_driver_process.stop_cmd_thread: break except zmq.ZMQError: time.sleep(0.1) sock.close() context.term() mi_logger.info("Driver process cmd socket closed.")
def send_evt_msg(zmq_driver_process): """ Await events on the driver process event queue and publish them on a ZMQ PUB socket to the driver process client. """ context = zmq.Context() sock = context.socket(zmq.PUB) zmq_driver_process.evt_port = sock.bind_to_random_port(zmq_driver_process.event_host_string) mi_logger.info("Driver process event socket bound to %i", zmq_driver_process.evt_port) file(zmq_driver_process.evt_port_fname, "w+").write(str(zmq_driver_process.evt_port) + "\n") zmq_driver_process.stop_evt_thread = False while not zmq_driver_process.stop_evt_thread: try: evt = zmq_driver_process.events.pop(0) mi_logger.debug("Event thread sending event %s", str(evt)) while evt: try: sock.send_pyobj(evt, flags=zmq.NOBLOCK) evt = None mi_logger.debug("Event sent!") except zmq.ZMQError: time.sleep(0.1) if zmq_driver_process.stop_evt_thread: break except IndexError: time.sleep(0.1) sock.close() context.term() mi_logger.info("Driver process event socket closed")
def test_configure(self): """Driver configuration tests""" channels = Some.VALID_CHANNELS + Some.INVALID_CHANNELS mi_logger.debug("\n configure: %s" % str(channels)) configs = {} for c in channels: configs[c] = {'method': 'ethernet', 'device_addr': '1.1.1.1', 'device_port': 1, 'server_addr': '2.2.2.2', 'server_port': 2} result = self.driver.configure(configs) _print_dict("\n configure result", result) for c in channels: self.assertTrue(c in result) for c in Some.INVALID_CHANNELS: self.assertEqual(result[c], InstErrorCode.INVALID_CHANNEL) for c in Some.VALID_CHANNELS: self.assertEqual(result[c], InstErrorCode.OK)
def get(self, params, *args, **kwargs): mi_logger.debug("MyProtocol(%s).get: params=%s" % (self._channel, str(params))) assert isinstance(params, (list, tuple)) result = {} for param in params: if param in self._values: value = self._values[param] else: value = InstErrorCode.INVALID_PARAMETER result[param] = value return result
def test_connect_disconnect(self): """Test state change when connecting and disconnecting""" result = self.driver.get_current_state() mi_logger.debug("Initial state result: %s", result) self.assertEquals(result[Channel.INSTRUMENT], DriverState.UNCONFIGURED) self.driver.chan_map[Channel.INSTRUMENT].connect = Mock(return_value = 12) result = self.driver.connect() result = self.driver.get_current_state() # Verify we hit the protocol since we are "connected" self.assertEquals(result[Channel.INSTRUMENT], DriverState.UNCONFIGURED) result = self.driver.disconnect() result = self.driver.get_current_state() # driver FSM should intercept self.assertEquals(result[Channel.INSTRUMENT], DriverConnectionState.DISCONNECTED)
def test_get_params_channel_all(self): """Driver get all params tests""" params = [(Channel.ALL, Parameter.PARAM1), (Channel.ALL, Parameter.PARAM2)] mi_logger.debug("\nGET: %s" % str(params)) get_result = self.driver.get(params) _print_dict("\nGET get_result", get_result) for c in Channel.list(): if c != Channel.ALL: self.assertTrue((c, Parameter.PARAM1) in get_result) self.assertTrue((c, Parameter.PARAM2) in get_result)
def test_get_params(self): """Driver get params tests""" params = Some.VALID_PARAMS + Some.INVALID_PARAMS mi_logger.debug("\nGET: %s" % str(params)) get_result = self.driver.get(params) _print_dict("\nGET get_result", get_result) self.assertEqual(get_result[("invalid_chan", Parameter.PARAM1)], InstErrorCode.INVALID_CHANNEL) self.assertEqual(get_result[(Channel.CHAN1, "invalid_param")], InstErrorCode.INVALID_PARAMETER) for cp in Some.VALID_PARAMS: self.assertTrue(cp in get_result)
def test_connect(self): """Driver connection tests""" channels = Some.VALID_CHANNELS + Some.INVALID_CHANNELS mi_logger.debug("\n connect: %s" % str(channels)) result = self.driver.connect(channels) _print_dict("\n connect result", result) for c in channels: self.assertTrue(c in result) for c in Some.INVALID_CHANNELS: self.assertEqual(result[c], InstErrorCode.INVALID_CHANNEL) for c in Some.VALID_CHANNELS: self.assertEqual(result[c], InstErrorCode.OK)
def set(self, params, *args, **kwargs): mi_logger.debug("MyProtocol(%s).set: params=%s" % (self._channel, str(params))) assert isinstance(params, dict) updated_params = 0 result = {} for (param, value) in params.items(): if param in self._values: if isinstance(value, int): self._values[param] = value result[param] = InstErrorCode.OK updated_params += 1 else: result[param] = InstErrorCode.INVALID_PARAM_VALUE else: result[param] = InstErrorCode.INVALID_PARAMETER # self.announce_to_driver(DriverAnnouncement.CONFIG_CHANGE, # msg="%s parameter(s) successfully set." % # updated_params) return result
def test_get_set(self): """ Test driver parameter get/set interface including device persistence. TA2=-4.858579e-06 PTCA1=-0.6603433 TCALDATE=(8, 11, 2005) """ # Launch driver process. driver_process = ZmqDriverProcess.launch_process(self.cmd_port, self.evt_port, self.dvr_mod, self.dvr_cls) # Create client and start messaging. driver_client = ZmqDriverClient(self.server_addr, self.cmd_port, self.evt_port) driver_client.start_messaging() time.sleep(3) # Configure driver for comms and transition to disconnected. reply = driver_client.cmd_dvr('configure', self.comms_config) time.sleep(2) # Establish devcie comms and transition to command. reply = driver_client.cmd_dvr('connect') time.sleep(2) # Get all parameters. get_params = [ (SBE37Channel.CTD, SBE37Parameter.ALL) ] reply = driver_client.cmd_dvr('get', get_params) time.sleep(2) # Check overall and individual parameter success. Check parameter types. self.assertIsInstance(reply, dict) self.assertIsInstance(reply[(SBE37Channel.CTD, SBE37Parameter.TA2)], float) self.assertIsInstance(reply[(SBE37Channel.CTD, SBE37Parameter.PTCA1)], float) self.assertIsInstance(reply[(SBE37Channel.CTD, SBE37Parameter.TCALDATE)], (list, tuple)) # Set up a param dict of the original values. old_ta2 = reply[(SBE37Channel.CTD, SBE37Parameter.TA2)] old_ptca1 = reply[(SBE37Channel.CTD, SBE37Parameter.PTCA1)] old_tcaldate = reply[(SBE37Channel.CTD, SBE37Parameter.TCALDATE)] orig_params = { (SBE37Channel.CTD, SBE37Parameter.TA2): old_ta2, (SBE37Channel.CTD, SBE37Parameter.PTCA1): old_ptca1, (SBE37Channel.CTD, SBE37Parameter.TCALDATE): old_tcaldate } # Set up a param dict of new values. new_ta2 = old_ta2*2 new_ptcal1 = old_ptca1*2 new_tcaldate = list(old_tcaldate) new_tcaldate[2] = new_tcaldate[2] + 1 new_tcaldate = tuple(new_tcaldate) new_params = { (SBE37Channel.CTD, SBE37Parameter.TA2): new_ta2, (SBE37Channel.CTD, SBE37Parameter.PTCA1): new_ptcal1, (SBE37Channel.CTD, SBE37Parameter.TCALDATE): new_tcaldate } # Set the params to their new values. reply = driver_client.cmd_dvr('set', new_params) time.sleep(2) # Check overall success and success of the individual paramters. self.assertIsInstance(reply, dict) mi_logger.debug('set result: %s', str(reply)) # Get the same paramters back from the driver. get_params = [ (SBE37Channel.CTD, SBE37Parameter.TA2), (SBE37Channel.CTD, SBE37Parameter.PTCA1), (SBE37Channel.CTD, SBE37Parameter.TCALDATE) ] reply = driver_client.cmd_dvr('get', get_params) time.sleep(2) # Check success, and check that the parameters were set to the # new values. self.assertIsInstance(reply, dict) self.assertIsInstance(reply[(SBE37Channel.CTD, SBE37Parameter.TA2)], float) self.assertIsInstance(reply[(SBE37Channel.CTD, SBE37Parameter.PTCA1)], float) self.assertIsInstance(reply[(SBE37Channel.CTD, SBE37Parameter.TCALDATE)], (list, tuple)) self.assertAlmostEqual(reply[(SBE37Channel.CTD, SBE37Parameter.TA2)], new_ta2, delta=abs(0.01*new_ta2)) self.assertAlmostEqual(reply[(SBE37Channel.CTD, SBE37Parameter.PTCA1)], new_ptcal1, delta=abs(0.01*new_ptcal1)) self.assertEqual(reply[(SBE37Channel.CTD, SBE37Parameter.TCALDATE)], new_tcaldate) # Set the paramters back to their original values. reply = driver_client.cmd_dvr('set', orig_params) self.assertIsInstance(reply, dict) mi_logger.debug('set result: %s', str(reply)) # Get the parameters back from the driver. reply = driver_client.cmd_dvr('get', get_params) # Check overall and individual sucess, and that paramters were # returned to their original values. self.assertIsInstance(reply, dict) self.assertIsInstance(reply[(SBE37Channel.CTD, SBE37Parameter.TA2)], float) self.assertIsInstance(reply[(SBE37Channel.CTD, SBE37Parameter.PTCA1)], float) self.assertIsInstance(reply[(SBE37Channel.CTD, SBE37Parameter.TCALDATE)], (list, tuple)) self.assertAlmostEqual(reply[(SBE37Channel.CTD, SBE37Parameter.TA2)], old_ta2, delta=abs(0.01*old_ta2)) self.assertAlmostEqual(reply[(SBE37Channel.CTD, SBE37Parameter.PTCA1)], old_ptca1, delta=abs(0.01*old_ptca1)) self.assertEqual(reply[(SBE37Channel.CTD, SBE37Parameter.TCALDATE)], old_tcaldate) # Disconnect driver from the device and transition to disconnected. reply = driver_client.cmd_dvr('disconnect', [SBE37Channel.CTD]) time.sleep(2) # Deconfigure the driver and transition to unconfigured. reply = driver_client.cmd_dvr('initialize', [SBE37Channel.CTD]) time.sleep(2) # End driver process and client messaging. driver_client.done() driver_process.wait()
def _print_dict(title, d): mi_logger.debug("%s:" % title) for item in d.items(): mi_logger.debug("\t%s" % str(item))