1

#!/usr/bin/env python

     2

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

     3

     4

# Written by Edouard TISSERANT (C) 2024

     5

# This file is part of Beremiz runtime

     6

# See COPYING.Runtime file for copyrights details.

     7

     8

import sys

     9

import traceback

    10

from inspect import getmembers, isfunction

    11

    12

import erpc

    13

    14

# eRPC service code

    15

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

    16

from erpc_interface.erpc_PLCObject.interface import IBeremizPLCObjectService

    17

from erpc_interface.erpc_PLCObject.server import BeremizPLCObjectServiceService

    18

    19

from runtime import GetPLCObjectSingleton as PLC

    20

from runtime.loglevels import LogLevelsDict

    21

from runtime.ServicePublisher import ServicePublisher

    22

    23

    24

def ReturnAsLastOutput(method, args_wrapper, *args):

    25

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

    26

    return 0

    27

    28

def TranslatedReturnAsLastOutput(translator):

    29

    def wrapper(method, args_wrapper, *args):

    30

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

    31

        return 0

    32

    return wrapper

    33

    34

    35

ReturnWrappers = {

    36

    "AppendChunkToBlob":ReturnAsLastOutput,

    37

    "GetLogMessage":TranslatedReturnAsLastOutput(

    38

        lambda res:log_message(*res)),

    39

    "GetPLCID":TranslatedReturnAsLastOutput(

    40

        lambda res:PSKID(*res)),

    41

    "GetPLCstatus":TranslatedReturnAsLastOutput(

    42

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

    43

    "GetTraceVariables":TranslatedReturnAsLastOutput(

    44

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

    45

    "MatchMD5":ReturnAsLastOutput,

    46

    "NewPLC":ReturnAsLastOutput,

    47

    "SeedBlob":ReturnAsLastOutput,

    48

    "SetTraceVariablesList": ReturnAsLastOutput,

    49

    "StopPLC":ReturnAsLastOutput,

    50

    "ExtendedCall":ReturnAsLastOutput,

    51

}

    52

    53

ArgsWrappers = {

    54

    "AppendChunkToBlob":

    55

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

    56

    "NewPLC":

    57

        lambda md5sum, plcObjectBlobID, extrafiles: (

    58

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

    59

    "SetTraceVariablesList": 

    60

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

    61

}

    62

    63

def rpc_wrapper(method_name, server):

    64

    PLCobj = PLC()

    65

    method=getattr(PLCobj, method_name)

    66

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

    67

    return_wrapper = ReturnWrappers.get(method_name,

    68

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

    69

    70

    def exception_wrapper(self, *args):

    71

        try:

    72

            return_wrapper(method, args_wrapper, *args)

    73

            return 0

    74

        except Exception as e:

    75

            print(traceback.format_exc())

    76

            PLCobj.LogMessage(LogLevelsDict["CRITICAL"], f'eRPC call {method_name} Exception "{str(e)}"')

    77

            server.transport.close()

    78

            raise

    79

    80

    return exception_wrapper

    81

    82

    83

class eRPCServer(object):

    84

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

    85

        self.continueloop = True

    86

        self.server = None

    87

        self.transport = None

    88

        self.servicename = servicename

    89

        self.ip_addr = ip_addr

    90

        self.port = int(port)

    91

        self.servicepublisher = None

    92

    93

    def _to_be_published(self):

    94

        return self.servicename is not None and \

    95

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

    96

    97

    def PrintServerInfo(self):

    98

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

    99

   100

        if self._to_be_published():

   101

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

   102

   103

        if sys.stdout:

   104

            sys.stdout.flush()

   105

   106

    def Loop(self, when_ready):

   107

        if self._to_be_published():

   108

            self.Publish()

   109

   110

        # service handler calls PLC object though erpc_stubs's wrappers

   111

        handler = type(

   112

            "PLCObjectServiceHandlder", 

   113

            (IBeremizPLCObjectService,),

   114

            {name: rpc_wrapper(name, self)

   115

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

   116

   117

        service = BeremizPLCObjectServiceService(handler)

   118

   119

        # TODO initialize Serial transport layer if selected

   120

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

   121

   122

        # initialize TCP transport layer

   123

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

   124

   125

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

   126

        self.server.add_service(service)

   127

   128

        when_ready()

   129

   130

        while self.continueloop:

   131

   132

            try:

   133

                self.server.run()

   134

            except erpc.transport.ConnectionClosed:

   135

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

   136

            except Exception as e:

   137

                self.Unpublish()

   138

                #TODO crash better

   139

                raise e

   140

   141

   142

    def Restart(self):

   143

        self.server.stop()

   144

   145

    def Quit(self):

   146

        self.continueloop = False

   147

        self.server.stop()

   148

   149

    def Publish(self):

   150

        self.servicepublisher = ServicePublisher("ERPC")

   151

        self.servicepublisher.RegisterService(self.servicename,

   152

                                              self.ip_addr, self.port)

   153

   154

    def Unpublish(self):

   155

        if self.servicepublisher is not None:

   156

            self.servicepublisher.UnRegisterService()

   157

            self.servicepublisher = None