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 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):
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):
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_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_server(self):
self.server = DeviceTestServer('', 0)
start_thread_with_cleanup(self, self.server, 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
