1

#!/usr/bin/env python

     2

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

     6

#

     7

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

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    15

#

    17

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

    20

#

    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

service_type = '_PYRO._tcp.local.'

    34

import os.path

    35

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

    36

# supported by this connector confnode.

    37

#

    38

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

    39

# or set to an empty list.

    40

    41

def PYRO_connector_factory(uri, confnodesroot):

    42

    """

    43

    This returns the connector to Pyro style PLCobject

    44

    """

    45

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

    46

    47

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

    48

    if servicetype == "PYROS":

    49

        schemename = "PYROLOCSSL"

    50

        # Protect against name->IP substitution in Pyro3

    51

        Pyro.config.PYRO_DNS_URI = True

    52

        # Beware Pyro lib need str path, not unicode

    53

        # don't rely on PYRO_STORAGE ! see documentation

    54

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

    55

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

    56

            confnodesroot.logger.write_error(

    57

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

    58

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

    59

            return None

    60

        else:

    61

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

    62

                                       % (Pyro.config.PYROSSL_CERTDIR))

    63

        Pyro.config.PYROSSL_CERT = "client.crt"

    64

        Pyro.config.PYROSSL_KEY = "client.key"

    65

        # Ugly Monkey Patching

    66

        def _gettimeout(self):

    67

            return self.timeout

    68

    69

        def _settimeout(self, timeout):

    70

            self.timeout = timeout

    71

        from M2Crypto.SSL import Connection

    72

        Connection.timeout = None

    73

        Connection.gettimeout = _gettimeout

    74

        Connection.settimeout = _settimeout

    75

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

    76

        # match host, expected 127.0.0.1, got server

    77

        Connection.clientPostConnectionCheck = None

    78

    else:

    79

        schemename = "PYROLOC"

    80

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

    81

        try:

    82

            from util.Zeroconf import Zeroconf

    83

            r = Zeroconf()

    84

            i = r.getServiceInfo(service_type, location)

    85

            if i is None:

    86

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

    87

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

    88

            port = str(i.getPort())

    89

            newlocation = ip + ':' + port

    90

            confnodesroot.logger.write(_("'%s' is located at %s\n") % (location, newlocation))

    91

            location = newlocation

    92

            r.close()

    93

        except Exception, msg:

    94

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

    95

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

    96

            return None

    97

    98

    # Try to get the proxy object

    99

    try:

   100

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

   101

    except Exception, msg:

   102

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

   103

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

   104

        return None

   105

   106

    def PyroCatcher(func, default=None):

   107

        """

   108

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

   109

        and return default value when it happen

   110

        """

   111

        def catcher_func(*args, **kwargs):

   112

            try:

   113

                return func(*args, **kwargs)

   114

            except Pyro.errors.ConnectionClosedError, e:

   115

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

   116

                confnodesroot._SetConnector(None)

   117

            except Pyro.errors.ProtocolError, e:

   118

                confnodesroot.logger.write_error("Pyro exception: " + str(e) + "\n")

   119

            except Exception, e:

   120

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

   121

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

   122

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

   123

                print errmess

   124

                confnodesroot._SetConnector(None)

   125

            return default

   126

        return catcher_func

   127

   128

    # Check connection is effective.

   129

    # lambda is for getattr of GetPLCstatus to happen inside catcher

   130

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

   131

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

   132

        return None

   133

   134

    class PyroProxyProxy(object):

   135

        """

   136

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

   137

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

   138

        """

   139

        def __init__(self):

   140

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

   141

            self.RemotePLCObjectProxyCopy = None

   142

   143

        def GetPyroProxy(self):

   144

            """

   145

            This func returns the real Pyro Proxy.

   146

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

   147

            """

   148

            return RemotePLCObjectProxy

   149

   150

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

   151

            """

   152

            confnodesroot._connector.GetPyroProxy() is used

   153

            rather than RemotePLCObjectProxy because

   154

            object is recreated meanwhile,

   155

            so we must not keep ref to it here

   156

            """

   157

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

   158

            if current_status == "Dirty":

   159

                """

   160

                Some bad libs with static symbols may polute PLC

   161

                ask runtime to suicide and come back again

   162

                """

   163

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

   164

                confnodesroot._connector.GetPyroProxy().ForceReload()

   165

                confnodesroot._Disconnect()

   166

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

   167

                sleep(0.5)

   168

                confnodesroot._Connect()

   169

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

   170

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

   171

        StartPLC = PyroCatcher(_PyroStartPLC, False)

   172

   173

        def _PyroGetTraceVariables(self):

   174

            """

   175

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

   176

            """

   177

            if self.RemotePLCObjectProxyCopy is None:

   178

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

   179

            return self.RemotePLCObjectProxyCopy.GetTraceVariables()

   180

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

   181

   182

        def _PyroGetPLCstatus(self):

   183

            return RemotePLCObjectProxy.GetPLCstatus()

   184

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

   185

   186

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

   187

            return RemotePLCObjectProxy.RemoteExec(script, **kwargs)

   188

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

   189

   190

        def __getattr__(self, attrName):

   191

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

   192

            if member is None:

   193

                def my_local_func(*args, **kwargs):

   194

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

   195

                member = PyroCatcher(my_local_func, None)

   196

                self.__dict__[attrName] = member

   197

            return member

   198

   199

    return PyroProxyProxy()