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 absolute_import

    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

    47

    48

service_type = '_PYRO._tcp.local.'

    49

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

    50

# supported by this connector confnode.

    51

#

    52

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

    53

# or set to an empty list.

    54

    55

URITypes = ["LOCAL", "PYRO", "PYROS"]

    56

    57

    58

def PYRO_connector_factory(uri, confnodesroot):

    59

    """

    60

    This returns the connector to Pyro style PLCobject

    61

    """

    62

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

    63

    64

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

    65

    if servicetype == "PYROS":

    66

        schemename = "PYROLOCSSL"

    67

        # Protect against name->IP substitution in Pyro3

    68

        Pyro.config.PYRO_DNS_URI = True

    69

        # Beware Pyro lib need str path, not unicode

    70

        # don't rely on PYRO_STORAGE ! see documentation

    71

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

    72

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

    73

            confnodesroot.logger.write_error(

    74

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

    75

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

    76

            return None

    77

        else:

    78

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

    79

                                       % (Pyro.config.PYROSSL_CERTDIR))

    80

        Pyro.config.PYROSSL_CERT = "client.crt"

    81

        Pyro.config.PYROSSL_KEY = "client.key"

    82

    83

        # Ugly Monkey Patching

    84

        def _gettimeout(self):

    85

            return self.timeout

    86

    87

        def _settimeout(self, timeout):

    88

            self.timeout = timeout

    89

        from M2Crypto.SSL import Connection  # pylint: disable=import-error

    90

        Connection.timeout = None

    91

        Connection.gettimeout = _gettimeout

    92

        Connection.settimeout = _settimeout

    93

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

    94

        # match host, expected 127.0.0.1, got server

    95

        Connection.clientPostConnectionCheck = None

    96

    else:

    97

        schemename = "PYROLOC"

    98

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

    99

        try:

   100

            from zeroconf import Zeroconf

   101

            r = Zeroconf()

   102

            i = r.get_service_info(service_type, location)

   103

            if i is None:

   104

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

   105

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

   106

            port = str(i.port)

   107

            newlocation = ip + ':' + port

   108

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

   109

            location = newlocation

   110

            r.close()

   111

        except Exception:

   112

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

   113

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

   114

            return None

   115

   116

    # Try to get the proxy object

   117

    try:

   118

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

   119

    except Exception:

   120

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

   121

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

   122

        return None

   123

   124

    def PyroCatcher(func, default=None):

   125

        """

   126

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

   127

        and return default value when it happen

   128

        """

   129

        def catcher_func(*args, **kwargs):

   130

            try:

   131

                return func(*args, **kwargs)

   132

            except Pyro.errors.ConnectionClosedError, e:

   133

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

   134

                confnodesroot._SetConnector(None)

   135

            except Pyro.errors.ProtocolError, e:

   136

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

   137

            except Exception, e:

   138

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

   139

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

   140

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

   141

                print(errmess)

   142

                confnodesroot._SetConnector(None)

   143

            return default

   144

        return catcher_func

   145

   146

    # Check connection is effective.

   147

    # lambda is for getattr of GetPLCstatus to happen inside catcher

   148

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

   149

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

   150

        return None

   151

   152

    class PyroProxyProxy(object):

   153

        """

   154

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

   155

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

   156

        """

   157

        def __init__(self):

   158

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

   159

            self.RemotePLCObjectProxyCopy = None

   160

   161

        def GetPyroProxy(self):

   162

            """

   163

            This func returns the real Pyro Proxy.

   164

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

   165

            """

   166

            return RemotePLCObjectProxy

   167

   168

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

   169

            """

   170

            confnodesroot._connector.GetPyroProxy() is used

   171

            rather than RemotePLCObjectProxy because

   172

            object is recreated meanwhile,

   173

            so we must not keep ref to it here

   174

            """

   175

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

   176

            if current_status == "Dirty":

   177

                # Some bad libs with static symbols may polute PLC

   178

                # ask runtime to suicide and come back again

   179

   180

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

   181

                confnodesroot._connector.GetPyroProxy().ForceReload()

   182

                confnodesroot._Disconnect()

   183

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

   184

                sleep(0.5)

   185

                confnodesroot._Connect()

   186

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

   187

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

   188

        StartPLC = PyroCatcher(_PyroStartPLC, False)

   189

   190

        def _PyroGetTraceVariables(self):

   191

            """

   192

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

   193

            """

   194

            if self.RemotePLCObjectProxyCopy is None:

   195

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

   196

            return self.RemotePLCObjectProxyCopy.GetTraceVariables()

   197

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

   198

   199

        def _PyroGetPLCstatus(self):

   200

            return RemotePLCObjectProxy.GetPLCstatus()

   201

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

   202

   203

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

   204

            return RemotePLCObjectProxy.RemoteExec(script, **kwargs)

   205

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

   206

   207

        def __getattr__(self, attrName):

   208

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

   209

            if member is None:

   210

                def my_local_func(*args, **kwargs):

   211

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

   212

                member = PyroCatcher(my_local_func, None)

   213

                self.__dict__[attrName] = member

   214

            return member

   215

   216

    return PyroProxyProxy()

   217