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

    26

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

    27

    28

class MissingCallException(Exception):

    29

    pass

    30

    31

def ExceptionFromERPCReturn(ret):

    32

    return {1:Exception,

    33

            2:MissingCallException}.get(ret,ValueError)

    34

    35

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

    36

    retval = erpc.Reference()

    37

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

    38

    if ret != 0:

    39

        raise ExceptionFromERPCReturn(ret)(client_method.__name__)

    40

    return retval.value

    41

    42

def TranslatedReturnAsLastOutput(translator):

    43

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

    44

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

    45

        return translator(res)

    46

    return wrapper

    47

    48

ReturnWrappers = {

    49

    "AppendChunkToBlob":ReturnAsLastOutput,

    50

    "GetLogMessage":TranslatedReturnAsLastOutput(

    51

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

    52

    "GetPLCID":TranslatedReturnAsLastOutput(

    53

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

    54

    "GetPLCstatus":TranslatedReturnAsLastOutput(

    55

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

    56

    "GetTraceVariables":TranslatedReturnAsLastOutput(

    57

        lambda res:(enum_to_PLCstatus[res.PLCstatus],

    58

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

    59

    "MatchMD5":ReturnAsLastOutput,

    60

    "NewPLC":ReturnAsLastOutput,

    61

    "SeedBlob":ReturnAsLastOutput,

    62

    "SetTraceVariablesList": ReturnAsLastOutput,

    63

    "StopPLC":ReturnAsLastOutput,

    64

}

    65

    66

ArgsWrappers = {

    67

    "NewPLC":

    68

        lambda md5sum, plcObjectBlobID, extrafiles: (

    69

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

    70

    "SetTraceVariablesList":

    71

        lambda orders : ([

    72

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

    73

            for idx, force in orders],)

    74

}

    75

    76

def ERPC_connector_factory(uri, confnodesroot):

    77

    """

    78

    returns the ERPC connector

    79

    """

    80

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

    81

    82

    # TODO add parsing for serial URI

    83

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

    84

    85

    try:

    86

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

    87

        locator, *IDhash = location.split('#',1)

    88

        x = re.match(r'(?P<host>[^\s:]+):?(?P<port>\d+)?', locator)

    89

        host = x.group('host')

    90

        port = x.group('port')

    91

        if port:

    92

            port = int(port)

    93

        else:

    94

            # default port depends on security

    95

            port = 4000 if IDhash else 3000

    96

    97

        if not IDhash and _scheme=="ERPCS":

    98

            confnodesroot.logger.write_error(

    99

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

   100

            return None

   101

        elif IDhash and _scheme!="ERPCS":

   102

            confnodesroot.logger.write_error(

   103

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

   104

            return None

   105

   106

    except Exception as e:

   107

        confnodesroot.logger.write_error(

   108

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

   109

        return None

   110

   111

    def rpc_wrapper(method_name):

   112

        client_method = getattr(BeremizPLCObjectServiceClient, method_name)

   113

        return_wrapper = ReturnWrappers.get(

   114

            method_name, 

   115

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

   116

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

   117

   118

        def exception_wrapper(self, *args):

   119

            try:

   120

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

   121

            except erpc.transport.ConnectionClosed as e:

   122

                confnodesroot._SetConnector(None)

   123

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

   124

            except erpc.codec.CodecError as e:

   125

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

   126

            except erpc.client.RequestError as e:

   127

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

   128

            except MissingCallException as e:

   129

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

   130

            except Exception as e:

   131

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

   132

                          + traceback.format_exc()

   133

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

   134

                confnodesroot._SetConnector(None)

   135

   136

            return self.PLCObjDefaults.get(method_name)

   137

        return exception_wrapper

   138

   139

   140

    PLCObjectERPCProxy = type(

   141

        "PLCObjectERPCProxy",

   142

        (ConnectorBase, BeremizPLCObjectServiceClient),

   143

        {name: rpc_wrapper(name)

   144

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

   145

   146

    try:

   147

        if IDhash:

   148

            ID = IDhash[0]

   149

            # load PSK from project

   150

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

   151

            if not os.path.exists(secpath):

   152

                confnodesroot.logger.write_error(

   153

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

   154

                return None

   155

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

   156

            transport = SSLPSKClientTransport(host, port, (secret, ID.encode()))

   157

        else:

   158

            # TODO if serial URI then 

   159

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

   160

   161

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

   162

   163

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

   164

        client = PLCObjectERPCProxy(clientManager)

   165

   166

    except Exception as e:

   167

        confnodesroot.logger.write_error(

   168

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

   169

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

   170

        return None

   171

   172

    # Check connection is effective.

   173

    IDPSK = client.GetPLCID()

   174

    if IDPSK:

   175

        ID, secret = IDPSK

   176

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

   177

    else:

   178

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

   179

   180

    return client