def test_request(self): client = katcp.DeviceClient(*self.server_addr) start_thread_with_cleanup(self, client, start_timeout=1) t0 = time.time() client.request(katcp.Message.request('stupidlongrequest' * 1000000), timeout=0.1) # If the send_message() call is in an EAGAIN spinning loop it will never # return, so getting here at all is a good sign :) self.assertLess(time.time() - t0, 1)
def setUp(self): super(test_KATCPClientResource_IntegratedTimewarp, self).setUp() self.server = DeviceTestServer('', 0) start_thread_with_cleanup(self, self.server) self.host, self.port = self.server.bind_address self.default_resource_spec = dict( name='thething', address=self.server.bind_address, controlled=True)
def setUp(self): self.server = DeviceTestServer('', 0) start_thread_with_cleanup(self, self.server, start_timeout=0.1) host, port = self.server._sock.getsockname() self.client = katcp.BlockingClient(host, port) start_thread_with_cleanup(self, self.client, start_timeout=0.1) self.assertTrue(self.client.wait_protocol(timeout=1))
def setUp(self): super(TestInspectingClientAsync, self).setUp() self.server = DeviceTestServer('', 0) start_thread_with_cleanup(self, self.server, start_timeout=1) self.host, self.port = self.server.bind_address self.client = InspectingClientAsync(self.host, self.port, ioloop=self.io_loop) self.io_loop.add_callback(self.client.connect)
def test_request(self): client = katcp.DeviceClient(*self.server_addr) start_thread_with_cleanup(self, client, start_timeout=1) t0 = time.time() client.request( katcp.Message.request('stupidlongrequest'*1000000), timeout=0.1) # If the send_message() call is in an EAGAIN spinning loop it will never # return, so getting here at all is a good sign :) self.assertLess(time.time() - t0, 1)
def setUp(self): super(TestDeviceServerClientIntegrated, self).setUp() self._setup_server() host, port = self.server.bind_address self.server_addr = (host, port) self.client = BlockingTestClient(self, host, port) start_thread_with_cleanup(self, self.client, start_timeout=1) self.assertTrue(self.client.wait_protocol(timeout=1))
def setUp(self): super(Test_InformHookDeviceClient, self).setUp() self.server = DeviceTestServer('', 0) start_thread_with_cleanup(self, self.server, start_timeout=1) self.host, self.port = self.server.bind_address self.client = katcp.inspecting_client._InformHookDeviceClient( self.host, self.port) self.client.set_ioloop(self.io_loop) self.io_loop.add_callback(self.client.start)
def setUp(self): self.server = DeviceTestServer('', 0) start_thread_with_cleanup(self, self.server, start_timeout=1) host, port = self.server.bind_address self.client = katcp.BlockingClient(host, port) start_thread_with_cleanup(self, self.client, start_timeout=1) self.assertTrue(self.client.wait_protocol(timeout=1))
def setUp(self): self.server = DeviceTestServer('', 0) start_thread_with_cleanup(self, self.server, start_timeout=1) host, port = self.server.bind_address self.client = katcp.DeviceClient(host, port) self.client.enable_thread_safety() start_thread_with_cleanup(self, self.client, start_timeout=1) self.client.wait_connected(timeout=1)
def setUp(self): """Set up for test.""" # test sensor # self._print_lock = threading.Lock() self._time_lock = threading.Lock() self._next_wakeup = 1e99 self.wake_waits = Queue.Queue() self.sensor = DeviceTestSensor( Sensor.INTEGER, "an.int", "An integer.", "count", [-4, 3], timestamp=12345, status=Sensor.NOMINAL, value=3) # test callback self.inform_called = threading.Event() def inform(sensor_name, timestamp, status, value): self.inform_called.set() self.calls.append((self.time(), (sensor_name, float(timestamp), status, value)) ) def next_wakeup_callback(timeout): with self._time_lock: if timeout is not None: next_wake = self.time() + timeout self._next_wakeup = min(self._next_wakeup, next_wake) else: self._next_wakeup = 1e99 self.wake_waits.put(timeout) def waited_callback(start, end, timeout): # A callback that updates 'simulated time' whenever wake.wait() is # called with self._time_lock: self._next_wakeup = 1e99 # test reactor self.reactor = sampling.SampleReactor() # Patch time.time so that we can lie about time. self.time_patcher = mock.patch('katcp.sampling.time') mtime = self.time_patcher.start() self.addCleanup(self.time_patcher.stop) self.time = mtime.time self.start_time = self.time.return_value = 0 # Replace the reactor wake Event with a time-warping mock Event self.reactor._wakeEvent = self.wake = wake = FakeEvent( self.time, next_wakeup_callback, waited_callback) start_thread_with_cleanup(self, self.reactor) # Wait for the event loop to reach its first wake.wait() self.wake_waits.get(timeout=1) self.calls = [] self.inform = inform
def setUp(self): super(TestInspectingClientAsyncStateCallback, self).setUp() self.server = DeviceTestServer('', 0) start_thread_with_cleanup(self, self.server, start_timeout=1) self.host, self.port = self.server.bind_address self.state_cb_future = tornado.concurrent.Future() self.client = InspectingClientAsync(self.host, self.port, ioloop=self.io_loop) self.client.set_state_callback(self._test_state_cb) self.done_state_cb_futures = [] self.cnt_state_cb_futures = collections.defaultdict(tornado.concurrent.Future)
def setUp(self): super(TestInspectingClientAsyncStateCallback, self).setUp() self.server = DeviceTestServer('', 0) start_thread_with_cleanup(self, self.server, start_timeout=1) self.host, self.port = self.server.bind_address self.state_cb_future = tornado.concurrent.Future() self.client = InspectingClientAsync(self.host, self.port, ioloop=self.io_loop) # Set a short initial_resync timeout to make resync tests quick self.client.initial_resync_timeout = 0.001 self.client.set_state_callback(self._test_state_cb) self.done_state_cb_futures = [] self.cnt_state_cb_futures = collections.defaultdict(tornado.concurrent.Future)
def setUpClassWithCleanup(cls): cls.tango_db = cleanup_tempfile(cls, prefix='tango', suffix='.db') cls.xmi_file = [pkg_resources.resource_filename( 'tango_simlib.tests', 'devenum_test_case.xmi')] cls.device_name = 'test/nodb/tangodeviceserver' model = tango_sim_generator.configure_device_model(cls.xmi_file, cls.device_name) cls.TangoDeviceServer = tango_sim_generator.get_tango_device_server( model, cls.xmi_file)[0] cls.tango_context = TangoTestContext(cls.TangoDeviceServer, device_name=cls.device_name, db=cls.tango_db) start_thread_with_cleanup(cls, cls.tango_context)
def _get_server(self, hints): """Return a running test server with or without request timeout hints Parameters ---------- hints : bool Whether or not the server should have request timeout hints enabled """ ServerClass = (DeviceTestServerWithTimeoutHints if hints else DeviceTestServer) server = ServerClass('', 0) start_thread_with_cleanup(self, server, start_timeout=1) host, port = server.bind_address return host, port, server
def setUp(self): self.receiver = CorrRx(port=8888) start_thread_with_cleanup(self, self.receiver, start_timeout=1) self.correlator = correlator_fixture.correlator self.corr_fix = correlator_fixture self.corr_freqs = CorrelatorFrequencyInfo(self.correlator.configd) dsim_conf = self.correlator.configd['dsimengine'] dig_host = dsim_conf['host'] self.dhost = FpgaDsimHost(dig_host, config=dsim_conf) self.dhost.get_system_information() # Increase the dump rate so tests can run faster self.correlator.xeng_set_acc_time(0.2) self.addCleanup(self.corr_fix.stop_x_data) self.corr_fix.start_x_data() self.corr_fix.issue_metadata()
def test_request_sensor_sampling_clear(self): self.server.clear_strategies = mock.Mock() start_thread_with_cleanup(self, self.server, start_timeout=1) client_connection = ClientConnectionTest() self.server.ioloop.make_current() tf = self.server.handle_message( client_connection, katcp.Message.request('sensor-sampling-clear')) # tf may be a tornado (not thread-safe) future, so we wrap it in a thread-safe # future object f = Future() self.server.ioloop.add_callback(gen.chain_future, tf, f) f.result(timeout=1) # Ensure that the tornado future has finished running its callbacks self.server.sync_with_ioloop() self._assert_msgs_equal(client_connection.messages, [ '!sensor-sampling-clear ok']) self.server.clear_strategies.assert_called_once_with(client_connection)
def test_request_sensor_sampling_clear(self): self.server.clear_strategies = mock.Mock() start_thread_with_cleanup(self, self.server, start_timeout=1) client_connection = ClientConnectionTest() self.server.ioloop.make_current() tf = self.server.handle_message( client_connection, katcp.Message.request('sensor-sampling-clear')) # tf may be a tornado (not thread-safe) future, so we wrap it in a thread-safe # future object f = Future() self.server.ioloop.add_callback(gen.chain_future, tf, f) f.result(timeout=1) # Ensure that the tornado future has finished running its callbacks self.server.sync_with_ioloop() self._assert_msgs_equal(client_connection.messages, ['!sensor-sampling-clear ok']) self.server.clear_strategies.assert_called_once_with(client_connection)
def setUpClassWithCleanup(cls): cls.tango_db = cleanup_tempfile(cls, prefix='tango', suffix='.db') cls.data_descr_files = [] cls.data_descr_files.append( pkg_resources.resource_filename('tango_simlib.tests', 'DishElementMaster.xmi')) cls.data_descr_files.append( pkg_resources.resource_filename('tango_simlib.tests', 'DishElementMaster_SIMDD.json')) cls.device_name = 'test/nodb/tangodeviceserver' model = tango_sim_generator.configure_device_model( cls.data_descr_files, cls.device_name) cls.TangoDeviceServer = tango_sim_generator.get_tango_device_server( model, cls.data_descr_files)[0] cls.tango_context = TangoTestContext(cls.TangoDeviceServer, device_name=cls.device_name, db=cls.tango_db) start_thread_with_cleanup(cls, cls.tango_context)
def test_sensor_sampling(self): start_thread_with_cleanup(self, self.server) s = katcp.Sensor.boolean('a-sens') s.set(1234, katcp.Sensor.NOMINAL, True) self.server.add_sensor(s) self.server._send_message = WaitingMock() self.server.wait_running(timeout=1.) self.assertTrue(self.server.running()) self.server._strategies = defaultdict(lambda: {}) req = mock_req('sensor-sampling', 'a-sens', 'event') self.server.request_sensor_sampling(req, req.msg).result(timeout=1) inf = req.client_connection.inform inf.assert_wait_call_count(count=1) (inf_msg, ) = inf.call_args[0] self._assert_msgs_equal( [inf_msg], (r'#sensor-status 1234000 1 a-sens nominal 1', )) req = mock_req('sensor-sampling', 'a-sens', 'period', 1000) self.server.request_sensor_sampling(req, req.msg).result() client = req.client_connection strat = self.server._strategies[client][s] # Test that the periodic update period is converted to seconds self.assertEqual(strat._period, 1.) # test that parameters returned by the request matches v4 format. # # We need to pass in the same client_conn as used by the previous # request since strategies are bound to specific connections req = mock_req('sensor-sampling', 'a-sens', client_conn=client) reply = self.server.request_sensor_sampling(req, req.msg).result() self._assert_msgs_equal([reply], ['!sensor-sampling ok a-sens period 1000']) # event-rate is not an allowed v4 strategy with self.assertRaises(FailReply): self.server.request_sensor_sampling( req, katcp.Message.request('sensor-sampling', 'a-sens', 'event-rate', 1000, 2000)).result() # differential-rate is not an allowed v4 strategy with self.assertRaises(FailReply): self.server.request_sensor_sampling( req, katcp.Message.request('sensor-sampling', 'a-sens', 'differential-rate', 1, 1000, 2000)).result()
def test_sensor_sampling(self): start_thread_with_cleanup(self, self.server) s = katcp.Sensor.boolean('a-sens') s.set(1234, katcp.Sensor.NOMINAL, True) self.server.add_sensor(s) self.server._send_message = WaitingMock() self.server.wait_running(timeout=1.) self.assertTrue(self.server.running()) self.server._strategies = defaultdict(lambda : {}) req = mock_req('sensor-sampling', 'a-sens', 'event') self.server.request_sensor_sampling(req, req.msg) inf = req.client_connection.inform inf.assert_wait_call_count(count=1) (inf_msg, ) = inf.call_args[0] self._assert_msgs_equal([inf_msg], ( r'#sensor-status 1234000 1 a-sens nominal 1',)) req = mock_req('sensor-sampling', 'a-sens', 'period', 1000) self.server.request_sensor_sampling(req, req.msg) client = req.client_connection strat = self.server._strategies[client][s] # Test that the periodic update period is converted to seconds self.assertEqual(strat._period, 1.) # test that parameters returned by the request matches v4 format. # # We need to pass in the same client_conn as used by the previous # request since strategies are bound to specific connections req = mock_req('sensor-sampling', 'a-sens', client_conn=client) reply = self.server.request_sensor_sampling(req, req.msg) self._assert_msgs_equal([reply], ['!sensor-sampling ok a-sens period 1000']) # event-rate is not an allowed v4 strategy with self.assertRaises(FailReply): self.server.request_sensor_sampling(req, katcp.Message.request( 'sensor-sampling', 'a-sens', 'event-rate', 1000, 2000)) # differential-rate is not an allowed v4 strategy with self.assertRaises(FailReply): self.server.request_sensor_sampling(req, katcp.Message.request( 'sensor-sampling', 'a-sens', 'differential-rate', 1, 1000, 2000))
def setUp(self): super(test_KATCPClientResourceContainerIntegrated, self).setUp() self.default_spec = dict(clients={ 'resource1' : dict(controlled=True), 'resource2' : dict(controlled=True), 'resource3' : dict(controlled=True)}, name='intgtest') self.resource_names = self.default_spec['clients'].keys() self.servers = {rn: DeviceTestServer('', 0) for rn in self.resource_names} for i, (s_name, s) in enumerate(sorted(self.servers.items())): start_thread_with_cleanup(self, s) self.default_spec['clients'][s_name]['address'] = s.bind_address # Add a unique sensor to each server sensor = DeviceTestSensor(DeviceTestSensor.INTEGER, "int."+s_name, "An Integer.", "count", [-50, 50], timestamp=self.io_loop.time(), status=DeviceTestSensor.NOMINAL, value=i) s.add_sensor(sensor) # Add a unique request to each server def handler(self, req, msg): """A new command.""" return Message.reply(msg.name, "ok", "bling1", "bling2") s._request_handlers['sparkling-new-'+s_name] = handler
def setUp(self): self.server = DeviceTestServer('', 0) start_thread_with_cleanup(self, self.server) self.ioloop_manager = ioloop_manager.IOLoopManager(managed_default=True) self.io_loop = self.ioloop_manager.get_ioloop() self.host, self.port = self.server.bind_address self.default_resource_spec = dict( name='thething', address=self.server.bind_address, controlled=True) self.client_resource = resource_client.KATCPClientResource( self.default_resource_spec) self.client_resource.set_ioloop(self.io_loop) self.io_loop.add_callback(self.client_resource.start) self.ioloop_thread_wrapper = resource_client.IOLoopThreadWrapper(self.io_loop) start_thread_with_cleanup(self, self.ioloop_manager, start_timeout=1) self.ioloop_thread_wrapper.default_timeout = 1 self.DUT = resource_client.ThreadSafeKATCPClientResourceWrapper( self.client_resource, self.ioloop_thread_wrapper) self.DUT.until_synced()
def setUp(self): self.ioloop_manager = ioloop_manager.IOLoopManager(managed_default=True) self.io_loop = self.ioloop_manager.get_ioloop() self.io_loop.make_current() self.ioloop_thread_wrapper = resource_client.IOLoopThreadWrapper(self.io_loop) start_thread_with_cleanup(self, self.ioloop_manager, start_timeout=1) self.ioloop_thread_wrapper.default_timeout = 1 self.default_spec = dict(clients={ 'resource1' : dict(controlled=True), 'resource2' : dict(controlled=True)}, name='wraptest') self.resource_names = self.default_spec['clients'].keys() self.servers = {rn: DeviceTestServer('', 0) for rn in self.resource_names} for i, (s_name, s) in enumerate(sorted(self.servers.items())): start_thread_with_cleanup(self, s) self.default_spec['clients'][s_name]['address'] = s.bind_address # Add a unique sensor to each server sensor = DeviceTestSensor(DeviceTestSensor.INTEGER, "int."+s_name, "An Integer.", "count", [-50, 50], timestamp=self.io_loop.time(), status=DeviceTestSensor.NOMINAL, value=i) s.add_sensor(sensor) # Add a unique request to each server def handler(self, req, msg): """A new command.""" return Message.reply(msg.name, "ok", "bling1", "bling2") s._request_handlers['sparkling-new-'+s_name] = handler self.resource_container = resource_client.KATCPClientResourceContainer( self.default_spec) self.DUT = resource_client.ThreadSafeKATCPClientResourceWrapper( self.resource_container, self.ioloop_thread_wrapper) self.DUT.start() self.DUT.until_synced()
def setUp(self): self.ioloop_manager = ioloop_manager.IOLoopManager(managed_default=True) self.ioloop = self.ioloop_manager.get_ioloop() self.ioloop_thread_wrapper = ioloop_manager.IOLoopThreadWrapper(self.ioloop) start_thread_with_cleanup(self, self.ioloop_manager, start_timeout=1)
def _setup_server(self): self.server = DeviceTestServer('', 0) start_thread_with_cleanup(self, self.server, start_timeout=1)
def _setup_server(self): self.server = DeviceTestServer('', 0) self.server.set_concurrency_options(thread_safe=False, handler_thread=False) start_thread_with_cleanup(self, self.server, start_timeout=1)
def setUp(self): self.ioloop_manager = ioloop_manager.IOLoopManager(managed_default=True) self.ioloop = self.ioloop_manager.get_ioloop() self.ioloop_thread_wrapper = resource_client.IOLoopThreadWrapper(self.ioloop) start_thread_with_cleanup(self, self.ioloop_manager, start_timeout=1)
def setUp(self): super(TestDeviceClientMemoryLeaks, self).setUp() self.server = DeviceTestServer('', 0) start_thread_with_cleanup(self, self.server, start_timeout=0.1) self.host, self.port = self.server.bind_address