powerplug-energenie/powerplug.py

import config
import logging
import mqtt
import report
import socket
import subprocess
import time

try:
    from config import APP_NAME as ROOT_LOGGER_NAME
except ImportError:
    ROOT_LOGGER_NAME = 'root'
logger = logging.getLogger(ROOT_LOGGER_NAME).getChild('main')


class sispmctl(object):
    AMP_CHANNEL = 0

    def __init__(self, mqtt_client):
        logger.info("Starting sispmctl module...")
        self.__mqtt_client__ = mqtt_client
        self.__state_requests__ = [{}, {}, {}, {}]
        self.publish_states()

    def __filter_output_parameter__(self, output):
        try:
            return int(output)
        except ValueError:
            return output

    def set_out_state(self, output, state):
        if output == "all":
            if self.__state__ != [state, state, state, state]:
                self.__set_out_state__(output, state)
        else:
            if self.__state__[int(output) - 1] != state:
                self.__set_out_state__(output, state)            

    def __set_out_state__(self, output, state):
            try:
                out_txt = subprocess.check_output(["sudo", "sispmctl", "-o" if state == True else "-f", output]).decode('UTF-8')
            except subprocess.CalledProcessError as grepexc:                                                                                                   
                logger.error("sispm error code %d", grepexc.returncode)
            else:
                logger.info('sispmctl channel %s changed to %s', output, state)
                self.publish_states()

    def toggle_out_state(self, output):
        if output == "all":
            for i in range(1,5):
                self.toggle_out_state(str(i))
        else:
            self.set_out_state(output, not self.__state__[int(output) - 1])

    def get_out_states(self):
        try:
            out_txt = subprocess.check_output(["sudo", "sispmctl", "-g", "all"])
        except subprocess.CalledProcessError as grepexc:
            logger.error("sispm error code %d", grepexc.returncode)
        else:
            rv = []
            for i in range(1, 5):
                rv.append(out_txt.decode("UTF-8").split("\n")[i].split("\t")[1] == "on")
            return rv

    def publish_states(self):
        self.__state__ = self.get_out_states()
        for i in range(1, 5):
            self.send_state(i)

    def send_state(self, output):
        topic = config.MQTT_TOPIC + "/status/" + str(output)
        logger.info("Sending Powerplug status information of plug %s to mqtt %s = %s", str(output), topic, str(self.__state__[output - 1]))
        try:
            self.__mqtt_client__.send(topic, "true" if self.__state__[output - 1] else "false")
        except (socket.timeout, OSError) as e:
            logger.warning("Erro while sending state information information")


class mqtt_powerplug(mqtt.mqtt_client):
    def __init__(self):
        mqtt.mqtt_client.__init__(self, config.APP_NAME, config.MQTT_SERVER, 1883, config.MQTT_USER, config.MQTT_PASS)
        for target in ["1", "2", "3", "4", "all"]:
            self.add_callback(config.MQTT_TOPIC + "/set/" + target, self.__set__)
            self.add_callback(config.MQTT_TOPIC + "/toggle/" + target, self.__toggle__)
        #
        self.__sc__ = sispmctl(self)

    def __set__(self, client, userdata, message):
        output = message.topic.split("/")[-1]
        if message.topic.find("set") >= 0:
            state = message.payload == b"true"
            logger.info("Received request to set output channel %s to state %s", output, str(state))
            self.__sc__.set_out_state(output, state)

    def __toggle__(self, client, userdata, message):
        output = message.topic.split("/")[-1]
        logger.info("Received request to toggle output channel %s", output)
        if message.payload != b"false":
            self.__sc__.toggle_out_state(output)

    def __del__(self):
        self.__client__.loop_stop()                                              # stop the loop


if __name__ == '__main__': 
    report.appLoggingConfigure(config.__BASEPATH__, config.LOGTARGET, ((config.APP_NAME, config.LOGLVL), ), fmt=config.formatter, host=config.LOGHOST, port=config.LOGPORT)
    #    
    mp = mqtt_powerplug()

    while True:
        time.sleep(30)
        mp.__sc__.publish_states()