def __init__(self):
self.log = logging.getLogger("fanfare")
self.log.setLevel(logging.INFO)
formatter = logging.Formatter(fmt='[%(name)s] %(message)s')
handler = logging.handlers.SysLogHandler(
facility=logging.handlers.SysLogHandler.LOG_DAEMON,
address="/dev/log")
handler.setFormatter(formatter)
handler.setLevel(logging.INFO)
self.log.addHandler(handler)
self.temp_treshold = 75
self.poll_time = 30
self.fan_control_device = '/proc/acpi/ibm/fan'
if os.getuid() != 0:
self.log.error(
'This program must run as root, as it needs access '
'to the fan control device %s. Exiting...',
self.fan_control_device)
sys.exit(2)
self.target_label = 'Physical id 0'
self.full_speed_on = False
self.log.info("Starting fanfare daemon")
sensors.init()
def _get_detected_chips(): # pragma: no cover
sensors.cleanup()
sensors.init()
chips_detected = list(sensors.iter_detected_chips())
return chips_detected
def enable(self):
try:
sensors.init()
super(Plugin, self).enable()
except Exception:
log.warning("Plex server not available.")
return self.disable()
def get_lmsensor(self):
"""
"""
if self._lmsensor_next_run < datetime.now():
locked = self._lock.acquire(False)
if locked == True:
try:
_lmsensor = {}
pysensors.init(config_filename=self.values["config_filename"].data)
try:
for chip in pysensors.iter_detected_chips():
_lmsensor['%s'%chip] = {}
for feature in chip:
_lmsensor['%s'%chip][feature.label] = feature.get_value()
except Exception:
logger.exception("[%s] - Exception in get_lmsensor", self.__class__.__name__)
finally:
pysensors.cleanup()
for val_id in ['temperature', 'voltage']:
for config in self.values[val_id].get_index_configs():
for chip in _lmsensor:
if config in _lmsensor[chip] :
self.values[val_id].set_data_index(config=config, data=_lmsensor[chip][config])
self._lmsensor_last = True
except Exception:
logger.exception("[%s] - Exception in get_lmsensor", self.__class__.__name__)
self._lmsensor_last = False
finally:
self._lock.release()
min_poll=99999
for val_id in ['temperature_poll', 'voltage_poll']:
if self.values[val_id].data > 0:
min_poll=min(min_poll, self.values[val_id].data)
self._lmsensor_next_run = datetime.now() + timedelta(seconds=min_poll)
def __init__(self):
self.netCounters = psutil.net_io_counters(pernic=True)
sensors.init()
while True:
self.updateInfoPerSecond()
self.updateInfoPerMinute()
self.display()
def __init__(self, serial_instance, eol='crlf'):
self.serial = serial_instance
self.eol = eol
self.alive = None
self._reader_alive = None
self.receiver_thread = None
sensors.init()
def _get_detected_chips(): # pragma: no cover
sensors.cleanup()
sensors.init()
chips_detected = list(sensors.iter_detected_chips())
return chips_detected
def main():
node = Node('temperaturemonitor.py')
parser = argparse.ArgumentParser(
description="Get temperature of CPU cores.")
parser.add_argument(
"--interval",
type=int,
default=2,
help='Sets time interval between each update on CPU temperature')
parser.add_argument("--source",
choices=["pysensors", "sysfs"],
default="sysfs")
args = parser.parse_args()
if args.source == "sysfs":
while True:
with open('/sys/class/thermal/thermal_zone0/temp') as temp_file:
temp = int(temp_file.read().strip()) / 1000.0
node.send(messaging.CPUTemperatureMessage(temp, -1))
time.sleep(args.interval)
else:
import sensors
sensors.init()
while True:
for chip in sensors.iter_detected_chips():
##print '%s at %s:' % (chip, chip.adapter_name)
temperatures = []
for feature in chip:
temperatures.append(feature.get_value())
node.send(
messaging.CPUTemperatureMessage(temperatures[0],
temperatures[1]))
time.sleep(args.interval)
node.stop()
sensors.cleanup()
def __init__(self):
self.netCounters = psutil.net_io_counters(pernic=True)
sensors.init()
while True:
self.updateInfoPerSecond()
self.updateInfoPerMinute()
self.display()
def get_sensors(self):
"""
collects the current temperature of CPU
and each core
"""
sensors.init()
added = []
cpu_temp_c = []
try:
for chip in sensors.iter_detected_chips():
for feature in chip:
if feature.name.startswith('temp'):
if ((feature.label.startswith('Physical')
or feature.label.startswith('CPU'))
and feature.label not in added):
self._status.add_cpu_temp(feature.get_value())
elif (feature.label.startswith('Core')
and feature.label not in added):
cpu_temp_c.append(feature.get_value())
added.append(feature.label)
except sensors.SensorsError:
pass
if cpu_temp_c:
try:
self._status.add_cpu_temp_core(cpu_temp_c)
except IndexError:
pass
sensors.cleanup()
def parse_sensors(cmd):
if cmd[1] == "init":
sensors.init()
elif cmd[1] == "loop":
set_loop_cb("sensors", sensors.loop, int(cmd[2]))
else:
print("[CLI]: \"%s\" not implemented" % (" ".join(cmd)))
def get_sensors(self):
"""
collects the current temperature of CPU
and each core
"""
sensors.init()
added = []
cpu_temp_c = []
try:
for chip in sensors.iter_detected_chips():
for feature in chip:
if feature.name.startswith('temp'):
if ((feature.label.startswith('Physical') or
feature.label.startswith('CPU')) and
feature.label not in added):
self._status.add_cpu_temp(feature.get_value())
elif (feature.label.startswith('Core')
and feature.label not in added):
cpu_temp_c.append(feature.get_value())
added.append(feature.label)
except sensors.SensorsError:
pass
if cpu_temp_c:
try:
self._status.add_cpu_temp_core(cpu_temp_c)
except IndexError:
pass
sensors.cleanup()
def enable(self):
try:
sensors.init()
super(Plugin, self).enable()
except Exception:
log.warning('Plex server not available.')
return self.disable()
def __init__(self):
self.log = logging.getLogger("fanfare")
self.log.setLevel(logging.INFO)
formatter = logging.Formatter(fmt='[%(name)s] %(message)s')
handler = logging.handlers.SysLogHandler(
facility=logging.handlers.SysLogHandler.LOG_DAEMON,
address="/dev/log")
handler.setFormatter(formatter)
handler.setLevel(logging.INFO)
self.log.addHandler(handler)
self.temp_treshold = 75
self.poll_time = 30
self.fan_control_device = '/proc/acpi/ibm/fan'
if os.getuid() != 0:
self.log.error('This program must run as root, as it needs access '
'to the fan control device %s. Exiting...',
self.fan_control_device)
sys.exit(2)
self.target_label = 'Physical id 0'
self.full_speed_on = False
self.log.info("Starting fanfare daemon")
sensors.init()
def check(self, instance):
## Capture CPU temperature stats
dimensions = self._set_dimensions(None, instance)
sensors.init()
stats ={}
try:
for chip in sensors.iter_detected_chips():
# Only temps from ISA adpters that are deteced by lm_sensors
if (chip.adapter_name == "ISA adapter"):
for feature in chip:
if "Core" in feature.label:
name = feature.label.replace(" ", "_")
name = name.lower()
stats["cpu."+str(chip)+"."+str(name)+"_temperature"] = feature.get_value()
elif "Physical id" in feature.label:
name = feature.label.replace(" ", "_")
name = name.lower()
stats["cpu."+str(chip)+".max_temperature"] = feature.get_value()
finally:
sensors.cleanup()
for key, value in stats.iteritems():
# Writes data to monasca that will go to InfluxDB
self.gauge(key, value, dimensions)
log.debug('Collected {0} cpu temp metrics'.format(len(stats))) 1,1 Top
def __init__(self):
"""Initialize"""
print("Initialize")
if os.name == "posix":
sensors.init()
self.ser = serial.Serial()
self.ser.baudrate = 9600
self.ser.port = PORT
try:
self.ser.open()
except:
print("no serial port")
if os.name == "posix":
self.chips = [[0 for feature in chip] for chip in sensors.iter_detected_chips()]
self.cores = psutil.cpu_count()
self.cpuTotal = psutil.cpu_percent()
self.cpu = [0 for cores in range(self.cores)]
self.mem = psutil.virtual_memory()
self.disk = psutil.disk_usage('/')
self.netio = psutil.net_io_counters()
self.netup = 0
self.netdw = 0
self.lastnetup = 0
self.lastnetdw = 0
self.interval = 1
def __init__(self):
print("Getting sensors ready")
sensors.init()
self.data = {}
self.cpus = available_cpu_count()
self.update()
def process_temp():
print("-" * 50)
sensors.init()
critical = False
try:
for chip in sensors.ChipIterator():
for feature in sensors.FeatureIterator(chip):
subs = list(sensors.SubFeatureIterator(chip, feature))
critical = None
current = None
for sub in subs:
value = sensors.get_value(chip, sub.number)
if sub.name.endswith(b"input"):
current = value
if sub.name.endswith(b"crit"):
critical_value = value
name = sensors.get_label(chip, feature)
print("Current temp for {}: {} / {}".format(name, current,
critical_value))
if current >= critical_value:
critical = True
if critical:
play_critical()
finally:
sensors.cleanup()
def getY():
sensors.init() # Inicializamos sensores
temperaturas = [] # Guarda todas las tempereturas
#detectadas
suma_total = 0 # Variable de apoyo
try:
# Recorremos todos los sensores detectados
for chip in sensors.iter_detected_chips():
a = chip
b = chip.adapter_name
if b == "PCI adapter":
print "Procesador >", a,
for core in chip:
print "",core.get_value(), "C"
# Agregamos a la lista
temperaturas.append(core.get_value())
total_tempe = len(temperaturas)
suma_total = sum(suma for suma in temperaturas)
prom = int(suma_total) / total_tempe
finally:
sensors.cleanup() # Cerramos los sensores
print "prom =>", prom
print "--------------------------------------"
if SERIAL: ser.write(str(prom)) # Enviamos el prom al arduino
return prom
def fetch_sensor_data():
try:
sensors.init()
data = {}
for chip in sensors.iter_detected_chips():
for feature in chip:
# log stuff we care about
if feature.label not in IGNORE_READINGS:
data[feature.label] = round(feature.get_value(), 3)
sorted_data = collections.OrderedDict(sorted(data.items()))
write_data_file(sorted_data)
if USE_REDIS:
import redis
REDIS_CONNECTION = redis.StrictRedis(host='localhost', port=6379, db=0)
write_data_redis(sorted_data)
if USE_INFLUX:
from influxdb import InfluxDBClient
INFLUX_CLIENT = InfluxDBClient('localhost', 8086, 'root', 'root', 'jarvis')
write_data_influx(sorted_data, INFLUX_CLIENT)
for name, reading in sorted_data.iteritems():
print "{0}: {1}".format(name, reading)
except Exception as exception:
print_exc()
print "Failed to get sensor data: {0}".format(exception.message)
def metric_init(params):
global descriptors
sensors.init()
corelist = []
try:
for chip in sensors.iter_detected_chips():
if chip.prefix == CORETEMP:
for feature in chip:
if feature.label.startswith('Core'):
corelist.append("%s Temperature" % feature.label)
except:
raise
finally:
sensors.cleanup()
for core in corelist:
print 'name: %s' % core
descriptors.append({'name': core,
'call_back': temp_handler,
'time_max': 90,
'value_type': 'float',
'units': 'Celsius',
'slope': 'both',
'format': '%.2f',
'description': 'Temperature of %s' % core,
'groups': 'Node Health'})
return descriptors
def __init__(self,inits=('$','%'),aliases=None,order=None):
self.inits = inits
sensors.init()
self.readings = {}
self.prev_readings = {}
if aliases is not None:
self.aliases = aliases
self.update()
def __init__(self, inits=('$', '%'), aliases=None, order=None):
self.inits = inits
sensors.init()
self.readings = {}
self.prev_readings = {}
if aliases is not None:
self.aliases = aliases
self.update()
def serve(port):
sensors.init()
server = Server("localhost", port)
try:
server.serve_forever()
except KeyboardInterrupt:
server.server_close()
finally:
sensors.cleanup()
def check(self, instance):
sensors.init()
try:
for chip in sensors.iter_detected_chips():
for feature in chip:
self.gauge("sensors." + feature.label,
feature.get_value(),
device_name=('%s' % (chip)))
finally:
sensors.cleanup()
def getDictTemp():
result = dict()
sensors.init()
try:
for chip in sensors.iter_detected_chips():
for feature in chip:
result[str(feature.label)] = str(feature.get_value())
finally:
sensors.cleanup()
return result
def init():
print("[RUNNER]: init")
buttons.init()
buttons.action()
leds.init()
phy_interface.init()
sensors.init()
power_counter.init()
mqtt.init()
cli.init()
things.init()
def __init__(self):
"""
Init sensors stats
"""
try:
sensors.init()
except:
self.initok = False
else:
self.initok = True
def __init__(self):
"""
Init sensors stats
"""
try:
sensors.init()
except:
self.initok = False
else:
self.initok = True
def __init__(self):
"""Init sensors stats."""
try:
sensors.init()
except Exception:
self.initok = False
else:
self.initok = True
# Init the stats
self.reset()
def __init__(self, influxdb_client, exit_flag_event):
"""
Initialize PySensors(lm-sensors)
"""
super(LmSensorsMetrics,
self).__init__(influxdb_client=influxdb_client,
watchdog=LmSensorsWatchdog(exit_flag_event),
exit_flag_event=exit_flag_event)
LOG.info('Initializing Lm-sensors...')
sensors.init()
def _get_temp(self):
import sensors
sensors.init()
for chip in sensors.iter_detected_chips():
if not 'temp' in str(chip):
continue
tot = 0
for i, feature in enumerate(chip):
tot += feature.get_value()
return float(tot) / (i + 1)
return None
def main():
try:
sensors.init()
log_thread = threading.Thread(target=lambda: run_log(60.0))
log_thread.daemon = True
log_thread.start()
http_viewer.run()
finally:
sensors.cleanup()
def temp_handler(name):
sensors.init()
temp = 0.0
try:
for chip in sensors.iter_detected_chips():
if chip.prefix == CORETEMP:
for feature in chip:
if '%s Temperature' % feature.label == name:
temp = feature.get_value()
finally:
sensors.cleanup()
return temp
def collect(self):
if sensors is None:
self.log.error('Unable to import module sensors')
return {}
sensors.init()
try:
for chip in sensors.iter_detected_chips():
for feature in chip:
self.publish(".".join([str(chip), feature.label]), feature.get_value())
finally:
sensors.cleanup()
def get_temp():
sensors.init()
temp = 0
try:
for chip in sensors.iter_detected_chips():
for feature in chip:
sensor_temp = feature.get_value()
if sensor_temp > temp:
temp = sensor_temp
finally:
sensors.cleanup()
return temp
def getTemp(name):
result = dict()
sensors.init()
try:
for chip in sensors.iter_detected_chips():
for feature in chip:
try:
if feature.label == name:
return feature.get_value()
except:
pass
finally:
sensors.cleanup()
def __enter__(self):
super().__enter__()
if not self._initAttempted:
self._initAttempted = True
try:
sensors.init()
self._initSuccess = True
except:
self._initSuccess = False
if self._initSuccess:
self._initCount += 1
return self
def collect(self):
if sensors is None:
self.log.error('Unable to import module sensors')
return {}
sensors.init()
try:
for chip in sensors.iter_detected_chips():
for feature in chip:
self.publish(".".join([str(chip), feature.label]),
feature.get_value())
finally:
sensors.cleanup()
def pysensors():
"""use python sensors package to collect sensor data"""
#print(f"Using sensors library {sensors.VERSION} ({sensors.LIB_FILENAME})")
#print()
html = '<pre>'
#print(dir(sensors))
sensors.init()
try:
#print(config)
for chip in sensors.iter_detected_chips():
if str(chip) in pysensorconfig:
#print(chip)
html += str(chip) + '<br>'
#print('Adapter:', chip.adapter_name)
#print(repr(config[str(chip)]))
for feature in chip:
#print(config[chip])
if feature.name in pysensorconfig[str(chip)]:
if 'label' in pysensorconfig[str(chip)]:
label = pysensorconfig[str(chip)]['label']
else:
label = feature.label
#print(feature.name)
if feature.name.startswith('fan'):
#print("%-25s %4d RPM" % (label+':', feature.get_value()))
html += "%-25s %4d RPM " % (label + ':',
feature.get_value())
html += "<meter max=2000 min=0 value=%d high=1250 low=750 optimum=100></meter> <br>" % feature.get_value(
)
if feature.name.startswith('temp'):
#print("%-27s %4.1f C" % (label+':', feature.get_value()))
html += "%-27s %4.1f°C " % (
label + ':', feature.get_value())
html += "<meter max=110.0 min=0.0 value=%f high=70.0 low=40.0 optimum=10.0></meter> </br>" % feature.get_value(
)
#f"{label!r}:"
#f" {feature.get_value():.1f}"
#)
for subfeature in feature:
if str(subfeature.name) in pysensorconfig[str(
chip)][feature.name]:
#print(f" {subfeature.name}: {subfeature.get_value():.1f}")
#print(" (%s: %4.1f C)" % (subfeature.name, subfeature.get_value()))
html += " (%s: %4.1f°C) <br>" % (
subfeature.name, subfeature.get_value())
#print()
html += '<br>'
finally:
sensors.cleanup()
return html
def main():
sensors.init()
try:
for chip in sensors.iter_detected_chips():
print(chip)
print('Adapter:', chip.adapter_name)
for feature in chip:
print('%s (%r): %.1f' %
(feature.name, feature.label, feature.get_value()))
for subfeature in feature:
print(' %s: %.1f' %
(subfeature.name, subfeature.get_value()))
print()
finally:
sensors.cleanup()
def create_models():
sensors.init()
S = sqla.session()
try:
for chip_struct in sensors.iter_detected_chips():
chip = sqla.create(S, models.Chip, ['addr', 'bus', 'path', 'prefix'], chip_struct)
S.add(chip)
S.flush()
for sensor_struct in chip_struct:
sensor = sqla.create(S, models.Sensor, ['chip', 'label'], sensor_struct)
sensor.chip_id = chip.id
S.add(sensor)
S.flush()
S.commit()
finally:
sensors.cleanup()
def main():
print(f"Using sensors library {sensors.VERSION} ({sensors.LIB_FILENAME})")
print()
sensors.init()
try:
for chip in sensors.iter_detected_chips():
print(chip)
print('Adapter:', chip.adapter_name)
for feature in chip:
print(f"{feature.name} ({feature.label!r}):"
f" {feature.get_value():.1f}")
for subfeature in feature:
print(f" {subfeature.name}: {subfeature.get_value():.1f}")
print()
finally:
sensors.cleanup()
def coretemp_handler(name):
sensors.init()
value = 0
try:
for chip in sensors.iter_detected_chips():
if chip.prefix.startswith('coretemp'):
for feature in chip:
if feature.label == name:
value = feature.get_value()
break
except:
print "WTF?!?"
finally:
sensors.cleanup()
return value
def __set_chip_read(self):
"""
Queries the chip applies result
to the 'read' dict. Then, collects the
recommended threshold values
"""
r.init()
try:
for x in r.iter_detected_chips(CHIP):
for f in x:
if "Core" in f.label:
self.read[f.label] = f.get_value()
for sub in f:
self.__collect_recommended(sub)
finally:
r.cleanup()
def __init__(self):
rospy.init_node('sysinfo')
pub = rospy.Publisher('sysinfo', SysInfo, queue_size=1)
pub_diagnostics = rospy.Publisher('/diagnostics', DiagnosticArray, queue_size=1)
rospy.Subscriber('roboclaw_state', RoboClawState, self.cb_bat_volt)
self._wifi_name = 'wlan0'
if rospy.has_param('~wifi_name'):
self._wifi_name = rospy.get_param('~wifi_name')
self._eth_name = 'eth0'
if rospy.has_param('~eth_name'):
self._eth_name = rospy.get_param('~eth_name')
self._base_bat_voltage = -1
self._last_bat_base = rospy.Time.now()
self._stat_bat_base = []
self._stat_bat_pc = []
self._stat_network = []
self._stat_system = []
info_msg = SysInfo()
info_msg.hostname = socket.gethostname()
sensors.init()
diag_msg = DiagnosticArray()
r = rospy.Rate(1)
while not rospy.is_shutdown():
info_msg.header.stamp = rospy.Time.now()
info_msg.system = self.system_status()
info_msg.network = self.network_status()
info_msg.battery_base = self.battery_base_status()
info_msg.battery_pc = self.battery_pc_status()
pub.publish(info_msg)
diag_msg.header.stamp = rospy.Time.now()
diag_msg.status.append(self.stat_bat_base)
diag_msg.status.append(self.stat_bat_pc)
diag_msg.status.append(self.stat_network)
diag_msg.status.append(self.stat_system)
pub_diagnostics.publish(diag_msg)
r.sleep()
def main():
sensors.init()
try:
for chip in sensors.iter_detected_chips():
print(chip)
print('Adapter:', chip.adapter_name)
for feature in chip:
print('%s (%r): %.1f' % (
feature.name, feature.label, feature.get_value()
))
for subfeature in feature:
print(' %s: %.1f' % (
subfeature.name, subfeature.get_value()
))
print()
finally:
sensors.cleanup()
def __init__(self):
if not 'FONT' in globals():
raise Exception('Config not loaded, missing \'from config import *\'?')
sensors.init()
for chip in sensors.iter_detected_chips():
for feature in chip:
self.cpusensor = feature
break
self.lastsent = 0
self.lastrecv = 0
self.lasttimestamp = None
self.blink_batt = True
self.refresh_batt_left_in = 0
self.time_batt_remaining = 0
self.re_cpufreq = re.compile('^cpu .*(?P<tst> \d+\.\d*)$', re.M|re.I)
def __init__(self, serial_instance, echo=False, eol='crlf', filters=()):
self.console = Console()
self.serial = serial_instance
self.echo = echo
self.raw = False
self.input_encoding = 'UTF-8'
self.output_encoding = 'UTF-8'
self.eol = eol
self.filters = filters
self.update_transformations()
self.exit_character = unichr(0x1d) # GS/CTRL+]
self.menu_character = unichr(0x14) # Menu: CTRL+T
self.alive = None
self._reader_alive = None
self.receiver_thread = None
self.rx_decoder = None
self.tx_decoder = None
sensors.init()
def load_sensors(self):
# build a temp hashmap to collect sensors id & address
sensors.init()
for chip in sensors.iter_detected_chips():
for feature in chip:
if feature.label in self.cfg['sensors'].keys():
dev = xaal.lib.Device("thermometer.basic")
dev.address = self.cfg['sensors'][feature.label]['addr']
dev.vendor_id = "IHSEV"
dev.product_id = "LM_SENSOR"
dev.url = "https://wiki.archlinux.org/index.php/Lm_sensors"
dev.info = "%s/%s/%s" % (platform.node(),chip.adapter_name,feature.label)
dev.version = 0.2
temp = dev.new_attribute("temperature")
name = "%s:%s" % (chip,feature.label)
self.data.update({name:temp})
self.engine.add_device(dev)
dev.dump()
def getTemp():
sensors.init()
avg = 0
try:
for chip in sensors.iter_detected_chips():
print HEADER + '%s at %s' % (chip, chip.adapter_name) + ENDC
for feature in chip:
_system = feature.label
_system_temp = feature.get_value()
print BLUE + '\tSystem: %s ' % (_system) + ENDC
print WARNING + '\tTemp: %.2f°C ' % (_system_temp) + ENDC
if _system_temp > 60:
print FAIL + '\tSystem Overheating' + ENDC
else:
print GREEN + BOLD + '\tSystem OK' + ENDC
print '\n'
finally:
sensors.cleanup()
def init():
syscmd("jack_control start")
# GPIO setup
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
sensors.init()
devices.init()
#controls init must be after devices and sensors, because it using them
controls.init()
controls.set_telegram_warning_handle(send_warning_telegram)
sound.init() # must be after controls
# arguments
parser = argparse.ArgumentParser()
parser.add_argument("--time")
parser.add_argument("--check_water_level", action='store_true')
args = parser.parse_args()
if args.time:
config.DEF_TIME_WATER_S = int(args.time)
#just check water level
if args.check_water_level:
my_logging.logger.info(
"water level: " + ("ok" if check_water_level() else "low"))
exit()
my_logging.logger.info("this is "+socket.gethostname()+" and we will run server and telegram bot")
web_server.run(__name__)
start_bot()
status=devices.get_status_str()+sensors.get_status_str()+controls.get_status_str()
my_logging.logger.info(status)
TTS.init() # this must be before STT
# sopare_plugin.init()
STT.init() # this must be at the end
watch_thread.init()
my_logging.logger.info("end init")
def __init__(self):
if not 'FONT' in globals():
raise Exception(
'Config not loaded, missing \'from config import *\'?')
sensors.init()
for chip in sensors.iter_detected_chips():
for feature in chip:
self.cpusensor = feature
break
self.lastsent = 0
self.lastrecv = 0
self.lasttimestamp = None
self.blink_batt = True
self.refresh_batt_left_in = 0
self.time_batt_remaining = 0
self.re_cpufreq = re.compile('^cpu .*(?P<tst> \d+\.\d*)$', re.M | re.I)
def init_sensors():
try:
import sensors
except (ImportError, ValueError):
return lambda: {}
def collect_sensor_data():
data = {}
for chip in sensors.iter_detected_chips():
for feature in chip:
try:
data[f'{chip}.{feature.label}'] = feature.get_value()
except: # noqa: E722
pass
return data
sensors.init()
return collect_sensor_data
def collect(self):
if sensors is None:
self.log.error('Unable to import module sensors')
return {}
sensors.init()
try:
for chip in sensors.iter_detected_chips():
for feature in chip:
label = feature.label.replace(' ', '-')
value = None
try:
value = feature.get_value()
except Exception:
if str_to_bool(self.config['send_zero']):
value = 0
if value is not None:
self.publish(".".join([str(chip), label]), value)
finally:
sensors.cleanup()
def metric_init(params):
global descriptors
metric_group = params.get('metric_group', 'coretemp')
sensors.init()
for chip in sensors.iter_detected_chips():
for feature in chip:
if chip.prefix.startswith('coretemp'):
descriptors.append({
'name': feature.label,
'call_back' : coretemp_handler,
'time_max' : 60,
'units': 'C',
'format' : '%.2f',
'slope' : 'both',
'description' : 'CPU Core Temperature',
'groups' : metric_group,
})
sensors.cleanup()
return descriptors
def collectTemperatureMetrics(self):
gmetric_obj = gmetric.Gmetric(self.gconf.host, self.gconf.port, self.gconf.protocol)
while not self._stopevent.isSet():
try:
sensors.init()
list_metrics = {}
for chip in sensors.iter_detected_chips():
for feature in chip:
fname = str(chip) + "-" + feature.label
feature_id = fname.replace(" ", "_")
# print '%s: %.2f' % (feature_id, feature.get_value())
list_metrics[feature_id] = feature.get_value()
# send metrics
# IPMI TOOL FOR mb TEMPERATURE
# get system wide counters metrics
p = subprocess.Popen(
"sudo ipmitool sdr | grep \"MB Temperature\" | awk '{print $4}'",
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
try:
ipmi_value = float(p.stdout.readline().strip())
list_metrics["MB_Temperature"] = ipmi_value
except ValueError:
pass
self.sendTemperatureMetrics(list_metrics, gmetric_obj)
# print list_metrics
finally:
sensors.cleanup()
sleep(self.temperature_interval)
logger.info("Terminating %s", threading.currentThread().name)
