python-host

#!/usr/bin/env python

import struct
import sys
import threading
import Queue
import os.path
import json
from time import gmtime, strftime
import time
from os.path import expanduser

usbDriveLetter = "E:"
isLogging = False
isTesting = False
home = expanduser("~")
logPath = home + '\pythonLog.txt'


# A quick way to attempt using another drive
# Returns true if another drive can be attempted
def try_another_drive():
    global usbDriveLetter
    if not os.path.exists(usbDriveLetter):
        # List of drive letters. Note the absence of A, B and C
        dl = "DEFGHIJKLMNOPQRSTUVWXYZ"
        drives = ['%s:' % d for d in dl if os.path.exists('%s:' % d)]

        # If we can find an alternative drive, use it and return true
        if drives:
            usbDriveLetter = drives[0]
            return True

    # If we can't find another drive...
    return False

# Check for 'test' command line arg
for arg in sys.argv:
    if arg == "test":
        isLogging = True
        isTesting = True


# On Windows, the default I/O mode is O_TEXT. Set this to O_BINARY
# to avoid unwanted modifications of the input/output streams.
if sys.platform == "win32":
    import os
    import msvcrt
    msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
    msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)


# Thread that reads messages from the webapp.
def read_thread_func(queue):
    while 1:
        # Read the message length (first 4 bytes).
        text_length_bytes = sys.stdin.read(4)

        if len(text_length_bytes) == 0:
            if queue:
                queue.put(None)
            sys.exit(0)

        # Unpack message length as 4 byte integer.
        text_length = struct.unpack('i', text_length_bytes)[0]

        # Read the text (JSON object) of the message.
        text = sys.stdin.read(text_length).decode('utf-8')

        if queue:
            queue.put(text)


# Helper to send response to extension
def send_message(message):
    # Write message size.
    sys.stdout.write(struct.pack('I', len(message)))
    # Write the message itself.
    sys.stdout.write(message)
    sys.stdout.flush()


class NativeMessenger():

    def __init__(self, queue):
        self.queue = queue
        # Main loop
        while 1:
            time.sleep(0.1)
            self.processMessages()
            # Break from loop if testing. This way we can work with individual
            # messages in the NativeMessenger object
            if isTesting is True:
                return

    def processMessages(self):
        while not self.queue.empty():
            message = self.queue.get_nowait()
            if message is None:
                self.quit()
                return
            self.log("DBG: Got message!")

            if isTesting is False:
                self.parseAndAct(message)

    # TODO: find a better way to get device paths
    def parseAndAct(self, message):
        # Turn message string to json object
        jMessage = json.loads(message)

        # Extract values from message
        messageType = jMessage["message_type"]
        userToken = jMessage["message_body"]["userToken"]
        preferences = jMessage["message_body"]["preferences"]

        if isTesting is True:
            return(json.dumps(messageType), json.dumps(userToken), json.dumps(preferences))

        # Follow instructions in message, get isSuccessful boolean
        if messageType == "write_usb":
            if isTesting is False:
                self.writeFileAndRespond(preferences, userToken, message)

    # TODO: Implement error codes
    def sendResponse(self, isSuccessful, errorMessage, message):
        self.log("DBG: in sendResponse")
        responseSkeleton = json.dumps({"is_successful": "",
                                       "original_message": "",
                                       "error": {"code": "", "message": ""}
                                       })

        response = json.loads(responseSkeleton)

        response["original_message"] = json.loads(message)
        response["error"]["code"] = '00000'
        response["error"]["message"] = errorMessage

        if isSuccessful is False:
            response["is_successful"] = "false"

        if isSuccessful is True:
            response["is_successful"] = "true"

        self.log("DBG: MESSAGE TO RESPOND WITH:")
        self.log(json.dumps(response))
        if isTesting is True:
            return json.dumps(response)

        else:
            send_message(json.dumps(response))

    def writeFileAndRespond(self, preferences, userToken, message):
        self.log("DBG: Attempting to write to " + usbDriveLetter)
        try:
            self.log("DBG: Writing preferences...")
            prefsFile = open(usbDriveLetter + '\.first-discovery-preferences.txt', 'w+')
            prefsFile.write(json.dumps(preferences))
            prefsFile.close()
            self.log("DBG: Preferences written")

            self.log("DBG: Writing token...")
            tokenFile = open(usbDriveLetter + '\.gpii-user-token.txt', 'w+')
            tokenFile.write(json.dumps(userToken).strip('"'))
            tokenFile.close()
            self.log("DBG: Token written")

            if isTesting is False:
                self.sendResponse(True, "no error", message)

        # If the USB path is invalid, attempt to use another drive
        except IOError as e:
            self.log("ERROR: Error writing to file. Do you have access?")
            hasAltDrive = try_another_drive()
            if hasAltDrive is True:
                self.writeFileAndRespond(preferences, userToken, message)
            else:
                self.log(str(e))
                self.sendResponse(False, "FileIO Error: " + str(e),  message)

    # Set isLogging to True to enable
    def log(self, message):
        # if isLogging == True:
        if isLogging is True:
            with open(logPath, 'a+') as logFile:
                logFile.write(strftime(
                    "%Y-%m-%d %H:%M:%S", gmtime()) + " " + message + "\n")


def tests():
    testSuccess = True
    print("\nTESTING: Running tests...\n")
    print("TESTING: Checking if path to log life exists and is writable")
    if os.path.exists(home):
        print("SUCCESS: log path is good!")
    else:
        print("FAILURE: log path isn't good")
        testSuccess = False
        return

    testMessage = json.dumps(
        {
            "message_type": "write_usb",
            "message_body": {
                "userToken": "unitTest",
                "preferences": {
                    "contexts": {
                        "gpii-default": {
                            "name": "unitTest",
                            "preferences": {
                                "gpii_firstDiscovery_language": "en-US",
                                "gpii_firstDiscovery_speak": "true",
                                    "gpii_firstDiscovery_speechRate": "1.5",
                                    "fluid_prefs_contrast": "bw",
                                    "fluid_prefs_textSize": "1.4",
                                    "gpii_firstDiscovery_onScreenKeyboard": "false",
                                    "gpii_firstDiscovery_captions": "false",
                                    "gpii_firstDiscovery_showSounds": "false",
                                    "gpii_firstDiscovery_stickyKeys": "true"
                            }
                        }
                    }
                }
            }
        }
    )
    testQueue = Queue.Queue()
    messenger = NativeMessenger(testQueue)

    # ===== PARSING TESTING ===== #
    tempPrefs = json.loads(testMessage)
    # Extract preferences from testMessage
    goodPrefs = json.dumps(tempPrefs["message_body"]["preferences"])

    messageParts = messenger.parseAndAct(testMessage)
    messageType = messageParts[0].strip('""')
    userToken = messageParts[1].strip('""')
    preferences = messageParts[2]

    # Check if the parsed message parts have the same vaules as testMessage
    if messageType == "write_usb" and userToken == "unitTest" and preferences == goodPrefs:
        print("SUCCESS: Parsing was successful")
    else:
        print("FAILURE: Parsing was not successful!")
        testSuccess = False

    # ===== RESPONSE TESTING ===== #
    response = json.loads(messenger.sendResponse(True, "no error", testMessage))
    testMessage = json.loads(testMessage)
    if response["original_message"]["message_body"] != testMessage["message_body"]:
        print("FAILURE: RESPONSE MESSAGE INCORRECT")
        testSuccess = False
    if response["error"]["code"] != '00000':
        print("FAILURE: RESPONSE MESSAGE INCORRECT")
        testSuccess = False
    if response["error"]["message"] != 'no error':
        print("FAILURE: RESPONSE MESSAGE INCORRECT")
        testSuccess = False
    else:
        print("SUCCESS: Response message was created successfully")

    # ===== TOKEN WRITING TESTING ===== #
    goodPrefsFile = '{"contexts": {"gpii-default": {"name": "unitTest", "preferences": {"gpii_firstDiscovery_captions": "false", "fluid_prefs_textSize": "1.4", "gpii_firstDiscovery_stickyKeys": "true", "gpii_firstDiscovery_showSounds": "false", "fluid_prefs_contrast": "bw", "gpii_firstDiscovery_speak": "true", "gpii_firstDiscovery_language": "en-US", "gpii_firstDiscovery_onScreenKeyboard": "false", "gpii_firstDiscovery_speechRate": "1.5"}}}}'

    # Check if paths are available
    if not os.path.exists(usbDriveLetter):
        print("FAILURE:"
              " USB Drive wasn't found! The host will now attempt to use "
              "\n\t another drive. Check if the the token and preferences "
              "\n\t were written to your USB drive. The next test will check "
              "\n\t if the files were written.")
        testSuccess = False
    if os.path.exists(usbDriveLetter + '\.first-discovery-preferences.txt'):
        print("INFO: preferences file exists. Deleting it...")
        os.remove(usbDriveLetter + '\.first-discovery-preferences.txt')
    if os.path.exists(usbDriveLetter + '\.gpii-user-token.txt'):
        print("INFO: token file exists. Deleting it...")
        os.remove(usbDriveLetter + '\.gpii-user-token.txt')

    tempPrefs = testMessage["message_body"]["preferences"]
    messenger.writeFileAndRespond(tempPrefs, "unitTest", json.dumps(testMessage))

    if os.path.exists(usbDriveLetter):
        prefsFile = open(usbDriveLetter + '\.first-discovery-preferences.txt', 'r').read()
        tokenFile = open(usbDriveLetter + '\.gpii-user-token.txt').read()
        # Compare values we want with values we get
        if prefsFile != goodPrefsFile or tokenFile != 'unitTest':
            print("FAILURE: Files not correctly written")
            testSuccess = False
        else:
            print("SUCCESS: Files properly written to " + usbDriveLetter)

        if testSuccess is False:
            print("FAILURE: UNIT TESTS FAILED")
        if testSuccess is True:
            print("SUCCESS: ALL TESTS RUN SUCCESSFULLY!")
    else:
        print("FAILURE: No USB device available")


def Main():
    if isTesting is True:
        tests()
    queue = Queue.Queue()
    thread = threading.Thread(target=read_thread_func, args=(queue,))
    thread.daemon = True
    thread.start()

    NativeMessenger(queue)
    sys.exit(0)

if __name__ == '__main__':
    Main()