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

    27

from __future__ import print_function

    28

import traceback

    29

from time import sleep

    30

import copy

    31

import socket

    32

import os.path

    33

    34

import Pyro

    35

import Pyro.core

    36

import Pyro.util

    37

from Pyro.errors import PyroError

    38

    39

    40

service_type = '_PYRO._tcp.local.'

    41

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

    42

# supported by this connector confnode.

    43

#

    44

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

    45

# or set to an empty list.

    46

    47

    48

def PYRO_connector_factory(uri, confnodesroot):

    49

    """

    50

    This returns the connector to Pyro style PLCobject

    51

    """

    52

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

    53

    54

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

    55

    if servicetype == "PYROS":

    56

        schemename = "PYROLOCSSL"

    57

        # Protect against name->IP substitution in Pyro3

    58

        Pyro.config.PYRO_DNS_URI = True

    59

        # Beware Pyro lib need str path, not unicode

    60

        # don't rely on PYRO_STORAGE ! see documentation

    61

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

    62

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

    63

            confnodesroot.logger.write_error(

    64

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

    65

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

    66

            return None

    67

        else:

    68

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

    69

                                       % (Pyro.config.PYROSSL_CERTDIR))

    70

        Pyro.config.PYROSSL_CERT = "client.crt"

    71

        Pyro.config.PYROSSL_KEY = "client.key"

    72

    73

        # Ugly Monkey Patching

    74

        def _gettimeout(self):

    75

            return self.timeout

    76

    77

        def _settimeout(self, timeout):

    78

            self.timeout = timeout

    79

        from M2Crypto.SSL import Connection

    80

        Connection.timeout = None

    81

        Connection.gettimeout = _gettimeout

    82

        Connection.settimeout = _settimeout

    83

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

    84

        # match host, expected 127.0.0.1, got server

    85

        Connection.clientPostConnectionCheck = None

    86

    else:

    87

        schemename = "PYROLOC"

    88

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

    89

        try:

    90

            from zeroconf import Zeroconf

    91

            r = Zeroconf()

    92

            i = r.get_service_info(service_type, location)

    93

            if i is None:

    94

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

    95

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

    96

            port = str(i.port)

    97

            newlocation = ip + ':' + port

    98

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

    99

            location = newlocation

   100

            r.close()

   101

        except Exception:

   102

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

   103

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

   104

            return None

   105

   106

    # Try to get the proxy object

   107

    try:

   108

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

   109

    except Exception:

   110

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

   111

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

   112

        return None

   113

   114

    def PyroCatcher(func, default=None):

   115

        """

   116

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

   117

        and return default value when it happen

   118

        """

   119

        def catcher_func(*args, **kwargs):

   120

            try:

   121

                return func(*args, **kwargs)

   122

            except Pyro.errors.ConnectionClosedError, e:

   123

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

   124

                confnodesroot._SetConnector(None)

   125

            except Pyro.errors.ProtocolError, e:

   126

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

   127

            except Exception, e:

   128

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

   129

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

   130

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

   131

                print(errmess)

   132

                confnodesroot._SetConnector(None)

   133

            return default

   134

        return catcher_func

   135

   136

    # Check connection is effective.

   137

    # lambda is for getattr of GetPLCstatus to happen inside catcher

   138

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

   139

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

   140

        return None

   141

   142

    class PyroProxyProxy(object):

   143

        """

   144

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

   145

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

   146

        """

   147

        def __init__(self):

   148

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

   149

            self.RemotePLCObjectProxyCopy = None

   150

   151

        def GetPyroProxy(self):

   152

            """

   153

            This func returns the real Pyro Proxy.

   154

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

   155

            """

   156

            return RemotePLCObjectProxy

   157

   158

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

   159

            """

   160

            confnodesroot._connector.GetPyroProxy() is used

   161

            rather than RemotePLCObjectProxy because

   162

            object is recreated meanwhile,

   163

            so we must not keep ref to it here

   164

            """

   165

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

   166

            if current_status == "Dirty":

   167

                # Some bad libs with static symbols may polute PLC

   168

                # ask runtime to suicide and come back again

   169

   170

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

   171

                confnodesroot._connector.GetPyroProxy().ForceReload()

   172

                confnodesroot._Disconnect()

   173

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

   174

                sleep(0.5)

   175

                confnodesroot._Connect()

   176

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

   177

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

   178

        StartPLC = PyroCatcher(_PyroStartPLC, False)

   179

   180

        def _PyroGetTraceVariables(self):

   181

            """

   182

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

   183

            """

   184

            if self.RemotePLCObjectProxyCopy is None:

   185

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

   186

            return self.RemotePLCObjectProxyCopy.GetTraceVariables()

   187

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

   188

   189

        def _PyroGetPLCstatus(self):

   190

            return RemotePLCObjectProxy.GetPLCstatus()

   191

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

   192

   193

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

   194

            return RemotePLCObjectProxy.RemoteExec(script, **kwargs)

   195

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

   196

   197

        def __getattr__(self, attrName):

   198

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

   199

            if member is None:

   200

                def my_local_func(*args, **kwargs):

   201

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

   202

                member = PyroCatcher(my_local_func, None)

   203

                self.__dict__[attrName] = member

   204

            return member

   205

   206

    return PyroProxyProxy()