def __init__(self, usuarios_por_pagina: int = 10, total_de_usuarios: int = 0): Singleton.__init__(self) self.usuarios_por_pagina = usuarios_por_pagina self.total_de_usuarios = 0 self.paginas = Paginas()
def log(level, message, source): date = str(datetime.datetime.now()) singleton = Singleton() aLog = date + " " + "[" + threading.current_thread( ).name + "] " + level + " " + source + " " + message if (level == "DBG"): if singleton.debug: Functions.logdebug() print(aLog, flush=True) elif (level == "ERR" or level == "WNG" or level == "DEAD"): Functions.logred() print(aLog, end='', flush=True) Functions.lognormal() elif (level == "ASK"): Functions.logyellow() print(aLog, flush=True) else: Functions.lognormal() print(aLog, flush=True) if (level == "DEAD"): sys.exit(1) singleton.logs.append(aLog) f = open("/tmp/pimpMySuperWatt.log", "a+") f.write(aLog + "\r\n") sys.stdout.flush()
def startWeb(): singleton = Singleton() # Ok now check if we webserver is asked if singleton.parameters["webserver"]: Functions.log("DBG", "Webserver is asked, starting it", "CORE") importlib.import_module('web') Functions.log( "DBG", "Trying instanciation of " + str(singleton.parameters["webClass"]), "CORE") mod = importlib.import_module('.' + singleton.parameters["webClass"], package="web") aSiteClass = getattr(mod, singleton.parameters["webClass"]) singleton.instanceWebApp = aSiteClass() else: Functions.log("DBG", "Webserver not asked", "CORE")
def pimpMySuperWatt(): Functions.log("INF", "Instanciate Singleton", "CORE") singleton = Singleton() Functions.log("INF", "Starting PimpMySuperWatts on " + socket.gethostname(), "CORE") Functions.log("INF", "Analysing arguments", "CORE") parser = argparse.ArgumentParser() parser.add_argument( "configFile", help="The absolute path to the configuration file (pimpMySuperWatt.py)" ) parser.add_argument("--debug", help="Debug mode, more verbosity", action="store_true") args = parser.parse_args() checkParameter(args) # Web starting waitServer = threading.Thread(target=startWeb) waitServer.start() # Connector communication starting waitConnector = threading.Thread(target=startConnector) waitConnector.start() waitThread = threading.Thread(target=waitEnd) waitThread.start() startDaemons() startPlugins() waitServer.join()
def pluginRequest(): Functions.log("DBG", "Start plugin request", "CORE") singleton = Singleton() for plugin in singleton.plugins: plugin.runPlugin() influxData = plugin.influxData() sendToInflux(influxData) sendToMqtt(influxData)
def inverterParameters(): singleton = Singleton() return { "qpi": singleton.QPI, "qid": singleton.QID, "qfw": singleton.QVFW, "qfw2": singleton.QVFW2, }
def startConnector(): singleton = Singleton() Functions.log("DBG", "Start connector now", "CORE") # Ok let's start with connector checking importlib.import_module('communication') Functions.log( "DBG", "Trying instanciation of " + str(singleton.parameters["communicationClass"]), "CORE") if not singleton.parameters["communicationClass"] == "": try: Functions.log( "DBG", "Importing module communicationClass " + str(singleton.parameters["communicationClass"]), "CORE") modCom = importlib.import_module( '.' + singleton.parameters["communicationClass"], package="communication") Functions.log( "DBG", "Retrieving class object " + str(singleton.parameters["communicationClass"]), "CORE") aConnectorClass = getattr( modCom, singleton.parameters["communicationClass"]) singleton.connector = aConnectorClass() Functions.log("DBG", "Launching QPI command", "CORE") singleton.QPI = Functions.command("QPI", "") Functions.log("DBG", "Launching QID command", "CORE") singleton.QID = Functions.command("QID", "") Functions.log("DBG", "Launching QVFW command", "CORE") singleton.QVFW = Functions.command("QVFW", "") Functions.log("DBG", "Launching QVFW2 command", "CORE") singleton.QVFW2 = Functions.command("QVFW2", "") except Exception as err: Functions.log("ERR", "Connector exception " + str(err), "CORE") else: Functions.log("DBG", "No serial connector defined.", "CORE")
def __init__(self): self.starttime = datetime.datetime.now() self.endtime = "" self.singleton = Singleton() Functions.log( "DBG", "Instanciation of a Connector Class on " + self.singleton.hostName + " start=" + str(self.starttime), "CORE") self.populateDevices() self.connect()
def startPlugins(): Functions.log("DBG", "Start plugins now", "CORE") singleton = Singleton() try: singleton.internalScheduler.add_job( pluginRequest, 'interval', seconds=singleton.parameters["queryPluginInterval"]) except Exception as err: Functions.log("ERR", "Error with scheduler " + str(err), "CORE")
def checkParameter(args): singleton = Singleton() # If debug if args.debug: Functions.log("INF", "Debug activated", "CORE") singleton.debug = True # Populate version singleton.version = Functions.kommandShell("git log | head -6") # Read configuration file json configFile = os.path.abspath(args.configFile) if not os.path.isfile(configFile): Functions.log("DEAD", "File " + str(configFile) + " doesn't exist", "CORE") Functions.log("INF", "Config file exist " + configFile, "CORE") singleton.configFile = configFile # Setting current hostname & ip singleton.hostName = socket.gethostname() for ifaceName in interfaces(): addrs = ifaddresses(ifaceName) try: for subAdress in addrs[netifaces.AF_INET]: if subAdress["addr"] != "127.0.0.1": Functions.log( "INF", "Local ip detected " + str(subAdress["addr"]), "CORE") singleton.ip = str(subAdress["addr"]) except Exception as err: Functions.log("WNG", "Error while trying to detect local ip " + str(err), "CORE") pass # Parsing the configFile Functions.log("DBG", "Parsing configFile " + configFile, "CORE") try: jsonLine = Functions.loadFileInALine(configFile) singleton.parameters = json.loads(jsonLine) Functions.log( "DBG", "Json config file successfully loaded " + json.dumps(singleton.parameters, indent=4), "CORE") except Exception as err: Functions.log( "DEAD", "Can't parse file " + configFile + " is it a json file ? details " + str(err), "CORE") # Instanciate plugin intanciatePlugins()
def sendToMqtt(json_body): singleton = Singleton() if not singleton.parameters["mqttServers"] == "": Functions.log("DBG", "Sending now to mqtts", "CORE") for mqtt in singleton.parameters["mqttServers"]: Functions.log( "DBG", "Sending now to " + mqtt["mqttServer"] + ":" + str(mqtt["mqttServerPort"]) + " server now", "CORE") publish.single(topic=mqtt["mqttTopic"], payload=json.dumps(json_body), hostname=mqtt["mqttServer"], port=mqtt["mqttServerPort"]) else: Functions.log("DBG", "No mqtt target specified", "CORE")
def startDaemons(): Functions.log("DBG", "Start daemons now", "CORE") singleton = Singleton() try: Functions.log( "DBG", "Add poolingRequest job to scheduler with " + str(singleton.parameters["queryPoolingInterval"]) + " sec(s) interval", "CORE") singleton.internalScheduler.add_job( poolingRequest, 'interval', seconds=singleton.parameters["queryPoolingInterval"]) except Exception as err: Functions.log("ERR", "Error with scheduler " + str(err), "CORE")
def intanciatePlugins(): singleton = Singleton() singleton.plugins = [] for file in sorted(glob.glob('plugins/*/*.py')): moduleName = os.path.basename(file.replace(".py", "")) try: Functions.log("DBG", "Loading plugins/" + moduleName + "/" + moduleName, "CORE") mod = importlib.import_module("plugins." + moduleName + "." + moduleName) Functions.log( "DBG", "End loading plugins/" + moduleName + "/" + moduleName, "CORE") Functions.log("DBG", "Trying dynamic instantiation " + moduleName, "CORE") aClass = getattr(mod, moduleName) instancePlugin = aClass() if isinstance(instancePlugin, abstractPlugin): Functions.log( "DBG", "Plugin " + str(instancePlugin.__class__.__name__.upper()) + " is an instance of AbstractPlugin, populating array", "CORE") singleton.plugins.append(instancePlugin) else: Functions.log( "ERR", "Plugin " + moduleName + " isn't an instance of AbstractPlugin did u extend abstractPlugin ?", "CORE") except Exception as err: Functions.log( "ERR", "Couldn't instantiate " + moduleName + " error " + str(err), "CORE")
def sendToInflux(json_body): singleton = Singleton() if not singleton.parameters["influxDbUrls"] == "": Functions.log("DBG", "Sending now to influxdbs", "CORE") for db in singleton.parameters["influxDbUrls"]: Functions.log("DBG", "Sending now to " + db["dbHost"] + " database now", "CORE") dbUser = db["username"] dbPassword = db["password"] dbHost = db["dbHost"] dbPort = db["dbPort"] dbName = db["dbName"] Functions.log( "DBG", "Sending data to " + dbHost + ":" + dbPort + " user: "******" password: "******" database: " + dbName, "CORE") client = InfluxDBClient(dbHost, dbPort, dbUser, dbPassword, dbName) client.create_database(dbName) client.write_points(json_body) else: Functions.log("DBG", "No influxdb target specified", "CORE")
def __init__(self): self.singleton = Singleton() Functions.log("DBG", "Site instance created starting site...", "site") self.create_app()
def __init__(self): self.error = 0 self.accept = -1 self.singleton = Singleton()
def get_instance(self): rw = Singleton() rw.conn = self.connection_database return rw.conn
def poolingRequest(): Functions.log("DBG", "Start pooling request", "CORE") singleton = Singleton() singleton.QPIGS = Functions.command("QPIGS", "") json_body = [{ "measurement": "pimpMySuperWatt", "tags": { "hostname": singleton.hostName, "version": singleton.version, "qpi": singleton.QPI, "qid": singleton.QID, "qfw": singleton.QVFW, "qfw2": singleton.QVFW2, "url": "http://" + singleton.ip + ":" + str(singleton.parameters["httpPort"]), "instance": singleton.parameters["instance"] }, "fields": singleton.QPIGS }] json_body_parameters = [{ "measurement": "pimpMySuperWatt_Parameters", "tags": { "hostname": singleton.hostName, "version": singleton.version, }, "fields": { "qpi": singleton.QPI, "qid": singleton.QID, "qfw": singleton.QVFW, "qfw2": singleton.QVFW2, "url": "http://" + singleton.ip + ":" + str(singleton.parameters["httpPort"]), "instance": singleton.parameters["instance"], "debug": singleton.parameters["debug"], "communicationClass": singleton.parameters["communicationClass"], "portPath": singleton.parameters["portPath"], "webserver": singleton.parameters["webserver"], "webserverDebug": singleton.parameters["webserverDebug"], "webClass": singleton.parameters["webClass"], "httpBind": singleton.parameters["httpBind"], "queryPoolingInterval": singleton.parameters["queryPoolingInterval"] } }] sendToInflux(json_body) sendToInflux(json_body_parameters) sendToMqtt(json_body) sendToMqtt(json_body_parameters)
if path is not None and cfg is None: self.__path = os.path.abspath(os.path.join(os.curdir, path)) with open(os.path.join(self.__path, "default.yaml"), "rb") as default_config: self.__data.update(load_yaml(default_config)) for cfg in sorted(os.listdir(self.__path)): if cfg != "default.yaml" and cfg[-4:] in ["yaml", "yml"]: with open(os.path.join(self.__path, cfg), "rb") as config_file: self.__data = update_config(self.__data, load_yaml(config_file)) def set_(self, key, value): self.__data[key] = value def values_(self): return self.__data def save_(self, file): file = os.path.abspath(os.path.join(os.curdir, file)) with open(file, 'w') as f: yaml.dump(self.__data, f) def __getattr__(self, item): if type(self.__data[item]) == dict: return Config(cfg=self.__data[item]) return self.__data[item] def __getitem__(self, item): return self.__data[item] config = Singleton(Config)
def inverterQuery(): singleton = Singleton() return singleton.QPIGS
with open(self.file, "a+") as f: f.write(self._to_string(self.messages[-1]) + "\n") def error(self, message): self.log(message, "error") def warning(self, message): self.log(message, "warning") def _to_string(self, msg): message = "" if msg['type'] != '': message += f"*{msg['type']}* " message += f"[{msg['time']}] {msg['stack']} - {msg['message']}" return message def _get_fulltext(self): message = "" for msg in self.messages: message += self._to_string(msg) + "\n" return message def dump(self, file=None): file = self.file if file is None else file file = abspath(file) with open(file, "w") as f: f.write(self._get_fulltext()) logger = Singleton(Logger)
def __init__(self): Singleton.__init__(self)
def __init__(self): self.error=0 self.singleton=Singleton()
import sys from PyQt5 import QtWidgets from PyQt5.QtWidgets import QMessageBox from global_data.system import get_system_running from gui.qds_gui import Ui_qds_gui from utils.singleton import Singleton instance = Singleton() class QdsWindow(QtWidgets.QMainWindow, Ui_qds_gui): def __init__(self): super(QdsWindow, self).__init__() ret = instance.detect_instance() if not ret: QMessageBox.information(self, '提示', '同一目录,只允许一个实例运行') sys.exit(-1) self.setupUi(self) def closeEvent(self, event): # 函数名固定不可变 if get_system_running(): QMessageBox.information(self, '提示', '请先停止软件运行,再关闭') event.ignore() else: instance.delete_lok_file() """ def closeEvent(self, event):#函数名固定不可变