1

#!/usr/bin/env python

     2

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

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program is distributed in the hope that it will be useful,

    17

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

    26

from __future__ import print_function

    27

import traceback

    28

from time import sleep

    29

import copy

    30

import socket

    31

import os.path

    32

    33

import Pyro

    34

import Pyro.core

    35

import Pyro.util

    36

from Pyro.errors import PyroError

    37

    38

    39

service_type = '_PYRO._tcp.local.'

    40

# this module attribute contains a list of DNS-SD (Zeroconf) service types

    41

# supported by this connector confnode.

    42

#

    43

# for connectors that do not support DNS-SD, this attribute can be omitted

    44

# or set to an empty list.

    45

    46

    47

def PYRO_connector_factory(uri, confnodesroot):

    48

    """

    49

    This returns the connector to Pyro style PLCobject

    50

    """

    51

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

    52

    53

    servicetype, location = uri.split("://")

    54

    if servicetype == "PYROS":

    55

        schemename = "PYROLOCSSL"

    56

        # Protect against name->IP substitution in Pyro3

    57

        Pyro.config.PYRO_DNS_URI = True

    58

        # Beware Pyro lib need str path, not unicode

    59

        # don't rely on PYRO_STORAGE ! see documentation

    60

        Pyro.config.PYROSSL_CERTDIR = os.path.abspath(str(confnodesroot.ProjectPath) + '/certs')

    61

        if not os.path.exists(Pyro.config.PYROSSL_CERTDIR):

    62

            confnodesroot.logger.write_error(

    63

                'Error : the directory %s is missing for SSL certificates (certs_dir).'

    64

                'Please fix it in your project.\n' % Pyro.config.PYROSSL_CERTDIR)

    65

            return None

    66

        else:

    67

            confnodesroot.logger.write(_("PYRO using certificates in '%s' \n")

    68

                                       % (Pyro.config.PYROSSL_CERTDIR))

    69

        Pyro.config.PYROSSL_CERT = "client.crt"

    70

        Pyro.config.PYROSSL_KEY = "client.key"

    71

    72

        # Ugly Monkey Patching

    73

        def _gettimeout(self):

    74

            return self.timeout

    75

    76

        def _settimeout(self, timeout):

    77

            self.timeout = timeout

    78

        from M2Crypto.SSL import Connection

    79

        Connection.timeout = None

    80

        Connection.gettimeout = _gettimeout

    81

        Connection.settimeout = _settimeout

    82

        # M2Crypto.SSL.Checker.WrongHost: Peer certificate commonName does not

    83

        # match host, expected 127.0.0.1, got server

    84

        Connection.clientPostConnectionCheck = None

    85

    else:

    86

        schemename = "PYROLOC"

    87

    if location.find(service_type) != -1:

    88

        try:

    89

            from zeroconf import Zeroconf

    90

            r = Zeroconf()

    91

            i = r.get_service_info(service_type, location)

    92

            if i is None:

    93

                raise Exception("'%s' not found" % location)

    94

            ip = str(socket.inet_ntoa(i.address))

    95

            port = str(i.port)

    96

            newlocation = ip + ':' + port

    97

            confnodesroot.logger.write(_("'{a1}' is located at {a2}\n").format(a1=location, a2=newlocation))

    98

            location = newlocation

    99

            r.close()

   100

        except Exception:

   101

            confnodesroot.logger.write_error(_("MDNS resolution failure for '%s'\n") % location)

   102

            confnodesroot.logger.write_error(traceback.format_exc())

   103

            return None

   104

   105

    # Try to get the proxy object

   106

    try:

   107

        RemotePLCObjectProxy = Pyro.core.getAttrProxyForURI(schemename + "://" + location + "/PLCObject")

   108

    except Exception:

   109

        confnodesroot.logger.write_error(_("Connection to '%s' failed.\n") % location)

   110

        confnodesroot.logger.write_error(traceback.format_exc())

   111

        return None

   112

   113

    def PyroCatcher(func, default=None):

   114

        """

   115

        A function that catch a Pyro exceptions, write error to logger

   116

        and return default value when it happen

   117

        """

   118

        def catcher_func(*args, **kwargs):

   119

            try:

   120

                return func(*args, **kwargs)

   121

            except Pyro.errors.ConnectionClosedError, e:

   122

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

   123

                confnodesroot._SetConnector(None)

   124

            except Pyro.errors.ProtocolError, e:

   125

                confnodesroot.logger.write_error(_("Pyro exception: %s\n") % e)

   126

            except Exception, e:

   127

                # confnodesroot.logger.write_error(traceback.format_exc())

   128

                errmess = ''.join(Pyro.util.getPyroTraceback(e))

   129

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

   130

                print(errmess)

   131

                confnodesroot._SetConnector(None)

   132

            return default

   133

        return catcher_func

   134

   135

    # Check connection is effective.

   136

    # lambda is for getattr of GetPLCstatus to happen inside catcher

   137

    if PyroCatcher(RemotePLCObjectProxy.GetPLCstatus)() is None:

   138

        confnodesroot.logger.write_error(_("Cannot get PLC status - connection failed.\n"))

   139

        return None

   140

   141

    class PyroProxyProxy(object):

   142

        """

   143

        A proxy proxy class to handle Beremiz Pyro interface specific behavior.

   144

        And to put Pyro exception catcher in between caller and Pyro proxy

   145

        """

   146

        def __init__(self):

   147

            # for safe use in from debug thread, must create a copy

   148

            self.RemotePLCObjectProxyCopy = None

   149

   150

        def GetPyroProxy(self):

   151

            """

   152

            This func returns the real Pyro Proxy.

   153

            Use this if you musn't keep reference to it.

   154

            """

   155

            return RemotePLCObjectProxy

   156

   157

        def _PyroStartPLC(self, *args, **kwargs):

   158

            """

   159

            confnodesroot._connector.GetPyroProxy() is used

   160

            rather than RemotePLCObjectProxy because

   161

            object is recreated meanwhile,

   162

            so we must not keep ref to it here

   163

            """

   164

            current_status, _log_count = confnodesroot._connector.GetPyroProxy().GetPLCstatus()

   165

            if current_status == "Dirty":

   166

                # Some bad libs with static symbols may polute PLC

   167

                # ask runtime to suicide and come back again

   168

   169

                confnodesroot.logger.write(_("Force runtime reload\n"))

   170

                confnodesroot._connector.GetPyroProxy().ForceReload()

   171

                confnodesroot._Disconnect()

   172

                # let remote PLC time to resurect.(freeze app)

   173

                sleep(0.5)

   174

                confnodesroot._Connect()

   175

            self.RemotePLCObjectProxyCopy = copy.copy(confnodesroot._connector.GetPyroProxy())

   176

            return confnodesroot._connector.GetPyroProxy().StartPLC(*args, **kwargs)

   177

        StartPLC = PyroCatcher(_PyroStartPLC, False)

   178

   179

        def _PyroGetTraceVariables(self):

   180

            """

   181

            for safe use in from debug thread, must use the copy

   182

            """

   183

            if self.RemotePLCObjectProxyCopy is None:

   184

                self.RemotePLCObjectProxyCopy = copy.copy(confnodesroot._connector.GetPyroProxy())

   185

            return self.RemotePLCObjectProxyCopy.GetTraceVariables()

   186

        GetTraceVariables = PyroCatcher(_PyroGetTraceVariables, ("Broken", None))

   187

   188

        def _PyroGetPLCstatus(self):

   189

            return RemotePLCObjectProxy.GetPLCstatus()

   190

        GetPLCstatus = PyroCatcher(_PyroGetPLCstatus, ("Broken", None))

   191

   192

        def _PyroRemoteExec(self, script, **kwargs):

   193

            return RemotePLCObjectProxy.RemoteExec(script, **kwargs)

   194

        RemoteExec = PyroCatcher(_PyroRemoteExec, (-1, "RemoteExec script failed!"))

   195

   196

        def __getattr__(self, attrName):

   197

            member = self.__dict__.get(attrName, None)

   198

            if member is None:

   199

                def my_local_func(*args, **kwargs):

   200

                    return RemotePLCObjectProxy.__getattr__(attrName)(*args, **kwargs)

   201

                member = PyroCatcher(my_local_func, None)

   202

                self.__dict__[attrName] = member

   203

            return member

   204

   205

    return PyroProxyProxy()