def setup_sensors(self):
"""
@brief Set up monitoring sensors.
@note The following sensors are made available on top of defaul sensors
implemented in AsynDeviceServer and its base classes.
device-status: Reports the health status of the FBFUSE and associated devices:
Among other things report HW failure, SW failure and observation failure.
"""
self._device_status = Sensor.discrete(
"device-status",
description="Health status of BLUSE",
params=self.DEVICE_STATUSES,
default="ok",
initial_status=Sensor.NOMINAL)
self.add_sensor(self._device_status)
self._local_time_synced = Sensor.boolean(
"local-time-synced",
description="Indicates BLUSE is NTP syncronised.",
default=True, # TODO: implement actual NTP synchronization request
initial_status=Sensor.NOMINAL)
self.add_sensor(self._local_time_synced)
self._version = Sensor.string(
"version",
description="Reports the current BLUSE version",
default=str(self.VERSION_INFO[1:]).strip('()').replace(
' ', '').replace(",", '.'), # e.g. '1.0'
initial_status=Sensor.NOMINAL)
self.add_sensor(self._version)
def setup_sensors(self):
"""Set up basic monitoring sensors.
"""
for name, params in self._parser.items():
if params["type"] == "float":
sensor = Sensor.float(name,
description=params["description"],
unit=params.get("units", None),
default=params.get("default", 0.0),
initial_status=Sensor.UNKNOWN)
elif params["type"] == "string":
sensor = Sensor.string(name,
description=params["description"],
default=params.get("default", ""),
initial_status=Sensor.UNKNOWN)
elif params["type"] == "int":
sensor = Sensor.integer(name,
description=params["description"],
default=params.get("default", 0),
unit=params.get("units", None),
initial_status=Sensor.UNKNOWN)
elif params["type"] == "bool":
sensor = Sensor.boolean(name,
description=params["description"],
default=params.get("default", False),
initial_status=Sensor.UNKNOWN)
else:
raise Exception("Unknown sensor type '{0}' requested".format(
params["type"]))
self.add_sensor(sensor)
def setup_sensors_beam (self, beam):
b = str(beam)
self._beam_sensors = {}
self.script.log(2, "KATCPServer::setup_sensors_beam ="+b)
self._beam_sensors["observing"] = Sensor.boolean("observing",
description="Beam " + b + " is observing",
unit="",
default=0)
self.add_sensor(self._beam_sensors["observing"])
self._beam_sensors["snr"] = Sensor.float("snr",
description="SNR of Beam "+b,
unit="",
params=[0,1e9],
default=0)
self.add_sensor(self._beam_sensors["snr"])
self._beam_sensors["power"] = Sensor.float("power",
description="Power Level of Beam "+b,
unit="",
default=0)
self.add_sensor(self._beam_sensors["power"])
self._beam_sensors["integrated"] = Sensor.float("integrated",
description="Length of integration for Beam "+b,
unit="",
default=0)
self.add_sensor(self._beam_sensors["integrated"])
def setup_sensors(self):
"""
@brief Set up monitoring sensors.
@note The following sensors are made available on top of default sensors
implemented in AsynDeviceServer and its base classes.
device-status: Reports the health status of the controller and associated devices:
Among other things report HW failure, SW failure and observation failure.
local-time-synced: Indicates whether the local time of the servers
is synchronised to the master time reference (use NTP).
This sensor is aggregated from all nodes that are part
of FBF and will return "not sync'd" if any nodes are
unsyncronised.
products: The list of product_ids that controller is currently handling
"""
self._device_status = Sensor.discrete(
"device-status",
description="Health status of FBFUSE",
params=self.DEVICE_STATUSES,
default="ok",
initial_status=Sensor.NOMINAL)
self.add_sensor(self._device_status)
self._local_time_synced = Sensor.boolean(
"local-time-synced",
description="Indicates FBF is NTP syncronised.",
default=True,
initial_status=Sensor.UNKNOWN)
self.add_sensor(self._local_time_synced)
def ntp_callback():
log.debug("Checking NTP sync")
try:
synced = check_ntp_sync()
except Exception:
log.exception("Unable to check NTP sync")
self._local_time_synced.set_value(False)
else:
if not synced:
log.warning("Server is not NTP synced")
self._local_time_synced.set_value(synced)
ntp_callback()
self._ntp_callback = PeriodicCallback(ntp_callback,
NTP_CALLBACK_PERIOD)
self._ntp_callback.start()
self._products_sensor = Sensor.string(
"products",
description="The names of the currently configured products",
default="",
initial_status=Sensor.NOMINAL)
self.add_sensor(self._products_sensor)
def setup_sensors_beam(self, beam):
b = str(beam)
self._beam_sensors = {}
self.script.log(2, "KATCPServer::setup_sensors_beam beam=" + b)
self._beam_sensors["observing"] = Sensor.boolean("observing",
description="Beam " +
b + " is observing",
unit="",
default=0)
self.add_sensor(self._beam_sensors["observing"])
self._beam_sensors["snr"] = Sensor.float("snr",
description="SNR of Beam " +
b,
unit="",
params=[0, 1e9],
default=0)
self.add_sensor(self._beam_sensors["snr"])
self._beam_sensors["beamformer_stddev_polh"] = Sensor.float(
"beamformer_stddev_polh",
description="Standard deviation of beam voltages for pol H",
unit="",
params=[0, 127],
default=0)
self.add_sensor(self._beam_sensors["beamformer_stddev_polh"])
self._beam_sensors["beamformer_stddev_polv"] = Sensor.float(
"beamformer_stddev_polv",
description="Standard deviation of beam voltages for pol V",
unit="",
params=[0, 127],
default=0)
self.add_sensor(self._beam_sensors["beamformer_stddev_polv"])
self._beam_sensors["integrated"] = Sensor.float(
"integrated",
description="Length of integration for Beam " + b,
unit="",
default=0)
self.add_sensor(self._beam_sensors["integrated"])
self._beam_sensors["input_channels"] = Sensor.integer(
"input_channels",
description="Number of configured input channels for Beam " + b,
unit="",
default=0)
self.add_sensor(self._beam_sensors["input_channels"])
def setup_sensors_beam (self, beam):
b = str(beam)
self._beam_sensors = {}
self.script.log(2, "KATCPServer::setup_sensors_beam beam="+b)
self._beam_sensors["observing"] = Sensor.boolean("observing",
description="Beam " + b + " is observing",
unit="",
default=0)
self.add_sensor(self._beam_sensors["observing"])
self._beam_sensors["snr"] = Sensor.float("snr",
description="SNR of Beam "+b,
unit="",
params=[0,1e9],
default=0)
self.add_sensor(self._beam_sensors["snr"])
self._beam_sensors["beamformer_stddev_polh"] = Sensor.float("beamformer_stddev_polh",
description="Standard deviation of beam voltages for pol H",
unit="",
params=[0,127],
default=0)
self.add_sensor(self._beam_sensors["beamformer_stddev_polh"])
self._beam_sensors["beamformer_stddev_polv"] = Sensor.float("beamformer_stddev_polv",
description="Standard deviation of beam voltages for pol V",
unit="",
params=[0,127],
default=0)
self.add_sensor(self._beam_sensors["beamformer_stddev_polv"])
self._beam_sensors["integrated"] = Sensor.float("integrated",
description="Length of integration for Beam "+b,
unit="",
default=0)
self.add_sensor(self._beam_sensors["integrated"])
self._beam_sensors["input_channels"] = Sensor.integer("input_channels",
description="Number of configured input channels for Beam "+b,
unit="",
default=0)
self.add_sensor(self._beam_sensors["input_channels"])
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)
def setup_sensors(self):
"""Set up basic monitoring sensors.
"""
for name, params in self._parser.items():
v = params.copy()
v.pop('updater')
if 'range' in v:
v.pop('range')
self.__eddDataStore.addTelescopeDataItem(name, v)
if params["type"] == "float":
sensor = Sensor.float(name,
description=params["description"],
unit=params.get("units", None),
default=params.get("default", 0.0),
initial_status=Sensor.UNKNOWN)
elif params["type"] == "string":
sensor = Sensor.string(name,
description=params["description"],
default=params.get("default", ""),
initial_status=Sensor.UNKNOWN)
elif params["type"] == "int":
sensor = Sensor.integer(name,
description=params["description"],
default=params.get("default", 0),
unit=params.get("units", None),
initial_status=Sensor.UNKNOWN)
elif params["type"] == "bool":
sensor = Sensor.boolean(name,
description=params["description"],
default=params.get("default", False),
initial_status=Sensor.UNKNOWN)
else:
raise Exception("Unknown sensor type '{0}' requested".format(
params["type"]))
self.add_sensor(sensor)
def setup_sensors(self):
self.add_sensor(Sensor.boolean('asens'))
def setup_sensors_host (self, host, port):
self.script.log(2, "KATCPServer::setup_sensors_host ("+host+","+port+")")
sock = sockets.openSocket (DL, host, int(port), 1)
if sock:
self.script.log(2, "KATCPServer::setup_sensors_host sock.send(" + self.script.lmc_cmd + ")")
sock.send (self.script.lmc_cmd + "\r\n")
lmc_reply = sock.recv (65536)
sock.close()
xml = xmltodict.parse(lmc_reply)
self._host_sensors = {}
# Disk sensors
self.script.log(2, "KATCPServer::setup_sensors_host configuring disk sensors")
disk_prefix = host+".disk"
self._host_sensors["disk_size"] = Sensor.float(disk_prefix+".size",
description=host+": disk size",
unit="MB",
params=[8192,1e9],
default=0)
self._host_sensors["disk_available"] = Sensor.float(disk_prefix+".available",
description=host+": disk available space",
unit="MB",
params=[1024,1e9],
default=0)
self.add_sensor(self._host_sensors["disk_size"])
self.add_sensor(self._host_sensors["disk_available"])
# Server Load sensors
self.script.log(2, "KATCPServer::setup_sensors_host configuring load sensors")
self._host_sensors["num_cores"] = Sensor.integer (host+".num_cores",
description=host+": disk available space",
unit="MB",
params=[1,64],
default=0)
self._host_sensors["load1"] = Sensor.float(host+".load.1min",
description=host+": 1 minute load ",
unit="",
default=0)
self._host_sensors["load5"] = Sensor.float(host+".load.5min",
description=host+": 5 minute load ",
unit="",
default=0)
self._host_sensors["load15"] = Sensor.float(host+".load.15min",
description=host+": 15 minute load ",
unit="",
default=0)
self.add_sensor(self._host_sensors["num_cores"])
self.add_sensor(self._host_sensors["load1"])
self.add_sensor(self._host_sensors["load5"])
self.add_sensor(self._host_sensors["load15"])
cpu_temp_pattern = re.compile("cpu[0-9]+_temp")
fan_speed_pattern = re.compile("fan[0-9,a-z]+")
power_supply_pattern = re.compile("ps[0-9]+_status")
self.script.log(2, "KATCPServer::setup_sensors_host configuring other metrics")
if not xml["lmc_reply"]["sensors"] == None:
for sensor in xml["lmc_reply"]["sensors"]["metric"]:
name = sensor["@name"]
if name == "system_temp":
self._host_sensors[name] = Sensor.float((host+".system_temp"),
description=host+": system temperature",
unit="C",
params=[-20,150],
default=0)
self.add_sensor(self._host_sensors[name])
if cpu_temp_pattern.match(name):
(cpu, junk) = name.split("_")
self._host_sensors[name] = Sensor.float((host+"." + name),
description=host+": "+ cpu +" temperature",
unit="C",
params=[-20,150],
default=0)
self.add_sensor(self._host_sensors[name])
if fan_speed_pattern.match(name):
self._host_sensors[name] = Sensor.float((host+"." + name),
description=host+": "+name+" speed",
unit="RPM",
params=[0,20000],
default=0)
self.add_sensor(self._host_sensors[name])
if power_supply_pattern.match(name):
self._host_sensors[name] = Sensor.boolean((host+"." + name),
description=host+": "+name,
unit="",
default=0)
self.add_sensor(self._host_sensors[name])
# TODO consider adding power supply sensors: e.g.
# device-status-kronos1-powersupply1
# device-status-kronos1-powersupply2
# device-status-kronos2-powersupply1
# device-status-kronos2-powersupply2
# TODO consider adding raid/disk sensors: e.g.
# device-status-<host>-raid
# device-status-<host>-raid-disk1
# device-status-<host>-raid-disk2
self.script.log(2, "KATCPServer::setup_sensors_host done!")
else:
self.script.log(2, "KATCPServer::setup_sensors_host no sensors found")
else:
self.script.log(-2, "KATCPServer::setup_sensors_host: could not connect to LMC")
def setup_sensors(self):
# Position sensors
self._SCM_request_azim = Sensor.float("SCM.request-azim", "Sky-space requested azimuth position.", "Degrees CW of north")
self.add_sensor(self._SCM_request_azim)
self._SCM_request_elev = Sensor.float("SCM.request-elev", "Sky-space requested elevation position.", "Degrees CW of north")
self.add_sensor(self._SCM_request_elev)
self._SCM_desired_azim = Sensor.float("SCM.desired-azim", "Sky-space desired azimuth position.", "Degrees CW of north")
self.add_sensor(self._SCM_desired_azim)
self._SCM_desired_elev = Sensor.float("SCM.desired-elev", "Sky-space desired elevation position.", "Degrees CW of north")
self.add_sensor(self._SCM_desired_elev)
self._SCM_actual_azim = Sensor.float("SCM.actual-azim", "Sky-space actual azimuth position.", "Degrees CW of north")
self.add_sensor(self._SCM_actual_azim)
self._SCM_actual_elev = Sensor.float("SCM.actual-elev", "Sky-space actual elevation position.", "Degrees CW of north")
self.add_sensor(self._SCM_actual_elev)
# Pointing model
self._SCM_pmodel1 = Sensor.float("SCM.pmodel1", "Pointing model parameter 1")
self.add_sensor(self._SCM_pmodel1)
self._SCM_pmodel2 = Sensor.float("SCM.pmodel2", "Pointing model parameter 2")
self.add_sensor(self._SCM_pmodel2)
self._SCM_pmodel3 = Sensor.float("SCM.pmodel3", "Pointing model parameter 3")
self.add_sensor(self._SCM_pmodel3)
self._SCM_pmodel4 = Sensor.float("SCM.pmodel4", "Pointing model parameter 4")
self.add_sensor(self._SCM_pmodel4)
self._SCM_pmodel5 = Sensor.float("SCM.pmodel5", "Pointing model parameter 5")
self.add_sensor(self._SCM_pmodel5)
self._SCM_pmodel6 = Sensor.float("SCM.pmodel6", "Pointing model parameter 6")
self.add_sensor(self._SCM_pmodel6)
self._SCM_pmodel7 = Sensor.float("SCM.pmodel7", "Pointing model parameter 7")
self.add_sensor(self._SCM_pmodel7)
self._SCM_pmodel8 = Sensor.float("SCM.pmodel8", "Pointing model parameter 8")
self.add_sensor(self._SCM_pmodel8)
self._SCM_pmodel9 = Sensor.float("SCM.pmodel9", "Pointing model parameter 9")
self.add_sensor(self._SCM_pmodel9)
self._SCM_pmodel10 = Sensor.float("SCM.pmodel10", "Pointing model parameter 10")
self.add_sensor(self._SCM_pmodel10)
self._SCM_pmodel11 = Sensor.float("SCM.pmodel11", "Pointing model parameter 11")
self.add_sensor(self._SCM_pmodel11)
self._SCM_pmodel12 = Sensor.float("SCM.pmodel12", "Pointing model parameter 12")
self.add_sensor(self._SCM_pmodel12)
self._SCM_pmodel13 = Sensor.float("SCM.pmodel13", "Pointing model parameter 13")
self.add_sensor(self._SCM_pmodel13)
self._SCM_pmodel14= Sensor.float("SCM.pmodel14", "Pointing model parameter 14")
self.add_sensor(self._SCM_pmodel14)
self._SCM_pmodel15= Sensor.float("SCM.pmodel15", "Pointing model parameter 15")
self.add_sensor(self._SCM_pmodel15)
self._SCM_pmodel16 = Sensor.float("SCM.pmodel16", "Pointing model parameter 16")
self.add_sensor(self._SCM_pmodel16)
self._SCM_pmodel17 = Sensor.float("SCM.pmodel17", "Pointing model parameter 17")
self.add_sensor(self._SCM_pmodel17)
self._SCM_pmodel18 = Sensor.float("SCM.pmodel18", "Pointing model parameter 18")
self.add_sensor(self._SCM_pmodel18)
self._SCM_pmodel19 = Sensor.float("SCM.pmodel19", "Pointing model parameter 19")
self.add_sensor(self._SCM_pmodel19)
self._SCM_pmodel20 = Sensor.float("SCM.pmodel20", "Pointing model parameter 20")
self.add_sensor(self._SCM_pmodel20)
self._SCM_pmodel21 = Sensor.float("SCM.pmodel21", "Pointing model parameter 21")
self.add_sensor(self._SCM_pmodel21)
self._SCM_pmodel22 = Sensor.float("SCM.pmodel22", "Pointing model parameter 22")
self.add_sensor(self._SCM_pmodel22)
self._SCM_pmodel23 = Sensor.float("SCM.pmodel23", "Pointing model parameter 23")
self.add_sensor(self._SCM_pmodel23)
self._SCM_pmodel24 = Sensor.float("SCM.pmodel24", "Pointing model parameter 24")
self.add_sensor(self._SCM_pmodel24)
self._SCM_pmodel25 = Sensor.float("SCM.pmodel25", "Pointing model parameter 25")
self.add_sensor(self._SCM_pmodel25)
self._SCM_pmodel26 = Sensor.float("SCM.pmodel26", "Pointing model parameter 26")
self.add_sensor(self._SCM_pmodel26)
self._SCM_pmodel27 = Sensor.float("SCM.pmodel27", "Pointing model parameter 27")
self.add_sensor(self._SCM_pmodel27)
self._SCM_pmodel28 = Sensor.float("SCM.pmodel28", "Pointing model parameter 28")
self.add_sensor(self._SCM_pmodel28)
self._SCM_pmodel29 = Sensor.float("SCM.pmodel29", "Pointing model parameter 29")
self.add_sensor(self._SCM_pmodel29)
self._SCM_pmodel30 = Sensor.float("SCM.pmodel30", "Pointing model parameter 30")
self.add_sensor(self._SCM_pmodel30)
# # Target
self._SCM_Target = Sensor.string("SCM.Target", "Target description string in katpoint format")
self.add_sensor(self._SCM_Target)
# Antenna activity
self._SCM_Antenna_Activity = Sensor.string("SCM.AntennaActivity", "Antenna activity label")
self.add_sensor(self._SCM_Antenna_Activity)
# RF sensor information
self._SCM_LcpAttenuation = Sensor.float("SCM.LcpAttenuation", "Variable attenuator setting on LCP")
self.add_sensor(self._SCM_LcpAttenuation)
self._SCM_RcpAttenuation = Sensor.float("SCM.RcpAttenuation", "Variable attenuator setting on RCP")
self.add_sensor(self._SCM_RcpAttenuation)
self._RFC_LcpFreqSel = Sensor.boolean("RFC.LcpFreqSel", "LCP Frequency Select Switch")
self.add_sensor(self._RFC_LcpFreqSel)
self._RFC_RcpFreqSel = Sensor.boolean("RFC.RcpFreqSel", "RCP Frequency Select Switch")
self.add_sensor(self._RFC_RcpFreqSel)
self._RFC_IntermediateStage_5GHz = Sensor.float("RFC.IntermediateStage_5GHz", "5 GHz Intermediate Stage LO frequency")
self.add_sensor(self._RFC_IntermediateStage_5GHz)
self._RFC_IntermediateStage_6_7GHz = Sensor.float("RFC.IntermediateStage_6_7GHz", "6.7 GHz Intermediate Stage LO frequency")
self.add_sensor(self._RFC_IntermediateStage_6_7GHz)
self._RFC_FinalStage = Sensor.float("RFC.FinalStage", "Final Stage LO frequency")
self.add_sensor(self._RFC_FinalStage)
# Noise diode sensor information
self._RFC_NoiseDiode_1 = Sensor.integer("RFC.NoiseDiode_1", "All noise diode data (bitfield)")
self.add_sensor(self._RFC_NoiseDiode_1)
# EMS information
self._EMS_WindDirection = Sensor.float("EMS.WindDirection", "Wind direction")
self.add_sensor(self._EMS_WindDirection)
self._EMS_WindSpeed = Sensor.float("EMS.WindSpeed", "Wind speed")
self.add_sensor(self._EMS_WindSpeed)
self._EMS_AirTemperature = Sensor.float("EMS.AirTemperature", "Air temperature")
self.add_sensor(self._EMS_AirTemperature)
self._EMS_AbsolutePressure = Sensor.float("EMS.AbsolutePressure", "Air pressure")
self.add_sensor(self._EMS_AbsolutePressure)
self._EMS_RelativeHumidity = Sensor.float("EMS.RelativeHumidity", "Ambient relative humidity")
self.add_sensor(self._EMS_RelativeHumidity)
self.animation_thread = threading.Thread(target=self.sensor_value_thread_function)
self.animation_thread.start()
def setup_sensors_host (self, host, port):
self.script.log(1, "KATCPServer::setup_sensors_host ("+host+","+port+")")
sock = sockets.openSocket (DL, host, int(port), 1)
if sock:
self.script.log(2, "KATCPServer::setup_sensors_host sock.send(" + self.script.lmc_cmd + ")")
sock.send (self.script.lmc_cmd + "\r\n")
lmc_reply = sock.recv (65536)
sock.close()
xml = xmltodict.parse(lmc_reply)
self.script.log(2, "KATCPServer::setup_sensors_host sock.recv=" + str(xml))
self._host_sensors = {}
# Disk sensors
self.script.log(2, "KATCPServer::setup_sensors_host configuring disk sensors")
disk_prefix = host+".disk"
self._host_sensors["disk_size"] = Sensor.float(disk_prefix+".size",
description=host+": disk size",
unit="MB",
params=[8192,1e9],
default=0)
self._host_sensors["disk_available"] = Sensor.float(disk_prefix+".available",
description=host+": disk available space",
unit="MB",
params=[1024,1e9],
default=0)
self.add_sensor(self._host_sensors["disk_size"])
self.add_sensor(self._host_sensors["disk_available"])
# Server Load sensors
self.script.log(2, "KATCPServer::setup_sensors_host configuring load sensors")
self._host_sensors["num_cores"] = Sensor.integer (host+".num_cores",
description=host+": disk available space",
unit="MB",
params=[1,64],
default=0)
self._host_sensors["load1"] = Sensor.float(host+".load.1min",
description=host+": 1 minute load ",
unit="",
default=0)
self._host_sensors["load5"] = Sensor.float(host+".load.5min",
description=host+": 5 minute load ",
unit="",
default=0)
self._host_sensors["load15"] = Sensor.float(host+".load.15min",
description=host+": 15 minute load ",
unit="",
default=0)
self._host_sensors["local_time_synced"] = Sensor.boolean("local_time_synced",
description=host+": NTP server synchronisation",
unit="",
default=0)
self.add_sensor(self._host_sensors["num_cores"])
self.add_sensor(self._host_sensors["num_cores"])
self.add_sensor(self._host_sensors["load1"])
self.add_sensor(self._host_sensors["load5"])
self.add_sensor(self._host_sensors["load15"])
self.add_sensor(self._host_sensors["local_time_synced"])
cpu_temp_pattern = re.compile("cpu[0-9]+_temp")
fan_speed_pattern = re.compile("fan[0-9,a-z]+")
power_supply_pattern = re.compile("ps[0-9]+_status")
self.script.log(2, "KATCPServer::setup_sensors_host configuring other metrics")
if not xml["lmc_reply"]["sensors"] == None:
for sensor in xml["lmc_reply"]["sensors"]["metric"]:
name = sensor["@name"]
if name == "system_temp":
self._host_sensors[name] = Sensor.float((host+".system_temp"),
description=host+": system temperature",
unit="C",
params=[-20,150],
default=0)
self.add_sensor(self._host_sensors[name])
if cpu_temp_pattern.match(name):
(cpu, junk) = name.split("_")
self._host_sensors[name] = Sensor.float((host+"." + name),
description=host+": "+ cpu +" temperature",
unit="C",
params=[-20,150],
default=0)
self.add_sensor(self._host_sensors[name])
if fan_speed_pattern.match(name):
self._host_sensors[name] = Sensor.float((host+"." + name),
description=host+": "+name+" speed",
unit="RPM",
params=[0,20000],
default=0)
self.add_sensor(self._host_sensors[name])
if power_supply_pattern.match(name):
self._host_sensors[name] = Sensor.boolean((host+"." + name),
description=host+": "+name,
unit="",
default=0)
self.add_sensor(self._host_sensors[name])
# TODO consider adding power supply sensors: e.g.
# device-status-kronos1-powersupply1
# device-status-kronos1-powersupply2
# device-status-kronos2-powersupply1
# device-status-kronos2-powersupply2
# TODO consider adding raid/disk sensors: e.g.
# device-status-<host>-raid
# device-status-<host>-raid-disk1
# device-status-<host>-raid-disk2
self.script.log(2, "KATCPServer::setup_sensors_host done!")
else:
self.script.log(2, "KATCPServer::setup_sensors_host no sensors found")
else:
self.script.log(-2, "KATCPServer::setup_sensors_host: could not connect to LMC")
def setup_sensors(self):
self.add_sensor(Sensor.boolean('asens'))
def setup_sensors(self):
"""
@brief Set up monitoring sensors.
"""
self._device_status = Sensor.discrete(
"device-status",
description=json.dumps(
dict(description="Health of device server",
valid_states=self.DEVICE_STATUSES)),
params=self.DEVICE_STATUSES,
default="ok",
initial_status=Sensor.NOMINAL)
self.add_sensor(self._device_status)
self._current_time = Sensor.float(
"current-time",
description=json.dumps(dict(description="The current time", )),
default=time.time(),
initial_status=Sensor.NOMINAL)
self.add_sensor(self._current_time)
self._dummy_sensor = Sensor.string(
"dummy-sensor",
description=json.dumps(
dict(description="A dummy sensor with a mutable value",
metadata={
"mysql_task_type": "DROPDOWN",
"options": {
"weee": 0,
"wooo": 1,
"wayhay": 2
},
"label": "Dummy Sensor Value"
},
setter="set-dummy-sensor-value",
timeout=30.0)),
default="",
initial_status=Sensor.NOMINAL)
self.add_sensor(self._dummy_sensor)
self._bool_sensor = Sensor.boolean(
"bool-sensor",
description=json.dumps(
dict(description="A bool sensor with a mutable value",
metadata={"mysql_task_type": "BOOL"},
setter="set-bool-sensor-value",
timeout=30.0)),
default=False,
initial_status=Sensor.NOMINAL)
self.add_sensor(self._bool_sensor)
self._getset_sensor = Sensor.string(
"getset-sensor",
description=json.dumps(
dict(description="A getset sensor with a mutable value",
metadata={"mysql_task_type": "GET_SET"},
setter="set-getset-sensor-value",
timeout=30.0)),
default="A value!",
initial_status=Sensor.NOMINAL)
self.add_sensor(self._getset_sensor)
def setup_sensors(instrument, katcp_server):
"""
Set up compound sensors to be reported to CAM
:param katcp_server: the katcp server with which to register the sensors
:return:
"""
nr_engines = len(instrument.fhosts + instrument.xhosts)
executor = futures.ThreadPoolExecutor(max_workers=nr_engines)
if not instrument._initialised:
raise RuntimeError('Cannot set up sensors until instrument is initialised.')
ioloop = getattr(instrument, 'ioloop', None)
if not ioloop:
ioloop = getattr(katcp_server, 'ioloop', None)
if not ioloop:
raise RuntimeError('IOLoop-containing katcp version required. Can go no further.')
instrument._sensors = {}
# f-engine lru
for _f in instrument.fhosts:
sensor = Sensor.boolean(name='%s_feng_lru' % _f.host,
description='F-engine %s LRU okay' % _f.host,
default=True)
katcp_server.add_sensor(sensor)
instrument._sensors[sensor.name] = sensor
ioloop.add_callback(_sensor_cb_flru, sensor, executor, _f)
# x-engine lru
for _x in instrument.xhosts:
sensor = Sensor.boolean(name='%s_xeng_lru' % _x.host,
description='X-engine %s LRU okay' % _x.host,
default=True)
katcp_server.add_sensor(sensor)
instrument._sensors[sensor.name] = sensor
ioloop.add_callback(_sensor_cb_xlru, sensor, executor, _x)
# f-engine tx counters
for _f in instrument.fhosts:
sensor = Sensor.boolean(name='%s_feng_tx' % _f.host,
description='F-engine TX okay - counters incrementing',
default=True)
katcp_server.add_sensor(sensor)
instrument._sensors[sensor.name] = sensor
ioloop.add_callback(_sensor_feng_tx, sensor, executor, _f)
# f-engine rx counters
for _f in instrument.fhosts:
sensor = Sensor.boolean(name='%s_feng_rx' % _f.host,
description='F-engine RX okay - counters incrementing',
default=True)
katcp_server.add_sensor(sensor)
instrument._sensors[sensor.name] = sensor
ioloop.add_callback(_sensor_feng_rx, sensor, executor, _f)
# x-engine tx counters
for _x in instrument.xhosts:
sensor = Sensor.boolean(name='%s_xeng_tx' % _x.host,
description='X-engine TX okay - counters incrementing',
default=True)
katcp_server.add_sensor(sensor)
instrument._sensors[sensor.name] = sensor
ioloop.add_callback(_sensor_xeng_tx, sensor, executor, _x)
# x-engine rx counters
for _x in instrument.xhosts:
sensor = Sensor.boolean(name='%s_xeng_rx' % _x.host,
description='X-engine RX okay - counters incrementing',
default=True)
katcp_server.add_sensor(sensor)
instrument._sensors[sensor.name] = sensor
ioloop.add_callback(_sensor_xeng_rx, sensor, executor, _x)
# x-engine QDR errors
for _x in instrument.xhosts:
sensor = Sensor.boolean(name='%s_xeng_qdr' % _x.host,
description='X-engine QDR okay',
default=True)
katcp_server.add_sensor(sensor)
instrument._sensors[sensor.name] = sensor
ioloop.add_callback(_xeng_qdr_okay, sensor, executor, _x)
# f-engine QDR errors
for _f in instrument.fhosts:
sensor = Sensor.boolean(name='%s_feng_qdr' % _f.host,
description='F-engine QDR okay',
default=True)
katcp_server.add_sensor(sensor)
instrument._sensors[sensor.name] = sensor
ioloop.add_callback(_feng_qdr_okay, sensor, executor, _f)
# x-engine PHY counters
for _x in instrument.xhosts:
sensor = Sensor.boolean(name='%s_xeng_phy' % _x.host,
description='X-engine PHY okay',
default=True)
katcp_server.add_sensor(sensor)
instrument._sensors[sensor.name] = sensor
ioloop.add_callback(_sensor_xeng_phy, sensor, executor, _x)
# f-engine PHY counters
for _f in instrument.fhosts:
sensor = Sensor.boolean(name='%s_feng_phy' % _f.host,
description='F-engine PHY okay',
default=True)
katcp_server.add_sensor(sensor)
instrument._sensors[sensor.name] = sensor
ioloop.add_callback(_sensor_feng_phy, sensor, executor, _f)
# f-engine PFB counters
for _f in instrument.fhosts:
sensor = Sensor.boolean(name='%s_feng_pfb' % _f.host,
description='F-engine PFB okay',
default=True)
katcp_server.add_sensor(sensor)
instrument._sensors[sensor.name] = sensor
ioloop.add_callback(_feng_pfb_okay, sensor, executor, _f)
# f-engine comms rx
fengops = instrument.fops
sensor = Sensor.boolean(name='fhosts_check_rx',
description='F-hosts rx okay',
default=True)
katcp_server.add_sensor(sensor)
instrument._sensors[sensor.name] = sensor
ioloop.add_callback(_fhost_check_rx, sensor, executor, fengops)
# # f-engine comms tx
sensor = Sensor.boolean(name='fhosts_check_tx',
description='F-hosts tx okay',
default=True)
katcp_server.add_sensor(sensor)
instrument._sensors[sensor.name] = sensor
ioloop.add_callback(_fhost_check_tx, sensor, executor, fengops)
# x-engine comms rx
xengops = instrument.xops
sensor = Sensor.boolean(name='xhosts_check_rx',
description='X-hosts rx okay',
default=True)
katcp_server.add_sensor(sensor)
instrument._sensors[sensor.name] = sensor
ioloop.add_callback(_xhost_check_rx, sensor, executor, xengops)
