1

#!/usr/bin/env python

     2

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

     3

     4

# Written by Edouard TISSERANT (C) 2024

     5

# This file is part of Beremiz IDE

     6

# See COPYING file for copyrights details.

     7

     8

     9

import os.path

    10

import re

    11

import traceback

    12

from inspect import getmembers, isfunction

    13

    14

    15

import erpc

    16

    17

# eRPC service code

    18

from erpc_interface.erpc_PLCObject.interface import IBeremizPLCObjectService

    19

from erpc_interface.erpc_PLCObject.client import BeremizPLCObjectServiceClient

    20

from erpc_interface.erpc_PLCObject.common import trace_order, extra_file, PLCstatus_enum

    21

    22

import PSKManagement as PSK

    23

from connectors.ERPC.PSK_Adapter import SSLPSKClientTransport

    24

from connectors.ConnectorBase import ConnectorBase

    25

from connectors.ERPC_URI import per_scheme_model

    26

    27

enum_to_PLCstatus = dict(map(lambda t:(t[1],t[0]),getmembers(PLCstatus_enum, lambda x:type(x)==int)))

    28

    29

class MissingCallException(Exception):

    30

    pass

    31

    32

def ExceptionFromERPCReturn(ret):

    33

    return {1:Exception,

    34

            2:MissingCallException}.get(ret,ValueError)

    35

    36

def ReturnAsLastOutput(client_method, obj, args_wrapper, *args):

    37

    retval = erpc.Reference()

    38

    ret = client_method(obj, *args_wrapper(*args), retval)

    39

    if ret != 0:

    40

        raise ExceptionFromERPCReturn(ret)(client_method.__name__)

    41

    return retval.value

    42

    43

def TranslatedReturnAsLastOutput(translator):

    44

    def wrapper(client_method, obj, args_wrapper, *args):

    45

        res = ReturnAsLastOutput(client_method, obj, args_wrapper, *args)

    46

        return translator(res)

    47

    return wrapper

    48

    49

ReturnWrappers = {

    50

    "AppendChunkToBlob":ReturnAsLastOutput,

    51

    "GetLogMessage":TranslatedReturnAsLastOutput(

    52

        lambda res:(res.msg, res.tick, res.sec, res.nsec)),

    53

    "GetPLCID":TranslatedReturnAsLastOutput(

    54

        lambda res:(res.ID, res.PSK)),

    55

    "GetPLCstatus":TranslatedReturnAsLastOutput(

    56

        lambda res:(enum_to_PLCstatus[res.PLCstatus], res.logcounts)),

    57

    "GetTraceVariables":TranslatedReturnAsLastOutput(

    58

        lambda res:(enum_to_PLCstatus[res.PLCstatus],

    59

                    [(sample.tick, bytes(sample.TraceBuffer)) for sample in res.traces])),

    60

    "MatchMD5":ReturnAsLastOutput,

    61

    "NewPLC":ReturnAsLastOutput,

    62

    "SeedBlob":ReturnAsLastOutput,

    63

    "SetTraceVariablesList": ReturnAsLastOutput,

    64

    "StopPLC":ReturnAsLastOutput,

    65

    "ExtendedCall":ReturnAsLastOutput,

    66

}

    67

    68

ArgsWrappers = {

    69

    "NewPLC":

    70

        lambda md5sum, plcObjectBlobID, extrafiles: (

    71

            md5sum, plcObjectBlobID, [extra_file(*f) for f in extrafiles]),

    72

    "SetTraceVariablesList":

    73

        lambda orders : ([

    74

            trace_order(idx, b"" if force is None else force) 

    75

            for idx, force in orders],)

    76

}

    77

    78

def rpc_wrapper(method_name, confnodesroot):

    79

    client_method = getattr(BeremizPLCObjectServiceClient, method_name)

    80

    return_wrapper = ReturnWrappers.get(

    81

        method_name, 

    82

        lambda client_method, obj, args_wrapper, *args: client_method(obj, *args_wrapper(*args)))

    83

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

    84

    85

    def exception_wrapper(self, *args):

    86

        try:

    87

            return return_wrapper(client_method, self, args_wrapper, *args)

    88

        except erpc.transport.ConnectionClosed as e:

    89

            confnodesroot._SetConnector(None)

    90

            confnodesroot.logger.write_error(_("Connection lost!\n"))

    91

        except erpc.codec.CodecError as e:

    92

            confnodesroot.logger.write_warning(_("ERPC codec error: %s\n") % e)

    93

        except erpc.client.RequestError as e:

    94

            confnodesroot.logger.write_error(_("ERPC request error: %s\n") % e)                

    95

        except MissingCallException as e:

    96

            confnodesroot.logger.write_warning(_("Remote call not supported: %s\n") % e)

    97

        except Exception as e:

    98

            errmess = _("Exception calling remote PLC object fucntion %s:\n") % method_name \

    99

                        + traceback.format_exc()

   100

            confnodesroot.logger.write_error(errmess + "\n")

   101

            confnodesroot._SetConnector(None)

   102

   103

        return self.PLCObjDefaults.get(method_name)

   104

    return exception_wrapper

   105

   106

   107

   108

def ERPC_connector_factory(uri, confnodesroot):

   109

    """

   110

    returns the ERPC connector

   111

    """

   112

    confnodesroot.logger.write(_("ERPC connecting to URI : %s\n") % uri)

   113

   114

    # TODO add parsing for serial URI

   115

    # ERPC:///dev/ttyXX:baudrate or ERPC://:COM4:baudrate

   116

   117

    try:

   118

        scheme, location = uri.split("://",1)

   119

        _model, _useID, parser, _builder = per_scheme_model[scheme]

   120

        location_data = parser(location)

   121

    except Exception as e:

   122

        confnodesroot.logger.write_error(

   123

            'Malformed URI "%s": %s\n' % (uri, str(e)))

   124

        return None

   125

   126

    PLCObjectERPCProxy = type(

   127

        "PLCObjectERPCProxy",

   128

        (ConnectorBase, BeremizPLCObjectServiceClient),

   129

        {name: rpc_wrapper(name, confnodesroot)

   130

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

   131

   132

    if scheme in ["ERPCS", "ERPC"]:

   133

        if scheme=="ERPCS":

   134

            ID = location_data["ID"]

   135

            if not ID:

   136

                confnodesroot.logger.write_error(

   137

                    f'Invalid URI "{uri}": ERPCS requires PLC ID after "#"\n')

   138

                return None

   139

            default_port = 4000

   140

        else:

   141

            ID = None

   142

            if "#" in location:

   143

                confnodesroot.logger.write_error(

   144

                    f'URI "{uri}": Non-encrypted ERPC does not take a PLC ID after "#"\n')

   145

                return None

   146

            default_port = 3000

   147

   148

        host = location_data["host"]

   149

        port = location_data["port"]

   150

        port = int(port) if port else default_port

   151

   152

        try:

   153

            if ID:

   154

                # load PSK from project

   155

                secpath = os.path.join(confnodesroot.ProjectPath, 'psk', ID + '.secret')

   156

                if not os.path.exists(secpath):

   157

                    confnodesroot.logger.write_error(

   158

                        'Error: Pre-Shared-Key Secret in %s is missing!\n' % secpath)

   159

                    return None

   160

                secret = open(secpath).read().partition(':')[2].rstrip('\n\r').encode()

   161

                transport = SSLPSKClientTransport(host, port, (secret, ID.encode())) # type: ignore

   162

            else:

   163

   164

                transport = erpc.transport.TCPTransport(host, port, False)

   165

   166

            clientManager = erpc.client.ClientManager(transport, erpc.basic_codec.BasicCodec)

   167

            client = PLCObjectERPCProxy(clientManager)

   168

   169

        except Exception as e:

   170

            confnodesroot.logger.write_error(

   171

                _("Connection to {loc} failed with exception {ex}\n").format(

   172

                    loc=uri, ex=str(e)))

   173

            return None

   174

   175

    else:

   176

        # TODO if serial URI then 

   177

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

   178

   179

        confnodesroot.logger.write_error(

   180

            _("Unknown scheme {scheme} in URI {uri}\n").format(

   181

                scheme=scheme, uri=uri))

   182

        return None

   183

    # Check connection is effective.

   184

    IDPSK = client.GetPLCID()

   185

    if IDPSK:

   186

        ID, secret = IDPSK

   187

        PSK.UpdateID(confnodesroot.ProjectPath, ID, secret, uri)

   188

    else:

   189

        confnodesroot.logger.write_warning(_("PLC did not provide identity and security infomation.\n"))

   190

   191

    return client