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

    33

import os.path

    34

    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()