Agordejo/tools/nsm-data

#! /usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Copyright 2020, Nils Hilbricht, Germany ( https://www.hilbricht.net )

This file is part of the Laborejo Software Suite ( https://www.laborejo.org ),
more specifically its template base application.

The Template Base Application is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
"""

import logging; logger = logging.getLogger("nsm-data"); logger.info("import")

URL="https://www.laborejo.org/argodejo/nsm-data"
HARD_LIMIT = 512 # no single message longer than this
VERSION= 1.0

#In case the user tries to run this standalone.
import argparse
parser = argparse.ArgumentParser(description="nsm-data is a module for Argodejo. It only communicates over OSC in an NSM-Session and has no standalone functionality.")
parser.add_argument("-v", "--version", action='version', version=str(VERSION))
args = parser.parse_args()

import json
import pathlib
from time import sleep
from sys import exit as sysexit

from nsmclient import NSMClient
from nsmclient import NSMNotRunningError

def chunkstring(string):
    return [string[0+i:HARD_LIMIT+i] for i in range(0, len(string), HARD_LIMIT)]

class DataClient(object):
    """
    Keys are strings,
    While nsmd OSC support int, str and float we use json exclusively.
    We expect a json string and will parse it here.

    All message consist of two arguments maximum: a key and, if a create-function, a json string.

    Rule: all client-keys are send as strings, even in replies. All client-values are send as
    json-string, even if originally just a string.

    Description is a multi-part message, a string.

    DataClient will register itself as Data-Storage. All other communication is done via osc.
    In theory every application can read and write us (like a book!)

    We listen to OSC paths and reply to the sender, which must give its address explicitly.
        /argodejo/datastorage/readall s:request-host i:request-port #Request all data
        /argodejo/datastorage/read s:key s:request-host i:request-port #Request one value

    The write functions have no reply. They will print out to stdout/err but not send an error
    message back.
        /argodejo/datastorage/create s:key any:value #Write/Create one value
        /argodejo/datastorage/update s:kecy any:value #Update a value, but only if it exists
        /argodejo/datastorage/delete s:key #Remove a key/value completely
    """

    def __init__(self):

        self.data = None #Dict. created in openOrNewCallbackFunction, saved as json
        self.absoluteJsonFilePath = None #pathlib.Path set by openOrNewCallbackFunction

        self._descriptionStringArray = {"identifier":None} #int:str
        self._descriptionId = None

        self.nsmClient = NSMClient(prettyName = "Data-Storage", #will raise an error and exit if this example is not run from NSM.
            saveCallback = self.saveCallbackFunction,
            openOrNewCallback = self.openOrNewCallbackFunction,
            supportsSaveStatus = True,         # Change this to True if your program announces it's save status to NSM
            exitProgramCallback = self.exitCallbackFunction,
            broadcastCallback = None,
            hideGUICallback = None, #replace with your hiding function. You need to answer in your function with nsmClient.announceGuiVisibility(False)
            showGUICallback = None,  #replace with your showing function. You need to answer in your function with nsmClient.announceGuiVisibility(True)
            sessionIsLoadedCallback = self.sessionIsLoadedCallback, #no parametersd
            loggingLevel = "error", #"info" for development or debugging, "error" for production. default is error.
            )

        #Add custom callbacks. They all receive _IncomingMessage(data)        
        self.nsmClient.reactions["/argodejo/datastorage/setclientoverridename"] = self.setClientOverrideName
        self.nsmClient.reactions["/argodejo/datastorage/getclientoverridename"] = self.getClientOverrideName
        self.nsmClient.reactions["/argodejo/datastorage/getall"] = self.getAll
        self.nsmClient.reactions["/argodejo/datastorage/getdescription"] = self.getDescription
        self.nsmClient.reactions["/argodejo/datastorage/setdescription"] = self.setDescription        
        #self.nsmClient.reactions["/argodejo/datastorage/read"] = self.reactRead
        #self.nsmClient.reactions["/argodejo/datastorage/readall"] = self.reactReadAll
        #self.nsmClient.reactions["/argodejo/datastorage/create"] = self.reactCreate
        #self.nsmClient.reactions["/argodejo/datastorage/update"] = self.reactUpdate
        #self.nsmClient.reactions["/argodejo/datastorage/delete"] = self.reactDelete

        #NsmClients only returns from init when it has a connection, and on top (for us) when session is ready. It is safe to announce now.
        self.nsmClient.broadcast("/argodejo/datastorage/announce", [self.nsmClient.ourClientId, HARD_LIMIT, self.nsmClient.ourOscUrl])

        while True:
            self.nsmClient.reactToMessage()
            sleep(0.05) #20fps update cycle

    def getAll(self, msg):
        """A complete data dumb, intended to use once after startup.
        Will split into multiple reply messages, if needed"""
        senderHost, senderPort = msg.params
        path = "/argodejo/datastorage/reply/getall"
        encoded = json.dumps(self.data)
        chunks = chunkstring(encoded)
        l = len(chunks)
        for index, chunk in enumerate(chunks):
            listOfParameters = [index+0, l-1, chunk]
            self.nsmClient.send(path, listOfParameters, host=senderHost, port=senderPort)

    def getDescription(self, msg)->str:
        """Returns a normal string, not json"""
        senderHost, senderPort = msg.params
        path = "/argodejo/datastorage/reply/getdescription"
        chunks = chunkstring(self.data["description"])
        l = len(chunks)
        for index, chunk in enumerate(chunks):
            listOfParameters = [index+0, l-1, chunk]
            self.nsmClient.send(path, listOfParameters, host=senderHost, port=senderPort)

    def setDescription(self, msg):
        """
        Answers with descriptionId and index when data was received and saved.        

        The GUI needs to buffer this a bit. Don't send every char as single message.
        
        This is for multi-part messages
        Index is 0 based,
        chunk is part of a simple string, not json.

        The descriptionId:int indicates the message the chunks belong to.
        If we see a new one we reset our storage.
        """
        descriptionId, index, chunk, senderHost, senderPort = msg.params #str, int, str, str, int
        if not self._descriptionId == descriptionId:
            self._descriptionId = descriptionId
            self._descriptionStringArray.clear()
        self._descriptionStringArray[index] = chunk         
        buildString = "".join([v for k,v in sorted(self._descriptionStringArray.items())])        
        self.data["description"] = buildString
        self.nsmClient.announceSaveStatus(False)

    def getClientOverrideName(self, msg):
        """Answers with empty string if clientId does not exist or has not data. This is a signal
        for the GUI/host to use the original name!"""
        clientId, senderHost, senderPort = msg.params
        path = "/argodejo/datastorage/reply/getclient"
        if clientId in self.data["clientOverrideNames"]:            
            name = self.data["clientOverrideNames"][clientId]
        else:
            logger.info(f"We were instructed to read client {clientId}, but it does not exist")
            name = ""
        listOfParameters = [clientId, json.dumps(name)]
        self.nsmClient.send(path, listOfParameters, host=senderHost, port=senderPort)

    def setClientOverrideName(self, msg):
        """We accept empty string as a name to remove the name override.        
        """
        clientId, jsonValue = msg.params
        name = json.loads(jsonValue)[:HARD_LIMIT]
        if name:
            self.data["clientOverrideNames"][clientId] = name
        else:
            #It is possible that a client not present in our storage will send an empty string. Protect.
            if clientId in self.data["clientOverrideNames"]:
                del self.data["clientOverrideNames"][clientId]
        self.nsmClient.announceSaveStatus(False)

    #Generic Functions. Not in use and not ready.
    #Callback Reactions to OSC. They all receive _IncomingMessage(data)
    def reactReadAll(self, msg):
        senderHost, senderPort = msg.params
        path = "/argodejo/datastorage/reply/readall"
        encoded = json.dumps("")
        chunks = chunkstring(encoded, 512)
        l = len(chunks)
        for index, chunk in enumerate(chunks):
            listOfParameters = [index+0, l-1, chunk]
            self.nsmClient.send(path, listOfParameters, host=senderHost, port=senderPort)

    def reactRead(self, msg):
        key, senderHost, senderPort = msg.params
        if key in self.data:
            path = "/argodejo/datastorage/reply/read"
            listOfParameters = [key, json.dumps(self.data[key])]
            self.nsmClient.send(path, listOfParameters, host=senderHost, port=senderPort)
        else:
            logger.warning(f"We were instructed to read key {key}, but it does not exist")

    def reactCreate(self, msg):
        key, jsonValue = msg.params
        value = json.loads(jsonValue)
        self.data[key] = value
        self.nsmClient.announceSaveStatus(False)

    def reactUpdate(self, msg):
        key, jsonValue = msg.params
        value = json.loads(jsonValue)
        if key in self.data:
            self.data[key] = value
            self.nsmClient.announceSaveStatus(False)
        else:
            logger.warning(f"We were instructed to update key {key} with value {value}, but it does not exist")

    def reactDelete(self, msg):
        key = msg.params[0]
        if key in self.data:
            del self.data[key]
            self.nsmClient.announceSaveStatus(False)
        else:
            logger.warning(f"We were instructed to delete key {key}, but it does not exist")

    #NSM Callbacks and File Handling

    def saveCallbackFunction(self, ourPath, sessionName, ourClientNameUnderNSM):
        result = self.data
        result["origin"] = URL
        result["version"] = VERSION
        jsonData = json.dumps(result, indent=2)

        try:
            with open(self.absoluteJsonFilePath, "w", encoding="utf-8") as f:
                f.write(jsonData)
        except Exception as e:
            logging.error("Will not load or save because: " + e.__repr__())
        return self.absoluteJsonFilePath
        #nsmclient.py will send save status clean

    def openOrNewCallbackFunction(self, ourPath, sessionName, ourClientNameUnderNSM):
        self.absoluteJsonFilePath = pathlib.Path(ourPath)
        try:
            self.data = self.openFromJson(self.absoluteJsonFilePath)
        except FileNotFoundError:
            self.data = None #This makes debugging output nicer. If we init Data() here all errors will be presented as follow-up error "while handling exception FileNotFoundError".
        except (NotADirectoryError, PermissionError) as e:
            self.data = None
            logger.error("Will not load or save because: " + e.__repr__())

        if not self.data:
            self.data = {"clientOverrideNames":{}, "description":""}
        logger.info("New/Open complete")
        #TODO: send data

    def openFromJson(self, absoluteJsonFilePath):
        with open(absoluteJsonFilePath, "r", encoding="utf-8") as f:
            try:
                text = f.read()
                result = json.loads(text)
            except Exception as error:
                result = None
                logger.error(error)

        if result and "version" in result and "origin" in result and result["origin"] == URL:
            if result["version"] >= VERSION:
                assert type(result) is dict, (result, type(result))
                logger.info("Loading file from json complete")
                return result
            else:
                logger.error(f"""{absoluteJsonFilePath} was saved with {result["version"]} but we need {VERSION}""")
                sysexit()
        else:
            logger.error(f"""Error. {absoluteJsonFilePath} not loaded. Not a sane argodejo/nsm-data file in json format""")
            sysexit()


    def sessionIsLoadedCallback(self):
        """At one point I thought we could send our data when session is ready, so the GUI actually
        has clients to rename. However, that turned out impossible or impractical.
        Instead the GUI now just fails if nameOverrides that we send are not available yet and tries
        again later.

        Leave that in for documentation.
        """
        pass
        
        

    #def broadcastCallbackFunction(self, ourPath, sessionName, ourClientNameUnderNSM, messagePath, listOfArguments):
    #    print (__file__, "broadcast")

    def exitCallbackFunction(self, ourPath, sessionName, ourClientNameUnderNSM):
        sysexit(0)

if __name__ == '__main__':
    """Creating an instance starts the client and does not return"""
    try:
        DataClient()
    except NSMNotRunningError:
        parser.print_help()