#!/usr/bin/env python

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

# Written by Edouard TISSERANT (C) 2024

# This file is part of Beremiz runtime

# See COPYING.Runtime file for copyrights details.

import sys

import traceback

from inspect import getmembers, isfunction

import erpc

# eRPC service code

from erpc_interface.erpc_PLCObject.common import PSKID, PLCstatus, TraceVariables, trace_sample, PLCstatus_enum, log_message

from erpc_interface.erpc_PLCObject.interface import IBeremizPLCObjectService

from erpc_interface.erpc_PLCObject.server import BeremizPLCObjectServiceService

from runtime import GetPLCObjectSingleton as PLC

from runtime.loglevels import LogLevelsDict

from runtime.ServicePublisher import ServicePublisher

def ReturnAsLastOutput(method, args_wrapper, *args):

args[-1].value = method(*args_wrapper(*args[:-1]))

return 0

def TranslatedReturnAsLastOutput(translator):

def wrapper(method, args_wrapper, *args):

args[-1].value = translator(method(*args_wrapper(*args[:-1])))

return 0

return wrapper

ReturnWrappers = {

"AppendChunkToBlob":ReturnAsLastOutput,

"GetLogMessage":TranslatedReturnAsLastOutput(

lambda res:log_message(*res)),

"GetPLCID":TranslatedReturnAsLastOutput(

lambda res:PSKID(*res)),

"GetPLCstatus":TranslatedReturnAsLastOutput(

lambda res:PLCstatus(getattr(PLCstatus_enum, res[0]),res[1])),

"GetTraceVariables":TranslatedReturnAsLastOutput(

lambda res:TraceVariables(getattr(PLCstatus_enum, res[0]),[trace_sample(*sample) for sample in res[1]])),

"MatchMD5":ReturnAsLastOutput,

"NewPLC":ReturnAsLastOutput,

"SeedBlob":ReturnAsLastOutput,

"SetTraceVariablesList": ReturnAsLastOutput,

"StopPLC":ReturnAsLastOutput,

}

ArgsWrappers = {

"AppendChunkToBlob":

lambda data, blobID:(data, bytes(blobID)),

"NewPLC":

lambda md5sum, plcObjectBlobID, extrafiles: (

md5sum, bytes(plcObjectBlobID), [(f.fname, bytes(f.blobID)) for f in extrafiles]),

"SetTraceVariablesList":

lambda orders : ([(order.idx, None if len(order.force)==0 else bytes(order.force)) for order in orders],)

}

def rpc_wrapper(method_name):

PLCobj = PLC()

method=getattr(PLCobj, method_name)

args_wrapper = ArgsWrappers.get(method_name, lambda *x:x)

return_wrapper = ReturnWrappers.get(method_name,

lambda method, args_wrapper, *args: method(*args_wrapper(*args)))

def exception_wrapper(self, *args):

try:

return_wrapper(method, args_wrapper, *args)

return 0

except Exception as e:

print(traceback.format_exc())

PLCobj.LogMessage(CRITICAL_LOG_LEVEL, f'eRPC call {method_name} Exception "{str(e)}"')

raise

return exception_wrapper

class eRPCServer(object):

def __init__(self, servicename, ip_addr, port):

self.continueloop = True

self.server = None

self.transport = None

self.servicename = servicename

self.ip_addr = ip_addr

self.port = port

self.servicepublisher = None

def _to_be_published(self):

return self.servicename is not None and \

self.ip_addr not in ["", "localhost", "127.0.0.1"]

def PrintServerInfo(self):

print(_("eRPC port :"), self.port)

if self._to_be_published():

print(_("Publishing service on local network"))

if sys.stdout:

sys.stdout.flush()

def Loop(self, when_ready):

if self._to_be_published():

self.Publish()

# service handler calls PLC object though erpc_stubs's wrappers

handler = type(

"PLCObjectServiceHandlder",

(IBeremizPLCObjectService,),

{name: rpc_wrapper(name)

for name,_func in getmembers(IBeremizPLCObjectService, isfunction)})()

service = BeremizPLCObjectServiceService(handler)

# TODO initialize Serial transport layer if selected

# transport = erpc.transport.SerialTransport(device, baudrate)

# initialize TCP transport layer

self.transport = erpc.transport.TCPTransport(self.ip_addr, int(self.port), True)

self.server = erpc.simple_server.SimpleServer(self.transport, erpc.basic_codec.BasicCodec)

self.server.add_service(service)

when_ready()

while self.continueloop:

try:

self.server.run()

except erpc.transport.ConnectionClosed:

PLC().LogMessage(LogLevelsDict["DEBUG"], 'eRPC client disconnected')

except Exception as e:

self.Unpublish()

#TODO crash better

raise e

def Restart(self):

self.server.stop()

def Quit(self):

self.continueloop = False

self.server.stop()

def Publish(self):

self.servicepublisher = ServicePublisher("ERPC")

self.servicepublisher.RegisterService(self.servicename,

self.ip_addr, self.port)

def Unpublish(self):

if self.servicepublisher is not None:

self.servicepublisher.UnRegisterService()

self.servicepublisher = None