genalexa.py

#!/usr/bin/env python

#!/usr/bin/env python
#-------------------------------------------------------------------------------
#    FILE: gengpioin.py
# PURPOSE: genmon.py support program to allow amazon alexa voice commands
#
#  AUTHOR: Jason G Yates
#    DATE: 27-Jul-2019
#
# MODIFICATIONS:
#-------------------------------------------------------------------------------
#
##############################################################################################
#### BASED ON WORK BY : https://github.com/nassir-malik/IOT-Pi3-Alexa-Automation          ####
##############################################################################################
#### To set up the Alexa Inegration, go to your Echo speaker and ask Alexa
#### to discover your device.  Say, "Discover my devices," or select Add
#### Device in the Devices section of the Alexa app.
####
#### Once Alexa has discovered your generator, you can use the Alexa app to
#### complete the setup.
####
#### To turn on your generator via the Echo speaker, say "Alexa, turn on
#### the generator".  And to off the generator again, "Alexa, turn off
#### the generator".
####
#### If you prefer to state the likes of "Alexa, start my generator"
#### or "Alexa, stop my generator" (rather than using the words ON or
#### OFF), you can set up a Routine with Alexa.


import email.utils, requests, select, socket, struct, sys, datetime, time, urllib, uuid, signal, os, threading
import atexit, getopt, json
import fcntl, re, time, locale, socket, subprocess, traceback
try:
    from genmonlib.mylog import SetupLogger
    from genmonlib.myconfig import MyConfig
    from genmonlib.myclient import ClientInterface
    from genmonlib.mysupport import MySupport
    from genmonlib.mycommon import MyCommon
    from genmonlib.program_defaults import ProgramDefaults
except Exception as e1:
    print("\n\nThis program requires the modules located in the genmonlib directory in the github repository.\n")
    print("Please see the project documentation at https://github.com/jgyates/genmon.\n")
    print("Error: " + str(e1))
    sys.exit(2)



# This XML is the minimum needed to define one of our virtual switches
# to the Amazon Echo

SETUP_XML ="""<?xml version=1.0?>
            <root>
             <device>
                <deviceType>urn:Belkin:device:controllee:1</deviceType>
                <friendlyName>%(device_name)s</friendlyName>
                <manufacturer>Belkin International Inc.</manufacturer>
                <modelName>Socket</modelName>
                <modelNumber>3.1415</modelNumber>
                <modelDescription>Belkin Plugin Socket 1.0</modelDescription>\r\n
                <UDN>uuid:Socket-1_0-%(device_serial)s</UDN>
                <serialNumber>221517K0101767</serialNumber>
                <binaryState>0</binaryState>
                <serviceList>
                  <service>
                      <serviceType>urn:Belkin:service:basicevent:1</serviceType>
                      <serviceId>urn:Belkin:serviceId:basicevent1</serviceId>
                      <controlURL>/upnp/control/basicevent1</controlURL>
                      <eventSubURL>/upnp/event/basicevent1</eventSubURL>
                      <SCPDURL>/eventservice.xml</SCPDURL>
                  </service>
              </serviceList>
              </device>
            </root>"""

# A simple utility class to wait for incoming data to be
# ready on a socket.
#----------  poller class ------------------------------------------------------
class poller(MyCommon):
    # ---------------- poller.init ---------------------------------------------
    def __init__(self, log = None, debug = False):
        super(poller, self).__init__()
        self.log = log
        self.debug = debug
        try:
            self.poller = select.poll()
            self.targets = {}
        except Exception as e1:
            self.LogErrorLine("Error in poller init: " + str(e1))
            sys.exit(1)

    # ---------------- poller.add ----------------------------------------------
    def add(self, target, fileno = None):
        if not fileno:
            fileno = target.fileno()
        self.poller.register(fileno, select.POLLIN)
        self.targets[fileno] = target

    # ---------------- poller.remove -------------------------------------------
    def remove(self, target, fileno = None):
        if not fileno:
            fileno = target.fileno()
        self.poller.unregister(fileno)
        del(self.targets[fileno])

    # ---------------- poller.poll ---------------------------------------------
    def poll(self, timeout = 0):
        ready = self.poller.poll(timeout)
        num = len(ready)
        for one_ready in ready:
            target = self.targets.get(one_ready[0], None)
            if target:
                target.do_read(one_ready[0])
        return num


# Base class for a generic UPnP device. This is far from complete
# but it supports either specified or automatic IP address and port
# selection.
#----------  upnp_device class -------------------------------------------------
class upnp_device(MyCommon):
    this_host_ip = None

    # ---------------- upnp_device.local_ip_address ----------------------------
    @staticmethod
    def local_ip_address():
        if not upnp_device.this_host_ip:
            temp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            try:
                temp_socket.connect(('8.8.8.8', 53))
                upnp_device.this_host_ip = temp_socket.getsockname()[0]
            except:
                upnp_device.this_host_ip = '127.0.0.1'
            del(temp_socket)
        return upnp_device.this_host_ip


    # ---------------- upnp_device.init ----------------------------------------
    def __init__(self, listener, poller, port, root_url, server_version, persistent_uuid, other_headers = None, ip_address = None, log = None, debug = False):
        super(upnp_device, self).__init__()
        self.log = log
        self.debug = debug
        try:
            self.listener = listener
            self.poller = poller
            self.port = port
            self.root_url = root_url
            self.server_version = server_version
            self.persistent_uuid = persistent_uuid
            self.uuid = uuid.uuid4()
            self.other_headers = other_headers

            if ip_address:
                self.ip_address = ip_address
            else:
                self.ip_address = upnp_device.local_ip_address()

            if self.ip_address == None:
                self.LogErrorLine("Error : unable to get IP address in upnp_device init")
                sys.exit(1)

            self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            self.socket.bind((self.ip_address, self.port))
            self.socket.listen(5)
            if self.port == 0:
                self.port = self.socket.getsockname()[1]
            self.poller.add(self)
            self.client_sockets = {}
            self.listener.add_device(self)
        except Exception as e1:
            self.LogErrorLine("Error in upnp_device init: " + str(e1))
            sys.exit(1)
    # ---------------- upnp_device.fileno --------------------------------------
    def fileno(self):
        return self.socket.fileno()

    # ---------------- upnp_device.do_read -------------------------------------
    def do_read(self, fileno):
        if fileno == self.socket.fileno():
            (client_socket, client_address) = self.socket.accept()
            self.poller.add(self, client_socket.fileno())
            self.client_sockets[client_socket.fileno()] = (client_socket, client_address)
        else:
            data, sender = self.client_sockets[fileno][0].recvfrom(4096)
            if not data:
                self.poller.remove(self, fileno)
                del(self.client_sockets[fileno])
            else:
                self.handle_request(data, sender, self.client_sockets[fileno][0], self.client_sockets[fileno][1])

    # ---------------- upnp_device.handle_request ------------------------------
    def handle_request(self, data, sender, socket, client_address):
        pass

    # ---------------- upnp_device.get_name ------------------------------------
    def get_name(self):
        return "unknown"

    # ---------------- upnp_device.respond_to_search ---------------------------
    def respond_to_search(self, destination, search_target):
        self.LogDebug("Responding to search for %s" % self.get_name())
        date_str = email.utils.formatdate(timeval=None, localtime=False, usegmt=True)
        location_url = self.root_url % {'ip_address' : self.ip_address, 'port' : self.port}
        message = ("HTTP/1.1 200 OK\r\n"
                  "CACHE-CONTROL: max-age=86400\r\n"
                  "DATE: %s\r\n"
                  "EXT:\r\n"
                  "LOCATION: %s\r\n"
                  "OPT: \"http://schemas.upnp.org/upnp/1/0/\"; ns=01\r\n"
                  "01-NLS: %s\r\n"
                  "SERVER: %s\r\n"
                  "ST: %s\r\n"
                  "USN: uuid:%s::%s\r\n" % (date_str, location_url, self.uuid, self.server_version, search_target, self.persistent_uuid, search_target))
        if self.other_headers:
            for header in self.other_headers:
                message += "%s\r\n" % header
        message += "\r\n"
        self.LogDebug(message)
        temp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        temp_socket.sendto(message.encode("UTF-8"), destination)

# This subclass does the bulk of the work to mimic a WeMo switch on the network.
#----------  fauxmo class ------------------------------------------------------
class fauxmo(upnp_device):
    # ---------------- fauxmo.make_uuid ----------------------------------------
    @staticmethod
    def make_uuid(name):
        return ''.join(["%x" % sum([ord(c) for c in name])] + ["%x" % ord(c) for c in "%sfauxmo!" % name])[:14]

    # ---------------- fauxmo.__init__ -----------------------------------------
    def __init__(self, name, listener, poller, ip_address, port, action_handler = None, log = None,  debug  = False):
        self.log = log
        self.debug = debug
        try:
            self.serial = self.make_uuid(name)
            self.name = name
            self.ip_address = ip_address
            self.generatorStatus = 0
            persistent_uuid = "Socket-1_0-" + self.serial
            other_headers = ['X-User-Agent: redsonic']
            super(fauxmo, self).__init__(listener, poller, port, "http://%(ip_address)s:%(port)s/setup.xml", "Unspecified, UPnP/1.0, Unspecified", persistent_uuid, other_headers=other_headers, ip_address=ip_address, log = log, debug = debug)
            if action_handler:
                self.action_handler = action_handler
            else:
                self.action_handler = self

            self.LogDebug("FauxMo device '%s' ready on %s:%s" % (self.name, self.ip_address, self.port))
        except Exception as e1:
            self.LogErrorLine("Error in fauxmo init: " + str(e1))
            sys.exit(1)

    # ---------------- fauxmo.get_name -----------------------------------------
    def get_name(self):
        return self.name

    # ---------------- fauxmo.handle_request -----------------------------------
    def handle_request(self, data, sender, socket, client_address):
        data = data.decode('utf-8')
        success = False

        if data.find('GET /setup.xml HTTP/1.1') == 0:

            self.LogDebug("Responding to setup.xml for %s" % self.name)
            xml = SETUP_XML % {'device_name' : self.name, 'device_serial' : self.serial}
            date_str = email.utils.formatdate(timeval=None, localtime=False, usegmt=True)
            message = ("HTTP/1.1 200 OK\r\n"
                       "CONTENT-LENGTH: %d\r\n"
                       "CONTENT-TYPE: text/xml\r\n"
                       "DATE: %s\r\n"
                       "LAST-MODIFIED: Sat, 01 Jan 2000 00:01:15 GMT\r\n"
                       "SERVER: Unspecified, UPnP/1.0, Unspecified\r\n"
                       "X-User-Agent: redsonic\r\n"
                       "CONNECTION: close\r\n"
                       "\r\n"
                       "%s" % (len(xml), date_str, xml))
            self.LogDebug(message)
            socket.send(message.encode("UTF-8"))
        elif data.find('SOAPACTION: "urn:Belkin:service:basicevent:1#SetBinaryState"') != -1:
            success = False
            if data.find('SetBinaryState') != -1:
                if data.find('<BinaryState>1</BinaryState>') != -1:
                    # on
                    self.LogDebug("Responding to ON for %s" % self.name)
                    success = self.action_handler.on()
                    if success:
                        self.generatorStatus = 1
                elif data.find('<BinaryState>0</BinaryState>') != -1:
                    # off
                    self.LogDebug("Responding to OFF for %s" % self.name)
                    success = self.action_handler.off()
                    if success:
                        self.generatorStatus = 0
                else:
                    self.LogError("Unknown Binary State request:")
                    self.LogError(data)

            if success:
                # The echo is happy with the 200 status code and doesn't
                # appear to care about the SOAP response body
                self.LogDebug("Successfully Completed Action")
                soap = ""
                date_str = email.utils.formatdate(timeval=None, localtime=False, usegmt=True)
                message = ("HTTP/1.1 200 OK\r\n"
                           "CONTENT-LENGTH: %d\r\n"
                           "CONTENT-TYPE: text/xml charset=\"utf-8\"\r\n"
                           "DATE: %s\r\n"
                           "EXT:\r\n"
                           "SERVER: Unspecified, UPnP/1.0, Unspecified\r\n"
                           "X-User-Agent: redsonic\r\n"
                           "CONNECTION: close\r\n"
                           "\r\n"
                           "%s" % (len(soap), date_str, soap))
                socket.send(message.encode("UTF-8"))
        elif data.find('GetBinaryState'):
            self.generatorStatus = self.action_handler.status(self.generatorStatus)
            self.LogDebug("Responding to provide current state: " + str(self.generatorStatus))
            soap = """<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
                <s:Body>
                    <u:GetBinaryStateResponse
                    xmlns:u="urn:Belkin:service:basicevent:1">
                    <BinaryState>"""+ str(self.generatorStatus) +"""</BinaryState>
                    </u:GetBinaryStateResponse>
                </s:Body></s:Envelope>"""
            date_str = email.utils.formatdate(timeval=None, localtime=False, usegmt=True)
            message = ("HTTP/1.1 200 OK\r\n"
                       "CONTENT-LENGTH: %d\r\n"
                       "CONTENT-TYPE: text/xml charset=\"utf-8\"\r\n"
                       "DATE: %s\r\n"
                       "EXT:\r\n"
                       "SERVER: Unspecified, UPnP/1.0, Unspecified\r\n"
                       "X-User-Agent: redsonic\r\n"
                       "CONNECTION: close\r\n"
                       "\r\n"
                       "%s" % (len(soap), date_str, soap))
            socket.send(message.encode("UTF-8"))
            self.LogDebug("SEND RESPONSE: "+str(message.replace('\n','\\n').replace('\r','\\r')))

        else:
            self.LogError("Unknown data:")
            self.LogError(str(data))
    # ---------------- fauxmo.on -----------------------------------------------
    def on(self):
        return False

    # ---------------- fauxmo.off ----------------------------------------------
    def off(self):
        return True


# Since we have a single process managing several virtual UPnP devices,
# we only need a single listener for UPnP broadcasts. When a matching
# search is received, it causes each device instance to respond.
#
# Note that this is currently hard-coded to recognize only the search
# from the Amazon Echo for WeMo devices. In particular, it does not
# support the more common root device general search. The Echo
# doesn't search for root devices.
#----------  upnp_broadcast_responder class ------------------------------------
class upnp_broadcast_responder(MyCommon):
    TIMEOUT = 0

    # ---------------- upnp_broadcast_responder.init ---------------------------
    def __init__(self, log = None, debug = False):
        super(upnp_broadcast_responder, self).__init__()
        self.log = log
        self.debug = debug
        self.devices = []

    # ---------------- upnp_broadcast_responder.init_socket --------------------
    def init_socket(self):
        ok = True
        self.ip = '239.255.255.250'
        self.port = 1900
        try:
            #This is needed to join a multicast group
            self.mreq = struct.pack("4sl",socket.inet_aton(self.ip),socket.INADDR_ANY)

            #Set up server socket
            self.ssock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,socket.IPPROTO_UDP)
            self.ssock.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

            try:
                self.ssock.bind(('',self.port))
            except Exception as e:
                self.LogError("WARNING: Failed to bind %s:%d: %s" , (self.ip,self.port,e))
                ok = False

            try:
                self.ssock.setsockopt(socket.IPPROTO_IP,socket.IP_ADD_MEMBERSHIP,self.mreq)
            except Exception as e:
                self.LogError('WARNING: Failed to join multicast group:'+str(e))
                ok = False

        except Exception as e:
            self.LogError("Failed to initialize UPnP sockets:"+str(e))
            return False
        if ok:
            self.LogDebug("Listening for UPnP broadcasts")

    # ---------------- upnp_broadcast_responder.fileno -------------------------
    def fileno(self):
        return self.ssock.fileno()
    # ---------------- upnp_broadcast_responder.do_read ------------------------
    def do_read(self, fileno):
        data, sender = self.recvfrom(1024)
        data = data.decode('utf-8')
        if data:
            if data.find('M-SEARCH') >= 0 and data.find('urn:Belkin:device:**') >0 or data.find('n:Belkin:device:**') >0 or data.find('upnp:rootdevice') >0:
                for device in self.devices:
                    time.sleep(0.5)
                    device.respond_to_search(sender, 'urn:Belkin:device:**')
            else:
                pass
    # ---------------- upnp_broadcast_responder.recvfrom -----------------------
    #Receive network data
    def recvfrom(self,size):
        if self.TIMEOUT:
            self.ssock.setblocking(0)
            ready = select.select([self.ssock], [], [], self.TIMEOUT)[0]
        else:
            self.ssock.setblocking(1)
            ready = True

        try:
            if ready:
                return self.ssock.recvfrom(size)
            else:
                return False, False
        except Exception as e:
            self.LogError("recvfrom exception: "+str(e))
            return False, False

    def add_device(self, device):
        self.devices.append(device)
        self.LogDebug("UPnP broadcast listener: new device registered")

# This is an example handler class. The fauxmo class expects handlers to be
# instances of objects that have on() and off() methods that return True
# on success and False otherwise.
#
# This example class takes two full URLs that should be requested when an on
# and off command are invoked respectively. It ignores any return data.

class FauxmoCallback(MyCommon):
    """Use this DEBOUNCE_SECONDS to keep multiple Amazon Echo devices from reacting to
       the same voice command.
    """
    DEBOUNCE_SECONDS = 0.3
    STATUS_INTERVAL = 10
    # ---------------- FauxmoCallback.init -------------------------------------
    def __init__(self, cmd, log = None, debug = False):
        super(FauxmoCallback, self).__init__()
        self.cmd = cmd
        self.log = log
        self.debug = debug
        self.lastEcho = time.time()
        self.lastStatus = time.time()
    # ---------------- FauxmoCallback.on ---------------------------------------
    def on(self):
        if self.debounce():
            return True
        try:
              returnValue = self.cmd("generator: setremote=starttransfer")
              ## FOR TESTING ## returnValue = self.cmd("generator: setremote=start")
              ## FOR TESTING ## returnValue = self.cmd("generator: setremote=stop")
              self.LogDebug("Sent Remote Start Command. Return Value: "+returnValue)
              if returnValue != "Remote command sent successfully":
                  self.LogError("Command Failed")
                  return False
        except Exception as e1:
              LogErrorLine("Error FauxmoCallback.on: " + str(e1))
              return False
        return True
    # ---------------- FauxmoCallback.off --------------------------------------
    def off(self):
        if self.debounce():
            return True
        try:
            returnValue = self.cmd("generator: setremote=stop")

            self.LogDebug("Sent Remote Stop Command. Return Value: "+returnValue)
            if returnValue != "Remote command sent successfully":
                self.LogError("Command Failed")
                return False
        except Exception as e1:
            self.LogErrorLine("Error FauxmoCallback.off: " + str(e1))
            return False
        return True
    # ---------------- FauxmoCallback.status -----------------------------------
    def status(self, currentStatus):
        """Ensure the generators status is not checked too often if many
           Echos are present
        """
        if (time.time() - self.lastStatus) < self.STATUS_INTERVAL:
            return currentStatus

        self.lastStatus = time.time()
        try:
              returnValue = self.cmd("generator: getbase")
              self.LogDebug("Sent GETBASE Command. Return Value: "+returnValue)
              if "RUNNING" in returnValue:
                  currentStatus = 1
              else:
                  currentStatus = 0
        except Exception as e1:
              LogErrorLine("Error StopCallback: " + str(e1))
              return currentStatus
        return currentStatus

    # ---------------- FauxmoCallback.debounce ---------------------------------
    def debounce(self):
        """If multiple Echos are present, the one most likely to respond first
           is the one that can best hear the speaker... which is the closest one.
           Adding a refractory period to handlers keeps us from worrying about
           one Echo overhearing a command meant for another one.
        """
        if (time.time() - self.lastEcho) < self.DEBOUNCE_SECONDS:
            return True

        self.lastEcho = time.time()
        return False


#----------  Signal Handler ----------------------------------------------------
def signal_handler(signal, frame):

    try:
        MyClientInterface.Close()
    except Exception as e1:
        log.error("Error: signal_handler: " + str(e1))
    sys.exit(0)

#------------------- Command-line interface for gengpioin ----------------------
if __name__=='__main__':
    address=ProgramDefaults.LocalHost

    try:
        console = SetupLogger("genalexa_console", log_file = "", stream = True)

        if os.geteuid() != 0:
            console.error("You need to have root privileges to run this script.\nPlease try again, this time using 'sudo'. Exiting.")
            sys.exit(2)

        HelpStr = '\nsudo python genalexa.py -a <IP Address or localhost> -c <path to genmon config file>\n'
        try:
            ConfigFilePath = ProgramDefaults.ConfPath
            opts, args = getopt.getopt(sys.argv[1:],"hc:a:",["help","configpath=","address="])
        except getopt.GetoptError:
            console.error("Invalid command line argument.")
            sys.exit(2)

        for opt, arg in opts:
            if opt == '-h':
                console.error(HelpStr)
                sys.exit()
            elif opt in ("-a", "--address"):
                address = arg
            elif opt in ("-c", "--configpath"):
                ConfigFilePath = arg
                ConfigFilePath = ConfigFilePath.strip()
    except Exception as e1:
        console.error("Error in init: " + str(e1) + " : " + GetErrorLine())
        sys.exit(1)
    try:
        port, loglocation = MySupport.GetGenmonInitInfo(ConfigFilePath, log = console)
        log = SetupLogger("client", loglocation + "genalexa.log")
    except Exception as e1:
        print("Error setting up log: " + str(e1))
        sys.exit(1)
    try:
        # Set the signal handler
        signal.signal(signal.SIGINT, signal_handler)

        if not os.path.isfile(ConfigFilePath + 'genalexa.conf'):
            console.error("Error: config file not found")
            log.error("Error: config file not found")
            sys.exit(1)
        config = MyConfig(filename = ConfigFilePath + 'genalexa.conf', section = 'genalexa', log = log)
        FauxmoName = config.ReadValue('name', default = " generator")
        FauxmoPort = config.ReadValue('port', return_type = int, default = 52004)
        Debug = config.ReadValue('debug', return_type = bool, default = False)

        log.error("Key word: " + FauxmoName + "; Port: "+str(FauxmoPort) + "; " + "Debug: " + str(Debug))
        MyClientInterface = ClientInterface(host = address, port = port, log = log)


        data = MyClientInterface.ProcessMonitorCommand("generator: start_info_json")
        StartInfo = {}
        StartInfo = json.loads(data)
        remoteCommands = False
        if 'RemoteCommands' in StartInfo:
           remoteCommands = StartInfo['RemoteCommands']
        if remoteCommands == False:
           log.error("Generator does not support remote commands. So you cannot use this addon. Exiting....")
           sys.exit(1)

        FauxmoAction = FauxmoCallback(MyClientInterface.ProcessMonitorCommand, log = log, debug = Debug)

        # Set up our singleton for polling the sockets for data ready
        p = poller(log = log)

        # Set up our singleton listener for UPnP broadcasts
        u = upnp_broadcast_responder(log  = log, debug = Debug)
        u.init_socket()

        # Add the UPnP broadcast listener to the poller so we can respond
        # when a broadcast is received.
        p.add(u)

        switch = fauxmo(FauxmoName, u, p, None, FauxmoPort, action_handler = FauxmoAction, log  = log, debug = Debug)

        if Debug:
            log.info("Entering main loop")

        while True:
            try:
                # Allow time for a ctrl-c to stop the process
                p.poll(100)
                time.sleep(0.1)
            except Exception as e:
                log.error("Exception occured in main loop: "  + str(e))
                time.sleep(60)
                # break

    except Exception as e1:
        log.error("Error : " + str(e1))
        console.error("Error: " + str(e1))