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