def setUp(self):
basic = Timestamp()
default = Timestamp(default=1235475793.0324881)
optional = Timestamp(optional=True)
default_optional = Timestamp(default=1235475793.0324881, optional=True)
self._pack = [
(basic, 1235475381.6966901, "1235475381696"),
(basic, "a", ValueError),
(basic, None, ValueError),
(default, None, "1235475793032"),
(default_optional, None, "1235475793032"),
(optional, None, ValueError),
]
self._unpack = [
(basic, "1235475381696", 1235475381.6960001),
(basic, "a", ValueError),
(basic, None, ValueError),
(default, None, 1235475793.0324881),
(default_optional, None, 1235475793.0324881),
(optional, None, None),
]
class MyServer(DeviceServer):
VERSION_INFO = ("example-api", 1, 0)
BUILD_INFO = ("example-implementation", 0, 1, "")
# Optionally set the KATCP protocol version and features. Defaults to
# the latest implemented version of KATCP, with all supported optional
# features
PROTOCOL_INFO = ProtocolFlags(5, 0, set([
ProtocolFlags.MULTI_CLIENT,
ProtocolFlags.MESSAGE_IDS,
]))
FRUIT = [
"apple", "banana", "pear", "kiwi",
]
def setup_sensors(self):
"""Setup some server sensors."""
self._add_result = Sensor.float("add.result",
"Last ?add result.", "", [-10000, 10000])
self._add_result.set_value(0, Sensor.UNREACHABLE)
self._time_result = Sensor.timestamp("time.result",
"Last ?time result.", "")
self._time_result.set_value(0, Sensor.INACTIVE)
self._eval_result = Sensor.string("eval.result",
"Last ?eval result.", "")
self._eval_result.set_value('', Sensor.UNKNOWN)
self._fruit_result = Sensor.discrete("fruit.result",
"Last ?pick-fruit result.", "", self.FRUIT)
self._fruit_result.set_value('apple', Sensor.ERROR)
self.add_sensor(self._add_result)
self.add_sensor(self._time_result)
self.add_sensor(self._eval_result)
self.add_sensor(self._fruit_result)
@request(Float(), Float())
@return_reply(Float())
def request_add(self, req, x, y):
"""Add two numbers"""
r = x + y
self._add_result.set_value(r)
return ("ok", r)
@request()
@return_reply(Timestamp())
def request_time(self, req):
"""Return the current time in ms since the Unix Epoch."""
r = time.time()
self._time_result.set_value(r)
return ("ok", r)
@request(Str())
@return_reply(Str())
def request_eval(self, req, expression):
"""Evaluate a Python expression."""
r = str(eval(expression))
self._eval_result.set_value(r)
return ("ok", r)
@request()
@return_reply(Discrete(FRUIT))
def request_pick_fruit(self, req):
"""Pick a random fruit."""
r = random.choice(self.FRUIT + [None])
if r is None:
return ("fail", "No fruit.")
delay = random.randrange(1,5)
req.inform("Picking will take %d seconds" % delay)
def pick_handler():
self._fruit_result.set_value(r)
req.reply("ok", r)
handle_timer = threading.Timer(delay, pick_handler)
handle_timer.start()
raise AsyncReply
@request(Str())
@return_reply()
def request_set_sensor_inactive(self, req, sensor_name):
"""Set sensor status to inactive"""
sensor = self.get_sensor(sensor_name)
ts, status, value = sensor.read()
sensor.set_value(value, sensor.INACTIVE, ts)
return('ok',)
@request(Str())
@return_reply()
def request_set_sensor_unreachable(self, req, sensor_name):
"""Set sensor status to unreachable"""
sensor = self.get_sensor(sensor_name)
ts, status, value = sensor.read()
sensor.set_value(value, sensor.UNREACHABLE, ts)
return('ok',)
def request_raw_reverse(self, req, msg):
"""
A raw request handler to demonstrate the calling convention if
@request decoraters are not used. Reverses the message arguments.
"""
# msg is a katcp.Message.request object
reversed_args = msg.arguments[::-1]
# req.make_reply() makes a katcp.Message.reply using the correct request
# name and message ID
return req.make_reply(*reversed_args)
class MyServer(AsyncDeviceServer):
VERSION_INFO = ("example-api", 1, 0)
BUILD_INFO = ("example-implementation", 0, 1, "")
# Optionally set the KATCP protocol version and features. Defaults to
# the latest implemented version of KATCP, with all supported optional
# featuresthat's all of the receivers
PROTOCOL_INFO = ProtocolFlags(5, 0, set([
ProtocolFlags.MULTI_CLIENT,
ProtocolFlags.MESSAGE_IDS,
]))
FRUIT = [
"apple", "banana", "pear", "kiwi",
]
def setup_sensors(self):
"""Setup some server sensors."""
self._add_result = Sensor.float("add.result",
"Last ?add result.", "", [-10000, 10000])
self._time_result = Sensor.timestamp("time.result",
"Last ?time result.", "")
self._eval_result = Sensor.string("eval.result",
"Last ?eval result.", "")
self._fruit_result = Sensor.discrete("fruit.result",
"Last ?pick-fruit result.", "", self.FRUIT)
self._device_armed = Sensor.boolean(
"device-armed",
description="Is the CAM server armed?",
initial_status=Sensor.NOMINAL,
default=True)
self._bandwidth = Sensor.float("bandwidth", default=300)
self._sourcename = Sensor.string("sourcename", default="none")
self._source_ra = Sensor.string("source_RA", default=0)
self._source_dec = Sensor.string("source_DEC", default=0)
self._exposure_time = Sensor.float("EXP_time", default=0)
self.add_sensor(self._sourcename)
self.add_sensor(self._source_ra)
self.add_sensor(self._source_dec)
self.add_sensor(self._exposure_time)
self.add_sensor(self._bandwidth)
self.add_sensor(self._device_armed)
self.add_sensor(self._add_result)
self.add_sensor(self._time_result)
self.add_sensor(self._eval_result)
self.add_sensor(self._fruit_result)
self._systemp_result = Sensor.float("add.result",
"Last ?add result.", "", [-10000, 10000])
self.add_sensor(self._systemp_result)
##self._bandwidth = Sensor.float("bandwidth", default=300)
#self.add_sensor(self._bandwidth)
@request()
@return_reply(Str())
def request_bandwidth(self, req, bw):
"""Return the Bandwidth"""
#req.inform("checking armed status", self._device_armed.value())
req.reply("ok", bw)
raise AsyncReply
@request()
@return_reply(Str())
def request_status_armed(self, req):
"""Return the state of the Armed/Disarmed"""
req.inform("checking armed status", self._device_armed.value())
req.reply("ok", self._device_armed.value())
raise AsyncReply
@request(Float())
@return_reply()
def request_long_action(self, req, t):
"""submit a long action command for testing using coroutine"""
@tornado.gen.coroutine
def wait():
yield tornado.gen.sleep(t)
req.reply("slept for", t, "second")
self.ioloop.add_callback(wait)
raise AsyncReply
@request(Float(), Float())
@return_reply(Str())
def request_radec(self, req, ra, dec):
"""testing to read in the RA DEC fomr a client"""
# test=ra+dec
self.ra = ra
self.dec = dec
return ("ok", "%f %f" % (self.ra, self.dec))
@request(Float(), Float())
@return_reply(Float())
def request_add(self, req, x, y):
"""Add two numbers"""
r = x + y
self._add_result.set_value(r)
return ("ok", r)
@request()
@return_reply(Str())
def request_arm(self, req):
"""Arm the controller"""
@tornado.gen.coroutine
def start_controller():
req.inform("processing", "command processing")
try:
yield tornado.gen.sleep(10)
except Exception as error:
req.reply("fail", "Unknown error: {0}".format(str(error)))
else:
req.reply("ok", "effcam armed")
self._device_armed.set_value(True)
if self._device_armed.value():
return ("fail", "Effcam is already armed")
self.ioloop.add_callback(start_controller)
raise AsyncReply
@request()
@return_reply(Str())
def request_disarm(self, req):
"""disarm the controller"""
@tornado.gen.coroutine
# @coroutine
def stop_controller():
req.inform("processing", "processing command")
try:
yield tornado.gen.sleep(10)
# yield self._controller.stop()
except Exception as error:
req.reply("fail", "Unknown error: {0}".format(str(error)))
else:
req.reply("ok", "effcam disarmed")
self._device_armed.set_value(False)
if self._device_armed.value() == False:
return ("fail", "Effcam is already disarmed")
self.ioloop.add_callback(stop_controller)
raise AsyncReply
@request()
@return_reply(Str())
def request_status_temp(self, req):
"""Return the current temp"""
#r = time.time()
t = "36"
# self._time_result.set_value(r)
return ("ok", t)
@request()
@return_reply(Timestamp())
def request_status_time(self, req):
"""Return the current time in seconds since the Unix Epoch."""
req.inform("processing", "processing command")
r = time.time()
# self._time_result.set_value(r)
req.reply("ok", r)
raise AsyncReply
# return ("ok", r)
@request()
@return_reply(Timestamp(), Str())
def request_status_time_and_temp(self, req):
"""Return the current time in seconds since the Unix Epoch."""
req.inform("processing", "processing command")
r = time.time()
# self._time_result.set_value(r)
t = "36"
req.reply("ok", r, t)
raise AsyncReply
@request(Str())
@return_reply()
def request_configure(self, req, config):
"""Return ok."""
print "{} received configuration {}".format(Time.now(),config)
self.config = config
time.sleep(1)
req.reply("ok",)
raise AsyncReply
@request(Str())
@return_reply()
def request_provision(self, req, config):
"""Return ok."""
print "{} received provision {}".format(Time.now(),config)
self.config = config
time.sleep(1)
req.reply("ok",)
raise AsyncReply
@request(Str())
@return_reply()
def request_measurement_prepare(self, req, config):
"""Return ok."""
print "{} received measurement prepare {}".format(Time.now(),config)
self.config = config
time.sleep(1)
req.reply("ok",)
raise AsyncReply
@request(Str())
@return_reply()
def request_configure(self, req, config):
"""Return ok."""
print "{} received configuration {}".format(Time.now(),config)
self.config = config
time.sleep(1)
req.reply("ok",)
raise AsyncReply
@request()
@return_reply(Str())
def request_status_config(self, req):
"""Return ok."""
req.reply("ok", "{}".format(self.config))
raise AsyncReply
@request()
@return_reply()
def request_capture_start(self, req):
"""Return ok."""
print "{} received capture start request on port :{}".format(Time.now(), server_port)
req.reply("ok")
raise AsyncReply
@request()
@return_reply()
def request_capture_stop(self, req):
"""Return ok."""
print "{} received capture stop request on port :{}".format(Time.now(), server_port)
req.reply("ok")
raise AsyncReply
@request()
@return_reply()
def request_measurement_start(self, req):
"""Return ok."""
print "{} received measurement start request on port :{}".format(Time.now(), server_port)
req.reply("ok")
raise AsyncReply
@request()
@return_reply()
def request_measurement_stop(self, req):
"""Return ok."""
print "{} received measurement stop request on port :{}".format(Time.now(), server_port)
req.reply("ok")
raise AsyncReply
@request()
@return_reply()
def request_deconfigure(self, req):
"""Return ok."""
print "{} received deconfigure request on port :{}".format(Time.now(), server_port)
req.reply("ok")
raise AsyncReply
@request()
@return_reply()
def request_deprovision(self, req):
"""Return ok."""
print "{} received deprovision request on port :{}".format(Time.now(), server_port)
req.reply("ok")
raise AsyncReply()
@return_reply()
def request_start(self, req):
"""Return ok."""
print "{} received start request on port :{}".format(Time.now(), server_port)
req.reply("ok")
raise AsyncReply
@request()
@return_reply()
def request_stop(self, req):
"""Return ok."""
print "{} received stop request on port :{}".format(Time.now(), server_port)
req.reply("ok")
raise AsyncReply
class TestDevice(object):
def __init__(self):
self.sent_messages = []
@request(Int(min=1, max=10), Discrete(("on", "off")), Bool())
@return_reply(Int(min=1, max=10), Discrete(("on", "off")), Bool())
def request_one(self, req, i, d, b):
if i == 3:
return ("fail", "I failed!")
if i == 5:
return ("bananas", "This should never be sent")
if i == 6:
return ("ok", i, d, b, "extra parameter")
if i == 9:
self.finish_request_one(req, i, d, b)
raise AsyncReply()
return ("ok", i, d, b)
@send_reply(Int(min=1, max=10), Discrete(("on", "off")), Bool())
def finish_request_one(self, req, i, d, b):
return (req, "ok", i, d, b)
def reply(self, req, msg, orig_msg):
self.sent_messages.append([req, msg])
@request(Int(min=1, max=3, default=2),
Discrete(("on", "off"), default="off"), Bool(default=True))
@return_reply(Int(min=1, max=3), Discrete(("on", "off")), Bool())
def request_two(self, req, i, d, b):
return ("ok", i, d, b)
@return_reply(Int(min=1, max=3), Discrete(("on", "off")), Bool())
@request(Int(min=1, max=3), Discrete(("on", "off")), Bool())
def request_three(self, req, i, d, b):
return ("ok", i, d, b)
@return_reply()
@request()
def request_four(self, req):
return ["ok"]
@inform(Int(min=1, max=3), Discrete(("on", "off")), Bool())
def inform_one(self, i, d, b):
pass
@request(Timestamp(), Timestamp(optional=True), major=4)
@return_reply(Timestamp(), Timestamp(default=321), major=4)
def request_katcpv4_time(self, req, timestamp1, timestamp2):
self.katcpv4_time1 = timestamp1
self.katcpv4_time2 = timestamp2
if timestamp2:
return ('ok', timestamp1, timestamp2)
else:
return ('ok', timestamp1)
@request(Timestamp(multiple=True), major=4)
@return_reply(Timestamp(multiple=True), major=4)
def request_katcpv4_time_multi(self, req, *timestamps):
self.katcpv4_time_multi = timestamps
return ('ok', ) + timestamps
@return_reply(Int(), Str())
@request(Int(), include_msg=True)
def request_eight(self, req, msg, i):
return ("ok", i, msg.name)
@request(Int(), Float(multiple=True))
@return_reply(Int(), Float(multiple=True))
def request_int_multifloat(self, req, i, *floats):
return ('ok', i) + floats