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

    30

import re

    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

    39

_transportFactory = None

    40

_WampSession = None

    41

_PySrv = None

    44

    45

ExposedCalls = [

    46

    "StartPLC",

    47

    "StopPLC",

    48

    "ForceReload",

    49

    "GetPLCstatus",

    50

    "NewPLC",

    51

    "MatchMD5",

    52

    "SetTraceVariablesList",

    53

    "GetTraceVariables",

    54

    "RemoteExec",

    55

    "GetLogMessage",

    56

    "ResetLogCount",

    57

]

    58

    59

ExposedProgressCalls = []

    60

    61

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

    62

# or User python code.

    63

    64

""" crossbar Events to register to """

    65

SubscribedEvents = []

    66

    67

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

    68

DoOnJoin = []

    69

    70

    71

def GetCallee(name):

    72

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

    73

    names = name.split('.')

    74

    obj = _PySrv.plcobj

    75

    while names:

    76

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

    77

    return obj

    78

    79

def getValidOptins(options, arguments):

    80

    validOptions = {}

    81

    for key in options:

    82

        if key in arguments:

    83

            validOptions[key] = options[key]

    84

    if len(validOptions) > 0:

    85

        return validOptions

    86

    else:

    87

        return None

    88

    89

class WampSession(wamp.ApplicationSession):

    90

    def onConnect(self):

    91

        if "secret" in self.config.extra:

    92

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

    93

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

    94

        else:

    95

            self.join(u"Automation")

    96

    97

    def onChallenge(self, challenge):

    98

        if challenge.method == u"wampcra":

    99

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

   100

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

   101

            return signature.decode("ascii")

   102

        else:

   103

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

   104

   105

    @inlineCallbacks

   106

    def onJoin(self, details):

   107

        global _WampSession

   108

        _WampSession = self

   109

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

   110

        validRegisterOptions = {}

   111

   112

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

   113

        if registerOptions:

   114

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

   115

            validRegisterOptions = getValidOptins(registerOptions, arguments)

   116

            if validRegisterOptions:

   117

                registerOptions = types.RegisterOptions(**validRegisterOptions)

   118

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

   119

   120

        for name in ExposedCalls:

   121

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

   122

   123

        if ExposedProgressCalls:

   124

            validRegisterOptions["details_arg"] = 'details'

   125

            registerOptions = types.RegisterOptions(**validRegisterOptions)

   126

            # using progress, details argument must be added

   127

            for name in ExposedProgressCalls:

   128

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

   129

   130

        for name in SubscribedEvents:

   131

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

   132

   133

        for func in DoOnJoin:

   134

            yield func(self)

   135

   136

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

   137

   138

    def onLeave(self, details):

   139

        global _WampSession, _transportFactory

   140

        super(WampSession, self).onLeave(details)

   141

        _WampSession = None

   142

        _transportFactory = None

   143

        print(_('WAMP session left'))

   144

   145

   146

class ReconnectingWampWebSocketClientFactory(WampWebSocketClientFactory, ReconnectingClientFactory):

   147

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

   148

        global _transportFactory

   149

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

   150

   151

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

   152

        if protocolOptions:

   153

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

   154

            validProtocolOptions = getValidOptins(protocolOptions, arguments)

   155

            if validProtocolOptions:

   156

                self.setProtocolOptions(**validProtocolOptions)

   157

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

   158

        _transportFactory = self

   159

   160

    def buildProtocol(self, addr):

   161

        self.resetDelay()

   162

        return ReconnectingClientFactory.buildProtocol(self, addr)

   163

   164

    def clientConnectionFailed(self, connector, reason):

   165

        if self.continueTrying:

   166

            print(_("WAMP Client connection failed (%s) .. retrying .." % time.ctime()))

   167

            super(ReconnectingWampWebSocketClientFactory, self).clientConnectionFailed(connector, reason)

   168

        else:

   169

            del connector

   170

   171

    def clientConnectionLost(self, connector, reason):

   172

        if self.continueTrying:

   173

            print(_("WAMP Client connection lost (%s) .. retrying .." % time.ctime()))

   174

            super(ReconnectingWampWebSocketClientFactory, self).clientConnectionFailed(connector, reason)

   175

        else:

   176

            del connector

   177

   178

   179

def LoadWampClientConf(wampconf):

   180

    try:

   181

        WSClientConf = json.load(open(wampconf))

   182

        return WSClientConf

   183

    except ValueError, ve:

   184

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

   185

        return None

   186

    except Exception:

   187

        return None

   188

   214

   215

def LoadWampSecret(secretfname):

   216

    try:

   217

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

   218

        return WSClientWampSecret

   219

    except ValueError, ve:

   220

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

   221

        return None

   222

    except Exception:

   223

        return None

   224

   225

   226

def IsCorrectUri(uri):

   227

    if re.match(r'w{1}s{1,2}:{1}/{2}.+:{1}[0-9]+/{1}.+', uri):

   228

        return True

   229

    else:

   230

        return False

   231

   232

   238

   239

    if not WSClientConf:

   240

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

   241

        return False

   242

   243

    if not IsCorrectUri(WSClientConf["url"]):

   244

        print(_("WAMP url {} is not correct!".format(WSClientConf["url"])))

   245

        return False

   246

   251

   252

    if WampSecret is not None:

   253

        WSClientConf["secret"] = WampSecret

   254

   255

    # create a WAMP application session factory

   256

    component_config = types.ComponentConfig(

   257

        realm=WSClientConf["realm"],

   258

        extra=WSClientConf)

   259

    session_factory = wamp.ApplicationSessionFactory(

   260

        config=component_config)

   261

    session_factory.session = WampSession

   262

   263

    # create a WAMP-over-WebSocket transport client factory

   264

    transport_factory = ReconnectingWampWebSocketClientFactory(

   265

        component_config,

   266

        session_factory,

   267

        url=WSClientConf["url"],

   268

        serializers=[MsgPackSerializer()])

   269

   270

    # start the client from a Twisted endpoint

   271

    conn = connectWS(transport_factory)

   272

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

   273

    return True # conn

   274

   275

   293

   294

def GetSession():

   295

    return _WampSession

   296

   302

    _PySrv = pysrv