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

from twisted.python.components import registerAdapter

    38

    39

from formless import annotate, webform

    40

import formless

    41

from nevow import tags, url, static

    42

    43

mandatoryConfigItems = ["ID", "active", "realm", "url"]

    44

    45

_transportFactory = None

    46

_WampSession = None

    47

_PySrv = None

    48

WorkingDir = None

    49

    50

# Find pre-existing project WAMP config file

    51

_WampConf = None

    52

_WampSecret = None

    53

    54

ExposedCalls = [

    55

    ("StartPLC", {}),

    56

    ("StopPLC", {}),

    57

    ("ForceReload", {}),

    58

    ("GetPLCstatus", {}),

    59

    ("NewPLC", {}),

    60

    ("MatchMD5", {}),

    61

    ("SetTraceVariablesList", {}),

    62

    ("GetTraceVariables", {}),

    63

    ("RemoteExec", {}),

    64

    ("GetLogMessage", {}),

    65

    ("ResetLogCount", {})

    66

]

    67

    68

# de-activated dumb wamp config

    69

defaultWampConfig = {

    70

    "ID": "wamptest", 

    71

    "active": False, 

    72

    "realm": "Automation", 

    73

    "url": "ws://127.0.0.1:8888"

    74

}

    75

    76

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

    77

# or User python code.

    78

    79

""" crossbar Events to register to """

    80

SubscribedEvents = []

    81

    82

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

    83

DoOnJoin = []

    84

    85

lastKnownConfig = None

    86

    87

def GetCallee(name):

    88

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

    89

    names = name.split('.')

    90

    obj = _PySrv.plcobj

    91

    while names:

    92

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

    93

    return obj

    94

    95

    96

class WampSession(wamp.ApplicationSession):

    97

    def onConnect(self):

    98

        if "secret" in self.config.extra:

    99

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

   100

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

   101

        else:

   102

            self.join(u"Automation")

   103

   104

    def onChallenge(self, challenge):

   105

        if challenge.method == u"wampcra":

   106

            if "secret" in self.config.extra:

   107

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

   108

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

   109

                return signature.decode("ascii")

   110

            else:

   111

                raise Exception("no secret given for authentication")

   112

        else:

   113

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

   114

   115

    @inlineCallbacks

   116

    def onJoin(self, details):

   117

        global _WampSession

   118

        _WampSession = self

   119

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

   120

   121

        for name, kwargs in ExposedCalls:

   122

            try:

   123

                registerOptions = types.RegisterOptions(**kwargs)

   124

            except TypeError as e:

   125

                registerOptions = None

   126

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

   127

   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

        try:

   152

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

   153

            if protocolOptions:

   154

                self.setProtocolOptions(**protocolOptions)

   155

            _transportFactory = self

   156

        except Exception, e:

   157

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

   158

            _transportFactory = None

   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 CheckConfiguration(WampClientConf):

   180

    url = WampClientConf["url"]

   181

    if not IsCorrectUri(url):

   182

        raise annotate.ValidateError(

   183

            {"url":"Invalid URL: {}".format(url)},

   184

            _("WAMP confiuration error:"))

   185

   186

def GetConfiguration():

   187

    global lastKnownConfig

   188

   189

    if os.path.exists(_WampConf):

   190

        WampClientConf = json.load(open(_WampConf))

   191

    else: 

   193

   194

    for itemName in mandatoryConfigItems:

   195

        if WampClientConf.get(itemName, None) is None :

   196

            raise Exception(_("WAMP configuration error : missing '{}' parameter.").format(itemName))

   197

   198

    CheckConfiguration(WampClientConf)

   199

   200

    lastKnownConfig = WampClientConf.copy()

   201

    return WampClientConf

   202

   203

   204

def SetWampSecret(wampSecret):

   205

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

   206

        f.write(wampSecret)

   207

   208

def SetConfiguration(WampClientConf):

   209

    global lastKnownConfig

   210

   211

    CheckConfiguration(WampClientConf)

   212

   213

    lastKnownConfig = WampClientConf.copy()

   214

   215

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

   216

        json.dump(WampClientConf, f, sort_keys=True, indent=4)

   217

    if 'active' in WampClientConf and WampClientConf['active']:

   218

        if _transportFactory and _WampSession:

   219

            StopReconnectWampClient()

   220

        StartReconnectWampClient()

   221

    else:

   222

        StopReconnectWampClient()

   223

   224

    return WampClientConf

   225

   226

   227

def LoadWampSecret(secretfname):

   228

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

   229

    if len(WSClientWampSecret) == 0 :

   230

        raise Exception(_("WAMP secret empty"))

   231

    return WSClientWampSecret

   232

   233

   234

def IsCorrectUri(uri):

   235

    return re.match(r'wss?://[^\s?:#-]+(:[0-9]+)?(/[^\s]*)?$', uri) is not None

   236

   237

   238

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

   239

    global _WampConf, _WampSecret

   240

    _WampConfDefault = os.path.join(WorkingDir, "wampconf.json")

   241

    _WampSecretDefault = os.path.join(WorkingDir, "wamp.secret")

   242

   263

    else :

   265

        _WampSecret = _WampSecretDefault

   266

   267

    if not WampClientConf["active"]:

   268

        print(_("WAMP deactivated in configuration"))

   269

        return

   270

   271

    # create a WAMP application session factory

   272

    component_config = types.ComponentConfig(

   273

        realm=WampClientConf["realm"],

   274

        extra=WampClientConf)

   275

    session_factory = wamp.ApplicationSessionFactory(

   276

        config=component_config)

   277

    session_factory.session = WampSession

   278

   279

    # create a WAMP-over-WebSocket transport client factory

   280

    ReconnectingWampWebSocketClientFactory(

   281

        component_config,

   282

        session_factory,

   283

        url=WampClientConf["url"],

   284

        serializers=[MsgPackSerializer()])

   285

   286

    # start the client from a Twisted endpoint

   287

    if _transportFactory:

   288

        conn = connectWS(_transportFactory)

   289

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

   290

        return True

   291

    else:

   292

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

   293

        return False

   294

   295

   296

def StopReconnectWampClient():

   297

    if _transportFactory is not None :

   298

        _transportFactory.stopTrying()

   299

    if _WampSession is not None :

   300

        _WampSession.leave()

   301

   302

   303

def StartReconnectWampClient():

   304

    if _WampSession:

   305

        # do reconnect

   306

        _WampSession.disconnect()

   307

        return True

   308

    else:

   309

        # do connect

   310

        RegisterWampClient()

   311

        return True

   312

   313

   314

def GetSession():

   315

    return _WampSession

   316

   317

def getWampStatus():

   318

    if _transportFactory is not None :

   319

        if _WampSession is not None :

   320

            if _WampSession.is_attached() :

   321

                return "Attached"

   322

            return "Established"

   323

        return "Connecting"

   324

    return "Disconnected"

   325

   326

   327

def SetServer(pysrv):

   328

    _PySrv = pysrv

   329

   330

   331

#### WEB CONFIGURATION INTERFACE ####

   332

WAMP_SECRET_URL = "secret"

   333

webExposedConfigItems = ['active', 'url', 'ID']

   334

   335

def wampConfigDefault(ctx,argument):

   336

    if lastKnownConfig is not None :

   337

        return lastKnownConfig.get(argument.name, None)

   338

   339

def wampConfig(**kwargs):

   340

    secretfile_field = kwargs["secretfile"]

   341

    if secretfile_field is not None:

   346

   347

    newConfig = lastKnownConfig.copy()

   348

    for argname in webExposedConfigItems:

   352

   353

    SetConfiguration(newConfig)

   354

   355

class FileUploadDownload(annotate.FileUpload):

   356

    pass

   357

   358

   359

class FileUploadDownloadRenderer(webform.FileUploadRenderer):

   360

    def input(self, context, slot, data, name, value):

   361

        slot[_("Upload:")]

   362

        slot = webform.FileUploadRenderer.input(self, context, slot, data, name, value)

   363

        download_url = data.typedValue.getAttribute('download_url')

   364

        return slot[tags.a(href=download_url)[_("Download")]]

   365

   366

registerAdapter(FileUploadDownloadRenderer, FileUploadDownload, formless.iformless.ITypedRenderer)

   367

   368

def getDownloadUrl(ctx, argument):

   369

    if lastKnownConfig is not None :

   370

        return url.URL.fromContext(ctx).\

   371

            child(WAMP_SECRET_URL).\

   372

            child(lastKnownConfig["ID"]+".secret")

   373

   374

webFormInterface = [

   375

    ("status",

   376

       annotate.String(label=_("Current status"),

   377

                       immutable = True,

   378

                       default = lambda *k:getWampStatus())),

   379

    ("ID",

   380

       annotate.String(label=_("ID"),

   381

                       default = wampConfigDefault)),

   382

    ("secretfile",

   383

       FileUploadDownload(

   384

           label = _("File containing secret for that ID"),

   385

           download_url = getDownloadUrl,

   386

       )),

   387

    ("active",

   388

       annotate.Boolean(label=_("Enable WAMP connection"),

   389

                        default=wampConfigDefault)),

   390

    ("url",

   391

       annotate.String(label=_("WAMP Server URL"),

   392

                       default=wampConfigDefault))]

   393

   394

   395

def deliverWampSecret(ctx, segments):

   396

    filename = segments[1].decode('utf-8')

   402

    secret = LoadWampSecret(_WampSecret)

   403

    return static.Data(secret, 'application/octet-stream'),()

   404