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 os

    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

    41

_transportFactory = None

    42

_WampSession = None

    43

_PySrv = None

    44

_WampConf = None

    45

_WampSecret = None

    46

    47

ExposedCalls = [

    48

    ("StartPLC", {}),

    49

    ("StopPLC", {}),

    50

    ("ForceReload", {}),

    51

    ("GetPLCstatus", {}),

    52

    ("NewPLC", {}),

    53

    ("MatchMD5", {}),

    54

    ("SetTraceVariablesList", {}),

    55

    ("GetTraceVariables", {}),

    56

    ("RemoteExec", {}),

    57

    ("GetLogMessage", {}),

    58

    ("ResetLogCount", {})

    59

]

    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

    80

class WampSession(wamp.ApplicationSession):

    81

    def onConnect(self):

    82

        if "secret" in self.config.extra:

    83

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

    84

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

    85

        else:

    86

            self.join(u"Automation")

    87

    88

    def onChallenge(self, challenge):

    89

        if challenge.method == u"wampcra":

    90

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

    91

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

    92

            return signature.decode("ascii")

    93

        else:

    94

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

    95

    96

    @inlineCallbacks

    97

    def onJoin(self, details):

    98

        global _WampSession

    99

        _WampSession = self

   100

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

   101

   102

        for name, kwargs in ExposedCalls:

   103

            try:

   104

                registerOptions = types.RegisterOptions(**kwargs)

   105

            except TypeError as e:

   106

                registerOptions = None

   107

                print(_("TypeError register option: {}".format(e)))

   108

   109

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

   110

   111

        for name in SubscribedEvents:

   112

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

   113

   114

        for func in DoOnJoin:

   115

            yield func(self)

   116

   117

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

   118

   119

    def onLeave(self, details):

   120

        global _WampSession, _transportFactory

   121

        super(WampSession, self).onLeave(details)

   122

        _WampSession = None

   123

        _transportFactory = None

   124

        print(_('WAMP session left'))

   125

   126

   127

class ReconnectingWampWebSocketClientFactory(WampWebSocketClientFactory, ReconnectingClientFactory):

   128

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

   129

        global _transportFactory

   130

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

   131

   132

        try:

   133

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

   134

            if protocolOptions:

   135

                self.setProtocolOptions(**protocolOptions)

   136

            _transportFactory = self

   137

        except Exception, e:

   138

            print(_("Custom protocol options failed :"), e)

   139

            _transportFactory = None

   140

   141

    def buildProtocol(self, addr):

   142

        self.resetDelay()

   143

        return ReconnectingClientFactory.buildProtocol(self, addr)

   144

   145

    def clientConnectionFailed(self, connector, reason):

   146

        if self.continueTrying:

   147

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

   148

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

   149

        else:

   150

            del connector

   151

   152

    def clientConnectionLost(self, connector, reason):

   153

        if self.continueTrying:

   154

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

   155

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

   156

        else:

   157

            del connector

   158

   159

   170

    try:

   175

                StopReconnectWampClient()

   179

   180

        return WSClientConf

   181

    except ValueError, ve:

   182

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

   183

        return None

   184

    except Exception, e:

   185

        print(_("WAMP save error: "), e)

   186

        return None

   187

   189

def LoadWampSecret(secretfname):

   190

    try:

   191

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

   192

        return WSClientWampSecret

   193

    except ValueError, ve:

   194

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

   195

        return None

   196

    except Exception:

   197

        return None

   198

   199

   200

def IsCorrectUri(uri):

   201

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

   202

        return True

   203

    else:

   204

        return False

   205

   206

   211

    if wampconf:

   212

        _WampConf = wampconf

   215

   216

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

   224

   225

    if WampSecret is not None:

   226

        WSClientConf["secret"] = WampSecret

   227

   228

    # create a WAMP application session factory

   229

    component_config = types.ComponentConfig(

   230

        realm=WSClientConf["realm"],

   231

        extra=WSClientConf)

   232

    session_factory = wamp.ApplicationSessionFactory(

   233

        config=component_config)

   234

    session_factory.session = WampSession

   235

   236

    # create a WAMP-over-WebSocket transport client factory

   237

    ReconnectingWampWebSocketClientFactory(

   238

        component_config,

   239

        session_factory,

   240

        url=WSClientConf["url"],

   241

        serializers=[MsgPackSerializer()])

   242

   243

    # start the client from a Twisted endpoint

   244

    if _transportFactory:

   245

        conn = connectWS(_transportFactory)

   246

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

   247

        return True

   248

    else:

   249

        print(_("WAMP client can not connect to :"), WSClientConf["url"])

   250

        return False

   251

   252

   253

def StopReconnectWampClient():

   254

    _transportFactory.stopTrying()

   255

    return _WampSession.leave()

   256

   257

   258

def StartReconnectWampClient():

   259

    if _WampSession:

   260

        # do reconnect

   261

        _WampSession.disconnect()

   262

        return True

   263

    else:

   264

        # do connect

   265

        RegisterWampClient()

   266

        return True

   267

   268

   269

def GetSession():

   270

    return _WampSession

   271

   272

   273

def StatusWampClient():

   274

    return _WampSession and _WampSession.is_attached()

   275

   276

   278

    _PySrv = pysrv