1

#!/usr/bin/env python

     2

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

     3

     4

# This file is part of Beremiz runtime.

     5

#

     6

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

     7

#

     8

# See COPYING.Runtime file for copyrights details.

     9

#

    10

# This library is free software; you can redistribute it and/or

    11

# modify it under the terms of the GNU Lesser General Public

    12

# License as published by the Free Software Foundation; either

    13

# version 2.1 of the License, or (at your option) any later version.

    14

    15

# This library is distributed in the hope that it will be useful,

    16

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

    17

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    18

# Lesser General Public License for more details.

    19

    20

# You should have received a copy of the GNU Lesser General Public

    21

# License along with this library; if not, write to the Free Software

    22

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

    23

    24

    25

from __future__ import absolute_import

    26

from __future__ import print_function

    27

import time

    28

import json

    29

import inspect

    31

from autobahn.twisted import wamp

    32

from autobahn.twisted.websocket import WampWebSocketClientFactory, connectWS

    33

from autobahn.wamp import types, auth

    34

from autobahn.wamp.serializer import MsgPackSerializer

    35

from twisted.internet.defer import inlineCallbacks

    36

from twisted.internet.protocol import ReconnectingClientFactory

    37

    38

    40

_WampSession = None

    41

_PySrv = None

    42

    43

ExposedCalls = [

    44

    "StartPLC",

    45

    "StopPLC",

    46

    "ForceReload",

    47

    "GetPLCstatus",

    48

    "NewPLC",

    49

    "MatchMD5",

    50

    "SetTraceVariablesList",

    51

    "GetTraceVariables",

    52

    "RemoteExec",

    53

    "GetLogMessage",

    54

    "ResetLogCount",

    55

]

    56

    57

ExposedProgressCalls = []

    58

    59

# Those two lists are meant to be filled by customized runtime

    60

# or User python code.

    61

    62

""" crossbar Events to register to """

    63

SubscribedEvents = []

    64

    65

""" things to do on join (callables) """

    66

DoOnJoin = []

    67

    68

    69

def GetCallee(name):

    70

    """ Get Callee or Subscriber corresponding to '.' spearated object path """

    71

    names = name.split('.')

    72

    obj = _PySrv.plcobj

    73

    while names:

    74

        obj = getattr(obj, names.pop(0))

    75

    return obj

    76

    77

def getValidOptins(options, arguments):

    78

    validOptions = {}

    79

    for key in options:

    80

        if key in arguments:

    81

            validOptions[key] = options[key]

    82

    if len(validOptions) > 0:

    83

        return validOptions

    84

    else:

    85

        return None

    86

    87

class WampSession(wamp.ApplicationSession):

    88

    def onConnect(self):

    89

        if "secret" in self.config.extra:

    90

            user = self.config.extra["ID"]

    91

            self.join(u"Automation", [u"wampcra"], user)

    92

        else:

    93

            self.join(u"Automation")

    94

    95

    def onChallenge(self, challenge):

    96

        if challenge.method == u"wampcra":

    97

            secret = self.config.extra["secret"].encode('utf8')

    98

            signature = auth.compute_wcs(secret, challenge.extra['challenge'].encode('utf8'))

    99

            return signature.decode("ascii")

   100

        else:

   101

            raise Exception("don't know how to handle authmethod {}".format(challenge.method))

   102

   103

    @inlineCallbacks

   104

    def onJoin(self, details):

   105

        global _WampSession

   106

        _WampSession = self

   107

        ID = self.config.extra["ID"]

   108

        validRegisterOptions = {}

   109

   110

        registerOptions = self.config.extra.get('registerOptions', None)

   111

        if registerOptions:

   112

            arguments = inspect.getargspec(types.RegisterOptions.__init__).args

   113

            validRegisterOptions = getValidOptins(registerOptions, arguments)

   114

            if validRegisterOptions:

   115

                registerOptions = types.RegisterOptions(**validRegisterOptions)

   116

                #print(_("Added custom register options"))

   117

   118

        for name in ExposedCalls:

   119

            yield self.register(GetCallee(name), u'.'.join((ID, name)), registerOptions)

   120

   121

        if ExposedProgressCalls:

   122

            validRegisterOptions["details_arg"] = 'details'

   123

            registerOptions = types.RegisterOptions(**validRegisterOptions)

   124

            # using progress, details argument must be added

   125

            for name in ExposedProgressCalls:

   126

                yield self.register(GetCallee(name), u'.'.join((ID, name)), registerOptions)

   127

   128

        for name in SubscribedEvents:

   129

            yield self.subscribe(GetCallee(name), unicode(name))

   130

   131

        for func in DoOnJoin:

   132

            yield func(self)

   133

   134

        print(_('WAMP session joined (%s) by:' % time.ctime()), ID)

   135

   136

    def onLeave(self, details):

   139

        _WampSession = None

   141

        print(_('WAMP session left'))

   142

   143

   144

class ReconnectingWampWebSocketClientFactory(WampWebSocketClientFactory, ReconnectingClientFactory):

   145

    def __init__(self, config, *args, **kwargs):

   147

        WampWebSocketClientFactory.__init__(self, *args, **kwargs)

   148

   149

        protocolOptions = config.extra.get('protocolOptions', None)

   150

        if protocolOptions:

   151

            arguments = inspect.getargspec(self.setProtocolOptions).args

   152

            validProtocolOptions = getValidOptins(protocolOptions, arguments)

   153

            if validProtocolOptions:

   154

                self.setProtocolOptions(**validProtocolOptions)

   155

                #print(_("Added custom protocol options"))

   157

   158

    def buildProtocol(self, addr):

   159

        self.resetDelay()

   160

        return ReconnectingClientFactory.buildProtocol(self, addr)

   161

   162

    def clientConnectionFailed(self, connector, reason):

   168

   169

    def clientConnectionLost(self, connector, reason):

   175

   176

   177

def LoadWampClientConf(wampconf):

   178

    try:

   179

        WSClientConf = json.load(open(wampconf))

   180

        return WSClientConf

   181

    except ValueError, ve:

   182

        print(_("WAMP load error: "), ve)

   183

        return None

   184

    except Exception:

   185

        return None

   186

   187

   188

def LoadWampSecret(secretfname):

   189

    try:

   190

        WSClientWampSecret = open(secretfname, 'rb').read()

   191

        return WSClientWampSecret

   192

    except ValueError, ve:

   193

        print(_("Wamp secret load error:"), ve)

   194

        return None

   195

    except Exception:

   196

        return None

   197

   198

   206

def RegisterWampClient(wampconf, secretfname):

   207

    WSClientConf = LoadWampClientConf(wampconf)

   208

   209

    if not WSClientConf:

   210

        print(_("WAMP client connection not established!"))

   216

   217

    WampSecret = LoadWampSecret(secretfname)

   218

   219

    if WampSecret is not None:

   220

        WSClientConf["secret"] = WampSecret

   221

   222

    # create a WAMP application session factory

   223

    component_config = types.ComponentConfig(

   224

        realm=WSClientConf["realm"],

   225

        extra=WSClientConf)

   226

    session_factory = wamp.ApplicationSessionFactory(

   227

        config=component_config)

   228

    session_factory.session = WampSession

   229

   230

    # create a WAMP-over-WebSocket transport client factory

   231

    transport_factory = ReconnectingWampWebSocketClientFactory(

   232

        component_config,

   233

        session_factory,

   234

        url=WSClientConf["url"],

   235

        serializers=[MsgPackSerializer()])

   236

   237

    # start the client from a Twisted endpoint

   238

    conn = connectWS(transport_factory)

   239

    print(_("WAMP client connecting to :"), WSClientConf["url"])

   246

   247

   248

def GetSession():

   250

    return _WampSession

   251

   252

   253

def SetServer(pysrv):

   254

    global _PySrv

   255

    _PySrv = pysrv