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

    30

import inspect

    31

import re

    32

from autobahn.twisted import wamp

    33

from autobahn.twisted.websocket import WampWebSocketClientFactory, connectWS

    34

from autobahn.wamp import types, auth

    35

from autobahn.wamp.serializer import MsgPackSerializer

    36

from twisted.internet.defer import inlineCallbacks

    37

from twisted.internet.protocol import ReconnectingClientFactory

    38

    39

    40

_transportFactory = None

    41

_WampSession = None

    42

_PySrv = None

    43

_WampConf = None

    44

_WampSecret = None

    45

    46

ExposedCalls = [

    47

    "StartPLC",

    48

    "StopPLC",

    49

    "ForceReload",

    50

    "GetPLCstatus",

    51

    "NewPLC",

    52

    "MatchMD5",

    53

    "SetTraceVariablesList",

    54

    "GetTraceVariables",

    55

    "RemoteExec",

    56

    "GetLogMessage",

    57

    "ResetLogCount",

    58

]

    59

    60

ExposedProgressCalls = []

    61

    62

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

    63

# or User python code.

    64

    65

""" crossbar Events to register to """

    66

SubscribedEvents = []

    67

    68

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

    69

DoOnJoin = []

    70

    71

    72

def GetCallee(name):

    73

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

    74

    names = name.split('.')

    75

    obj = _PySrv.plcobj

    76

    while names:

    77

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

    78

    return obj

    79

    80

def getValidOptins(options, arguments):

    81

    validOptions = {}

    82

    for key in options:

    83

        if key in arguments:

    84

            validOptions[key] = options[key]

    85

    if len(validOptions) > 0:

    86

        return validOptions

    87

    else:

    88

        return None

    89

    90

class WampSession(wamp.ApplicationSession):

    91

    def onConnect(self):

    92

        if "secret" in self.config.extra:

    93

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

    94

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

    95

        else:

    96

            self.join(u"Automation")

    97

    98

    def onChallenge(self, challenge):

    99

        if challenge.method == u"wampcra":

   100

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

   101

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

   102

            return signature.decode("ascii")

   103

        else:

   104

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

   105

   106

    @inlineCallbacks

   107

    def onJoin(self, details):

   108

        global _WampSession

   109

        _WampSession = self

   110

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

   111

        validRegisterOptions = {}

   112

   113

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

   114

        if registerOptions:

   115

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

   116

            validRegisterOptions = getValidOptins(registerOptions, arguments)

   117

            if validRegisterOptions:

   118

                registerOptions = types.RegisterOptions(**validRegisterOptions)

   119

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

   120

   121

        for name in ExposedCalls:

   122

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

   123

   124

        if ExposedProgressCalls:

   125

            validRegisterOptions["details_arg"] = 'details'

   126

            registerOptions = types.RegisterOptions(**validRegisterOptions)

   127

            # using progress, details argument must be added

   128

            for name in ExposedProgressCalls:

   129

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

   130

   131

        for name in SubscribedEvents:

   132

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

   133

   134

        for func in DoOnJoin:

   135

            yield func(self)

   136

   137

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

   138

   139

    def onLeave(self, details):

   140

        global _WampSession, _transportFactory

   141

        super(WampSession, self).onLeave(details)

   142

        _WampSession = None

   143

        _transportFactory = None

   144

        print(_('WAMP session left'))

   145

   146

   147

class ReconnectingWampWebSocketClientFactory(WampWebSocketClientFactory, ReconnectingClientFactory):

   148

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

   149

        global _transportFactory

   150

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

   151

   152

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

   153

        if protocolOptions:

   154

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

   155

            validProtocolOptions = getValidOptins(protocolOptions, arguments)

   156

            if validProtocolOptions:

   157

                self.setProtocolOptions(**validProtocolOptions)

   158

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

   159

        _transportFactory = self

   160

   161

    def buildProtocol(self, addr):

   162

        self.resetDelay()

   163

        return ReconnectingClientFactory.buildProtocol(self, addr)

   164

   165

    def clientConnectionFailed(self, connector, reason):

   166

        if self.continueTrying:

   167

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

   168

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

   169

        else:

   170

            del connector

   171

   172

    def clientConnectionLost(self, connector, reason):

   173

        if self.continueTrying:

   174

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

   175

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

   176

        else:

   177

            del connector

   178

   179

   180

def LoadWampClientConf(wampconf):

   181

    try:

   182

        WSClientConf = json.load(open(wampconf))

   183

        return WSClientConf

   184

    except ValueError, ve:

   185

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

   186

        return None

   187

    except Exception:

   188

        return None

   189

   190

def SaveWampClientConf(wampconf, url, active):

   191

    try:

   192

        WSClientConf = LoadWampClientConf(wampconf)

   193

        change = False

   194

        if url:

   195

            oldUrl = WSClientConf.get('url', None)

   196

            if oldUrl != url:

   197

                WSClientConf['url'] = url

   198

                change = True

   199

   200

        oldActive = WSClientConf.get('active', False)

   201

        if oldActive != active:

   202

            WSClientConf['active'] = active

   203

            change = True

   204

   205

        if change:

   206

            with open(os.path.realpath(wampconf), 'w') as f:

   207

                json.dump(WSClientConf, f)

   208

   209

        return WSClientConf

   210

    except ValueError, ve:

   215

        return None

   216

   217

def LoadWampSecret(secretfname):

   218

    try:

   219

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

   220

        return WSClientWampSecret

   221

    except ValueError, ve:

   222

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

   223

        return None

   224

    except Exception:

   225

        return None

   226

   227

   228

def IsCorrectUri(uri):

   229

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

   230

        return True

   231

    else:

   232

        return False

   233

   234

   235

def RegisterWampClient(wampconf = None, secretfname = None):

   236

    if wampconf:

   237

        WSClientConf = LoadWampClientConf(wampconf)

   238

    else:

   239

        WSClientConf = LoadWampClientConf(_WampConf)

   240

   241

    if not WSClientConf:

   242

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

   243

        return False

   244

   245

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

   246

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

   247

        return False

   248

   249

    if secretfname:

   250

        WampSecret = LoadWampSecret(secretfname)

   251

    else:

   252

        WampSecret = LoadWampSecret(_WampSecret)

   253

   254

    if WampSecret is not None:

   255

        WSClientConf["secret"] = WampSecret

   256

   257

    # create a WAMP application session factory

   258

    component_config = types.ComponentConfig(

   259

        realm=WSClientConf["realm"],

   260

        extra=WSClientConf)

   261

    session_factory = wamp.ApplicationSessionFactory(

   262

        config=component_config)

   263

    session_factory.session = WampSession

   264

   265

    # create a WAMP-over-WebSocket transport client factory

   266

    transport_factory = ReconnectingWampWebSocketClientFactory(

   267

        component_config,

   268

        session_factory,

   269

        url=WSClientConf["url"],

   270

        serializers=[MsgPackSerializer()])

   271

   272

    # start the client from a Twisted endpoint

   273

    conn = connectWS(transport_factory)

   274

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

   275

    return True # conn

   276

   284

        _WampSession.disconnect()

   285

        return True

   288

        RegisterWampClient()

   289

        return True

   304

   305

def GetSession():

   306

    return _WampSession

   307

   308

def StatusWampClient():

   309

    return _WampSession and _WampSession.is_attached()

   310

   311

def SetServer(pysrv, wampconf = None, wampsecret = None):

   312

    global _PySrv, _WampConf, _WampSecret

   313

    _PySrv = pysrv

   314

    _WampConf = wampconf

   315

    _WampSecret = wampsecret