communication.py

# -*- coding: utf-8 -*-

# ***************************************************************************
# *                                                                         *
# *   Animate workbench - FreeCAD Workbench for lightweight animation       *
# *   Copyright (c) 2019 Jiří Valášek jirka362@gmail.com                    *
# *                                                                         *
# *   This file is part of the Animate workbench.                           *
# *                                                                         *
# *   This program is free software; you can redistribute it and/or modify  *
# *   it under the terms of the GNU Lesser General Public License (LGPL)    *
# *   as published by the Free Software Foundation; either version 2 of     *
# *   the License, or (at your option) any later version.                   *
# *   for detail see the LICENCE text file.                                 *
# *                                                                         *
# *   Animate workbench 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 Lesser General Public License for more details.                   *
# *                                                                         *
# *   You should have received a copy of the GNU Library General Public     *
# *   License along with Animate workbench; if not, write to the Free       *
# *   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,        *
# *   MA  02111-1307 USA                                                    *
# *                                                                         *
# ***************************************************************************/



import sys
try:
    import FreeCAD
except ImportError:
    pass

from PySide2.QtCore import QThread, QByteArray, QDataStream, QIODevice
from PySide2.QtNetwork import QTcpServer, QTcpSocket, QAbstractSocket, \
                              QHostAddress


SIZEOF_UINT16 = 2


SERVER_ERROR_INVALID_ADDRESS = 1


SERVER_ERROR_PORT_OCCUPIED = 2


WAIT_TIME_MS = 30000


COMMAND_EXECUTED_CONFIRMATION_MESSAGE = "Command executed successfully"


CLIENT_COMMAND_EXECUTED = 0


CLIENT_COMMAND_FAILED = 1


CLIENT_ERROR_RESPONSE_NOT_COMPLETE = 2


CLIENT_ERROR_NO_RESPONSE = 3


CLIENT_ERROR_BLOCK_NOT_WRITTEN = 4


CLIENT_ERROR_NO_CONNECTION = 5




class CommandThread(QThread):

    

    

    

    def __init__(self, socketDescriptor, parent):
        super(CommandThread, self).__init__(parent)
        self.socketDescriptor = socketDescriptor
        self.blockSize = 0

    

    def run(self):
        # Try to connect to an incoming tcp socket using its socket descriptor
        tcpSocket = QTcpSocket()
        if not tcpSocket.setSocketDescriptor(self.socketDescriptor):
            FreeCAD.Console.PrintError("Socket not accepted.\n")
            return
        FreeCAD.Console.PrintLog("Socket accepted.\n")

        # Wait for an incoming message
        if not tcpSocket.waitForReadyRead(msecs=WAIT_TIME_MS):
            FreeCAD.Console.PrintError("No request send.\n")
            return

        # Make an input data stream
        instr = QDataStream(tcpSocket)
        instr.setVersion(QDataStream.Qt_4_0)

        # Try to read the message size
        if self.blockSize == 0:
            if tcpSocket.bytesAvailable() < 2:
                FreeCAD.Console.PrintError("Received message "
                                           + "has too few bytes.\n")
                return
            self.blockSize = instr.readUInt16()

        # Check message is sent complete
        if tcpSocket.bytesAvailable() < self.blockSize:
            FreeCAD.Console.PrintError("Received message has less bytes "
                                       + "then it's supposed to.\n")
            return

        # Read message and inform about it
        cmd = instr.readRawData(self.blockSize).decode("UTF-8")
        FreeCAD.Console.PrintLog("CommandServer received> "
                                 + cmd + "\n")

        # Try to execute the message string and prepare  a response
        try:
            exec(cmd)
        except Exception as e:
            FreeCAD.Console.PrintError("Executing external command failed:"
                                       + str(e) + "\n")
            message = "Command failed - " + str(e)
        else:
            FreeCAD.Console.PrintLog("Executing external command succeeded!\n")
            message = COMMAND_EXECUTED_CONFIRMATION_MESSAGE

        # Prepare the data block to send back and inform about it
        FreeCAD.Console.PrintLog("CommandServer sending> " + message + " \n")
        block = QByteArray(
                len(message.encode("UTF-8")).to_bytes(2, byteorder='big')
                + message.encode("UTF-8"))
        outstr = QDataStream(block, QIODevice.WriteOnly)
        outstr.setVersion(QDataStream.Qt_4_0)

        # Send the block, disconnect from the socket and terminate the QThread
        tcpSocket.write(block)
        tcpSocket.disconnectFromHost()
        tcpSocket.waitForDisconnected()




class CommandServer(QTcpServer):
    

    def __init__(self, parent=None):
        super(CommandServer, self).__init__(parent)

    

    def incomingConnection(self, socketDescriptor):
        thread = CommandThread(socketDescriptor, self)
        thread.finished.connect(thread.deleteLater)
        thread.start()

    

    def close(self):
        super(CommandServer, self).close()
        FreeCAD.Console.PrintLog("Server closed.\n")




def checkIPIsValid(ip):
    if ip.upper() == "LOCALHOST":
        return True

    numbers = ip.split(".")
    if len(numbers) == 4:
        if all([(0 <= int(num) <= 255) for num in numbers]):
            return True

    return False




def startServer(addr, port):

    if not checkIPIsValid(addr):
        return SERVER_ERROR_INVALID_ADDRESS

    if addr.upper() == "LOCALHOST":
        addr = QHostAddress(QHostAddress.LocalHost)
    else:
        addr = QHostAddress(addr)

    server = CommandServer()
    if not server.listen(addr, port):
        FreeCAD.Console.PrintLog("Unable to start the server: %s.\n"
                                 % server.errorString())
        return SERVER_ERROR_PORT_OCCUPIED

    else:
        FreeCAD.Console.PrintLog("The server is running on address %s"
                                 % server.serverAddress().toString()
                                 + " and port %d.\n" % server.serverPort())
        return server




class CommandClient:

    

    

    

    

    

    def __init__(self, host, port):
        self.host = host
        self.port = port
        self.tcpSocket = QTcpSocket()
        self.blockSize = 0

    

    def sendCommand(self, cmd):

        # connect a Qt slot to receive and print errors
        self.tcpSocket.error.connect(self.displayError)

        # Try to connect to a host server
        self.tcpSocket.connectToHost(self.host, self.port, QIODevice.ReadWrite)
        if not self.tcpSocket.waitForConnected(msecs=WAIT_TIME_MS):
            if "FreeCAD" in sys.modules:
                FreeCAD.Console.PrintError("CommandClient.sendCommand error: "
                                           + "No connection\n")
            else:
                print("CommandClient.sendCommand error: No connection\n")
            return CLIENT_ERROR_NO_CONNECTION

        # Prepare a command message to be sent
        block = QByteArray(
                len(cmd.encode("UTF-8")).to_bytes(2, byteorder='big')
                + cmd.encode("UTF-8"))
        outstr = QDataStream(block, QIODevice.WriteOnly)
        outstr.setVersion(QDataStream.Qt_4_0)

        # Try to send the message
        if "FreeCAD" in sys.modules:
            FreeCAD.Console.PrintMessage("CommandClient sending> "
                                         + cmd + "\n")
        else:
            print("CommandClient sending> " + cmd + "\n")
        self.tcpSocket.write(block)
        if not self.tcpSocket.waitForBytesWritten(msecs=WAIT_TIME_MS):
            if "FreeCAD" in sys.modules:
                FreeCAD.Console.PrintError("CommandClient.sendCommand error: "
                                           + "Block not written\n")
            else:
                print("CommandClient.sendCommand error: Block not written\n")
            return CLIENT_ERROR_BLOCK_NOT_WRITTEN

        # Wait for a response from the host server
        if not self.tcpSocket.waitForReadyRead(msecs=WAIT_TIME_MS):
            if "FreeCAD" in sys.modules:
                FreeCAD.Console.PrintError("CommandClient.sendCommand error: "
                                           + "No response received.\n")
            else:
                print("CommandClient.sendCommand error: "
                      + "No response received.\n")
            return CLIENT_ERROR_NO_RESPONSE

        # Try to read the response
        instr = QDataStream(self.tcpSocket)
        instr.setVersion(QDataStream.Qt_4_0)
        if self.blockSize == 0:
            if self.tcpSocket.bytesAvailable() < 2:
                return CLIENT_ERROR_RESPONSE_NOT_COMPLETE
            self.blockSize = instr.readUInt16()

        if self.tcpSocket.bytesAvailable() < self.blockSize:
            return CLIENT_ERROR_RESPONSE_NOT_COMPLETE
        response = instr.readRawData(self.blockSize).decode("UTF-8")
        if "FreeCAD" in sys.modules:
            FreeCAD.Console.PrintMessage("CommandClient received> "
                                         + response + "\n")
        else:
            print("CommandClient received> " + response + "\n")

        # Wait until the host server terminates the connection
        self.tcpSocket.waitForDisconnected()
        # Reset blockSize to prepare for sending next command
        self.blockSize = 0

        # Return value representing a command execution status
        if response == COMMAND_EXECUTED_CONFIRMATION_MESSAGE:
            return CLIENT_COMMAND_EXECUTED
        else:
            return CLIENT_COMMAND_FAILED

    

    def displayError(self, socketError):
        if socketError != QAbstractSocket.RemoteHostClosedError:
            if "FreeCAD" in sys.modules:
                FreeCAD.Console.PrintError("CommandClient error occurred> %s."
                                           % self.tcpSocket.errorString()
                                           + "\n")
            else:
                print("CommandClient error occurred> %s."
                      % self.tcpSocket.errorString() + "\n")




def sendClientCommand(host, port, cmd, wait_time=WAIT_TIME_MS):
    # Try to connect to a host server
    tcpSocket = QTcpSocket()
    tcpSocket.connectToHost(host, port, QIODevice.ReadWrite)
    if not tcpSocket.waitForConnected(msecs=wait_time):
        return CLIENT_ERROR_NO_CONNECTION

    # Prepare a command message to be sent
    block = QByteArray(
            len(cmd.encode("UTF-8")).to_bytes(2, byteorder='big')
            + cmd.encode("UTF-8"))
    outstr = QDataStream(block, QIODevice.WriteOnly)
    outstr.setVersion(QDataStream.Qt_4_0)
    tcpSocket.write(block)

    # Try to send the message
    if not tcpSocket.waitForBytesWritten(msecs=wait_time):
        return CLIENT_ERROR_BLOCK_NOT_WRITTEN

    # Wait for a response from the host server
    if not tcpSocket.waitForReadyRead(msecs=wait_time):
        return CLIENT_ERROR_NO_RESPONSE

    # Try to read the response
    instr = QDataStream(tcpSocket)
    instr.setVersion(QDataStream.Qt_4_0)
    blockSize = 0
    if blockSize == 0:
        if tcpSocket.bytesAvailable() < 2:
            return CLIENT_ERROR_RESPONSE_NOT_COMPLETE
        blockSize = instr.readUInt16()
    if tcpSocket.bytesAvailable() < blockSize:
        return CLIENT_ERROR_RESPONSE_NOT_COMPLETE

    # Wait until the host server terminates the connection
    tcpSocket.waitForDisconnected()

    # Return value representing a command execution status
    if instr.readRawData(blockSize).decode("UTF-8") \
            == COMMAND_EXECUTED_CONFIRMATION_MESSAGE:
        return CLIENT_COMMAND_EXECUTED
    else:
        return CLIENT_COMMAND_FAILED