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

import Pyro

    26

import Pyro.core

    27

import Pyro.util

    28

from Pyro.errors import PyroError

    29

import traceback

    30

from time import sleep

    31

import copy

    32

import socket

    35

service_type = '_PYRO._tcp.local.'

    36

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

    37

# supported by this connector confnode.

    38

#

    39

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

    40

# or set to an empty list.

    41

    42

    43

def PYRO_connector_factory(uri, confnodesroot):

    44

    """

    45

    This returns the connector to Pyro style PLCobject

    46

    """

    47

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

    48

    49

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

    50

    if servicetype == "PYROS":

    51

        schemename = "PYROLOCSSL"

    52

        # Protect against name->IP substitution in Pyro3

    53

        Pyro.config.PYRO_DNS_URI = True

    54

        # Beware Pyro lib need str path, not unicode

    55

        # don't rely on PYRO_STORAGE ! see documentation

    56

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

    57

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

    58

            confnodesroot.logger.write_error(

    59

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

    60

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

    61

            return None

    62

        else:

    63

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

    64

                                       % (Pyro.config.PYROSSL_CERTDIR))

    65

        Pyro.config.PYROSSL_CERT = "client.crt"

    66

        Pyro.config.PYROSSL_KEY = "client.key"

    67

    68

        # Ugly Monkey Patching

    69

        def _gettimeout(self):

    70

            return self.timeout

    71

    72

        def _settimeout(self, timeout):

    73

            self.timeout = timeout

    74

        from M2Crypto.SSL import Connection

    75

        Connection.timeout = None

    76

        Connection.gettimeout = _gettimeout

    77

        Connection.settimeout = _settimeout

    78

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

    79

        # match host, expected 127.0.0.1, got server

    80

        Connection.clientPostConnectionCheck = None

    81

    else:

    82

        schemename = "PYROLOC"

    83

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

    84

        try:

    85

            from util.Zeroconf import Zeroconf

    86

            r = Zeroconf()

    87

            i = r.getServiceInfo(service_type, location)

    88

            if i is None:

    89

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

    90

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

    91

            port = str(i.getPort())

    92

            newlocation = ip + ':' + port

    93

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

    94

            location = newlocation

    95

            r.close()

    96

        except Exception, msg:

    97

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

    98

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

    99

            return None

   100

   101

    # Try to get the proxy object

   102

    try:

   103

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

   104

    except Exception, msg:

   105

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

   106

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

   107

        return None

   108

   109

    def PyroCatcher(func, default=None):

   110

        """

   111

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

   112

        and return default value when it happen

   113

        """

   114

        def catcher_func(*args, **kwargs):

   115

            try:

   116

                return func(*args, **kwargs)

   117

            except Pyro.errors.ConnectionClosedError, e:

   118

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

   119

                confnodesroot._SetConnector(None)

   120

            except Pyro.errors.ProtocolError, e:

   121

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

   122

            except Exception, e:

   123

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

   124

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

   125

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

   126

                print errmess

   127

                confnodesroot._SetConnector(None)

   128

            return default

   129

        return catcher_func

   130

   131

    # Check connection is effective.

   132

    # lambda is for getattr of GetPLCstatus to happen inside catcher

   133

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

   134

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

   135

        return None

   136

   137

    class PyroProxyProxy(object):

   138

        """

   139

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

   140

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

   141

        """

   142

        def __init__(self):

   143

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

   144

            self.RemotePLCObjectProxyCopy = None

   145

   146

        def GetPyroProxy(self):

   147

            """

   148

            This func returns the real Pyro Proxy.

   149

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

   150

            """

   151

            return RemotePLCObjectProxy

   152

   153

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

   154

            """

   155

            confnodesroot._connector.GetPyroProxy() is used

   156

            rather than RemotePLCObjectProxy because

   157

            object is recreated meanwhile,

   158

            so we must not keep ref to it here

   159

            """

   160

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

   161

            if current_status == "Dirty":

   162

                """

   163

                Some bad libs with static symbols may polute PLC

   164

                ask runtime to suicide and come back again

   165

                """

   166

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

   167

                confnodesroot._connector.GetPyroProxy().ForceReload()

   168

                confnodesroot._Disconnect()

   169

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

   170

                sleep(0.5)

   171

                confnodesroot._Connect()

   172

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

   173

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

   174

        StartPLC = PyroCatcher(_PyroStartPLC, False)

   175

   176

        def _PyroGetTraceVariables(self):

   177

            """

   178

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

   179

            """

   180

            if self.RemotePLCObjectProxyCopy is None:

   181

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

   182

            return self.RemotePLCObjectProxyCopy.GetTraceVariables()

   183

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

   184

   185

        def _PyroGetPLCstatus(self):

   186

            return RemotePLCObjectProxy.GetPLCstatus()

   187

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

   188

   189

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

   190

            return RemotePLCObjectProxy.RemoteExec(script, **kwargs)

   191

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

   192

   193

        def __getattr__(self, attrName):

   194

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

   195

            if member is None:

   196

                def my_local_func(*args, **kwargs):

   197

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

   198

                member = PyroCatcher(my_local_func, None)

   199

                self.__dict__[attrName] = member

   200

            return member

   201

   202

    return PyroProxyProxy()