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 sys

    29

import traceback

    30

import atexit

    31

from threading import Thread, Event

    32

    33

from twisted.internet import reactor, threads

    34

from autobahn.twisted import wamp

    35

from autobahn.twisted.websocket import WampWebSocketClientFactory, connectWS

    36

from autobahn.wamp import types

    37

from autobahn.wamp.exception import TransportLost

    38

from autobahn.wamp.serializer import MsgPackSerializer

    39

    40

    41

_WampSession = None

    42

_WampConnection = None

    43

_WampSessionEvent = Event()

    44

    45

    46

class WampSession(wamp.ApplicationSession):

    47

    def onJoin(self, details):

    48

        global _WampSession

    49

        _WampSession = self

    50

        _WampSessionEvent.set()

    51

        print('WAMP session joined for :', self.config.extra["ID"])

    52

    53

    def onLeave(self, details):

    54

        global _WampSession

    55

        _WampSessionEvent.clear()

    56

        _WampSession = None

    57

        print('WAMP session left')

    58

    59

    60

PLCObjDefaults = {

    61

    "StartPLC":          False,

    62

    "GetTraceVariables": ("Broken", None),

    63

    "GetPLCstatus":      ("Broken", None),

    64

    "RemoteExec":        (-1, "RemoteExec script failed!")

    65

}

    66

    67

    68

def WAMP_connector_factory(uri, confnodesroot):

    69

    """

    70

    WAMP://127.0.0.1:12345/path#realm#ID

    71

    WAMPS://127.0.0.1:12345/path#realm#ID

    72

    """

    73

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

    74

    urlpath, realm, ID = location.split('#')

    75

    urlprefix = {"WAMP":  "ws",

    76

                 "WAMPS": "wss"}[servicetype]

    77

    url = urlprefix+"://"+urlpath

    78

    79

    def RegisterWampClient():

    80

    81

        # start logging to console

    82

        # log.startLogging(sys.stdout)

    83

    84

        # create a WAMP application session factory

    85

        component_config = types.ComponentConfig(

    86

            realm=unicode(realm),

    87

            extra={"ID": ID})

    88

        session_factory = wamp.ApplicationSessionFactory(

    89

            config=component_config)

    90

        session_factory.session = WampSession

    91

    92

        # create a WAMP-over-WebSocket transport client factory

    93

        transport_factory = WampWebSocketClientFactory(

    94

            session_factory,

    95

            url=url,

    96

            serializers=[MsgPackSerializer()])

    97

    98

        # start the client from a Twisted endpoint

    99

        conn = connectWS(transport_factory)

   100

        confnodesroot.logger.write(_("WAMP connecting to URL : %s\n") % url)

   101

        return conn

   102

   103

    AddToDoBeforeQuit = confnodesroot.AppFrame.AddToDoBeforeQuit

   104

   105

    def ThreadProc():

   106

        global _WampConnection

   107

        _WampConnection = RegisterWampClient()

   108

        AddToDoBeforeQuit(reactor.stop)

   109

        reactor.run(installSignalHandlers=False)

   110

   111

    def WampSessionProcMapper(funcname):

   112

        wampfuncname = unicode('.'.join((ID, funcname)))

   113

   114

        def catcher_func(*args, **kwargs):

   115

            if _WampSession is not None:

   116

                try:

   117

                    return threads.blockingCallFromThread(

   118

                        reactor, _WampSession.call, wampfuncname,

   119

                        *args, **kwargs)

   120

                except TransportLost:

   121

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

   122

                    confnodesroot._SetConnector(None)

   123

                except Exception:

   124

                    errmess = traceback.format_exc()

   125

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

   126

                    print(errmess)

   127

                    # confnodesroot._SetConnector(None)

   128

            return PLCObjDefaults.get(funcname)

   129

        return catcher_func

   130

   131

    class WampPLCObjectProxy(object):

   132

        def __init__(self):

   133

            global _WampConnection

   134

            if not reactor.running:

   135

                Thread(target=ThreadProc).start()

   136

            else:

   137

                _WampConnection = threads.blockingCallFromThread(

   138

                    reactor, RegisterWampClient)

   139

            if not _WampSessionEvent.wait(5):

   140

                _WampConnection.stopConnecting()

   141

                raise Exception(_("WAMP connection timeout"))

   142

   143

        def __del__(self):

   144

            _WampConnection.disconnect()

   145

            #

   146

            # reactor.stop()

   147

   148

        def __getattr__(self, attrName):

   149

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

   150

            if member is None:

   151

                member = WampSessionProcMapper(attrName)

   152

                self.__dict__[attrName] = member

   153

            return member

   154

   155

    # Try to get the proxy object

   156

    try:

   157

        return WampPLCObjectProxy()

   158

    except Exception:

   159

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

   160

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

   161

        return None