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 six import text_type as text

    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.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

from runtime import GetPLCObjectSingleton

    43

    44

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

    45

    46

_transportFactory = None

    47

_WampSession = None

    48

_PySrv = None

    49

WorkingDir = None

    50

    51

# Find pre-existing project WAMP config file

    52

_WampConf = None

    53

_WampSecret = None

    54

    55

ExposedCalls = [

    56

    ("StartPLC", {}),

    57

    ("StopPLC", {}),

    58

    ("GetPLCstatus", {}),

    59

    ("GetPLCID", {}),

    60

    ("SeedBlob", {}),

    61

    ("AppendChunkToBlob", {}),

    62

    ("PurgeBlobs", {}),

    63

    ("NewPLC", {}),

    64

    ("RepairPLC", {}),

    65

    ("MatchMD5", {}),

    66

    ("SetTraceVariablesList", {}),

    67

    ("GetTraceVariables", {}),

    68

    ("RemoteExec", {}),

    69

    ("GetLogMessage", {}),

    70

    ("ResetLogCount", {})

    71

]

    72

    73

# de-activated dumb wamp config

    74

defaultWampConfig = {

    75

    "ID": "wamptest",

    76

    "active": False,

    77

    "realm": "Automation",

    78

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

    79

}

    80

    81

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

    82

# or User python code.

    83

    84

""" crossbar Events to register to """

    85

SubscribedEvents = []

    86

    87

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

    88

DoOnJoin = []

    89

    90

lastKnownConfig = None

    91

    92

    93

def GetCallee(name):

    94

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

    95

    names = name.split('.')

    96

    obj = GetPLCObjectSingleton()

    97

    while names:

    98

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

    99

    return obj

   100

   101

   102

class WampSession(wamp.ApplicationSession):

   103

   104

    def onConnect(self):

   105

        if "secret" in self.config.extra:

   106

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

   107

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

   108

        else:

   109

            self.join(u"Automation")

   110

   111

    def onChallenge(self, challenge):

   112

        if challenge.method == u"wampcra":

   113

            if "secret" in self.config.extra:

   114

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

   115

                signature = auth.compute_wcs(

   116

                    secret, challenge.extra['challenge'].encode('utf8'))

   117

                return signature.decode("ascii")

   118

            else:

   119

                raise Exception("no secret given for authentication")

   120

        else:

   121

            raise Exception(

   122

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

   123

   124

    def onJoin(self, details):

   125

        global _WampSession

   126

        _WampSession = self

   127

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

   128

   129

        for name, kwargs in ExposedCalls:

   130

            try:

   131

                registerOptions = types.RegisterOptions(**kwargs)

   132

            except TypeError as e:

   133

                registerOptions = None

   134

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

   135

   136

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

   137

   138

        for name in SubscribedEvents:

   139

            self.subscribe(GetCallee(name), text(name))

   140

   141

        for func in DoOnJoin:

   142

            func(self)

   143

   144

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

   145

   146

    def onLeave(self, details):

   147

        global _WampSession, _transportFactory

   148

        super(WampSession, self).onLeave(details)

   149

        _WampSession = None

   150

        _transportFactory = None

   151

        print(_('WAMP session left'))

   152

   153

    def publishWithOwnID(self, eventID, value):

   154

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

   155

        self.publish(text(ID+'.'+eventID), value)

   156

   157

   158

class ReconnectingWampWebSocketClientFactory(WampWebSocketClientFactory, ReconnectingClientFactory):

   159

   160

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

   161

        global _transportFactory

   162

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

   163

   164

        try:

   173

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

   174

            if protocolOptions:

   175

                self.setProtocolOptions(**protocolOptions)

   176

            _transportFactory = self

   177

        except Exception as e:

   178

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

   179

            _transportFactory = None

   180

   185

    def buildProtocol(self, addr):

   186

        self.resetDelay()

   187

        return ReconnectingClientFactory.buildProtocol(self, addr)

   188

   189

    def clientConnectionFailed(self, connector, reason):

   190

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

   191

              time.ctime())

   192

        super(ReconnectingWampWebSocketClientFactory,

   193

              self).clientConnectionFailed(connector, reason)

   194

   195

    def clientConnectionLost(self, connector, reason):

   196

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

   197

              time.ctime())

   198

        super(ReconnectingWampWebSocketClientFactory,

   199

              self).clientConnectionFailed(connector, reason)

   200

   201

   202

def CheckConfiguration(WampClientConf):

   203

    url = WampClientConf["url"]

   204

    if not IsCorrectUri(url):

   205

        raise annotate.ValidateError(

   206

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

   207

            _("WAMP configuration error:"))

   208

   212

   213

def GetConfiguration():

   214

    global lastKnownConfig

   215

   216

    WampClientConf = None

   217

   218

    if os.path.exists(_WampConf):

   219

        try: 

   220

            WampClientConf = json.load(open(_WampConf))

   222

        except ValueError:

   223

            pass

   224

   225

    if WampClientConf is None:

   226

        WampClientConf = defaultWampConfig.copy()

   227

   228

    for itemName in mandatoryConfigItems:

   229

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

   230

            raise Exception(

   231

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

   232

   233

    CheckConfiguration(WampClientConf)

   234

   235

    lastKnownConfig = WampClientConf.copy()

   236

    return WampClientConf

   237

   238

   239

def SetWampSecret(wampSecret):

   240

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

   241

        f.write(wampSecret)

   242

   243

   244

def SetConfiguration(WampClientConf):

   245

    global lastKnownConfig

   246

   247

    CheckConfiguration(WampClientConf)

   248

   249

    lastKnownConfig = WampClientConf.copy()

   250

   251

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

   252

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

   253

    StopReconnectWampClient()

   254

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

   255

        StartReconnectWampClient()

   256

   257

    return WampClientConf

   258

   259

   260

def LoadWampSecret(secretfname):

   261

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

   262

    if len(WSClientWampSecret) == 0:

   263

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

   264

    return WSClientWampSecret

   265

   266

   267

def IsCorrectUri(uri):

   268

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

   269

   270

   271

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

   272

    global _WampConf, _WampSecret

   273

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

   274

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

   275

   276

    # set config file path only if not already set

   277

    if _WampConf is None:

   278

        # default project's wampconf has precedance over commandline given

   279

        if os.path.exists(_WampConfDefault) or wampconf is None:

   280

            _WampConf = _WampConfDefault

   281

        else:

   282

            _WampConf = wampconf

   283

   284

    WampClientConf = GetConfiguration()

   285

   286

    # set secret file path only if not already set

   287

    if _WampSecret is None:

   288

        # default project's wamp secret also

   289

        # has precedance over commandline given

   290

        if os.path.exists(_WampSecretDefault):

   291

            _WampSecret = _WampSecretDefault

   292

        else:

   293

            _WampSecret = wampsecret

   294

   295

    if _WampSecret is not None:

   296

        WampClientConf["secret"] = LoadWampSecret(_WampSecret)

   297

    else:

   298

        print(_("WAMP authentication has no secret configured"))

   299

        _WampSecret = _WampSecretDefault

   300

   301

    if not WampClientConf["active"]:

   302

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

   303

        return

   304

   305

    # create a WAMP application session factory

   306

    component_config = types.ComponentConfig(

   307

        realm=WampClientConf["realm"],

   308

        extra=WampClientConf)

   309

    session_factory = wamp.ApplicationSessionFactory(

   310

        config=component_config)

   311

    session_factory.session = WampSession

   312

   313

    # create a WAMP-over-WebSocket transport client factory

   314

    ReconnectingWampWebSocketClientFactory(

   315

        component_config,

   316

        session_factory,

   317

        url=WampClientConf["url"],

   318

        serializers=[MsgPackSerializer()])

   319

   320

    # start the client from a Twisted endpoint

   321

    if _transportFactory:

   322

        connectWS(_transportFactory)

   323

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

   324

        return True

   325

    else:

   326

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

   327

        return False

   328

   329

   330

def StopReconnectWampClient():

   331

    if _transportFactory is not None:

   332

        _transportFactory.stopTrying()

   333

    if _WampSession is not None:

   334

        _WampSession.leave()

   335

   336

   337

def StartReconnectWampClient():

   338

    if _WampSession:

   342

        _WampSession.disconnect()

   343

        return True

   344

    else:

   345

        # do connect

   346

        RegisterWampClient()

   347

        return True

   348

   349

   350

def GetSession():

   351

    return _WampSession

   352

   353

   354

def getWampStatus():

   355

    if _transportFactory is not None:

   356

        if _WampSession is not None:

   357

            if _WampSession.is_attached():

   358

                return "Attached"

   359

            return "Established"

   360

        return "Connecting"

   361

    return "Disconnected"

   362

   363

   364

def SetServer(pysrv):

   365

    global _PySrv

   366

    _PySrv = pysrv

   367

   368

   369

def PublishEvent(eventID, value):

   370

    if getWampStatus() == "Attached":

   371

        _WampSession.publish(text(eventID), value)

   372

   373

   374

def PublishEventWithOwnID(eventID, value):

   375

    if getWampStatus() == "Attached":

   376

        _WampSession.publishWithOwnID(text(eventID), value)

   377

   378

   379

# WEB CONFIGURATION INTERFACE

   380

WAMP_SECRET_URL = "secret"

   381

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

   382

   383

   384

def wampConfigDefault(ctx, argument):

   385

    if lastKnownConfig is not None:

   395

   396

   397

def wampConfig(**kwargs):

   398

    secretfile_field = kwargs["secretfile"]

   399

    if secretfile_field is not None:

   400

        secretfile = getattr(secretfile_field, "file", None)

   401

        if secretfile is not None:

   402

            secret = secretfile_field.file.read()

   403

            SetWampSecret(secret)

   404

   405

    newConfig = lastKnownConfig.copy()

   406

    for argname in webExposedConfigItems:

   411

        arg = kwargs.get(argname, None)

   412

        if arg is not None:

   417

   418

    SetConfiguration(newConfig)

   419

   420

   421

class FileUploadDownload(annotate.FileUpload):

   422

    pass

   423

   424

   425

class FileUploadDownloadRenderer(webform.FileUploadRenderer):

   426

   427

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

   428

        # pylint: disable=expression-not-assigned

   429

        slot[_("Upload:")]

   430

        slot = webform.FileUploadRenderer.input(

   431

            self, context, slot, data, name, value)

   432

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

   433

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

   434

   435

   436

registerAdapter(FileUploadDownloadRenderer, FileUploadDownload,

   437

                formless.iformless.ITypedRenderer)

   438

   439

   440

def getDownloadUrl(ctx, argument):

   441

    if lastKnownConfig is not None:

   442

        return url.URL.fromContext(ctx).\

   443

            child(WAMP_SECRET_URL).\

   444

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

   445

   446

   447

webFormInterface = [

   448

    ("status",

   449

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

   450

                     immutable=True,

   451

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

   452

    ("ID",

   453

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

   454

                     default=wampConfigDefault)),

   455

    ("secretfile",

   456

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

   457

                        download_url=getDownloadUrl)),

   458

    ("active",

   459

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

   460

                      default=wampConfigDefault)),

   461

    ("url",

   462

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

   463

                     default=wampConfigDefault))]

   464

   465

   466

def deliverWampSecret(ctx, segments):

   467

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

   468

   469

    # FIXME: compare filename to ID+".secret"

   470

    # for now all url under /secret returns the secret

   471

   472

    # TODO: make beautifull message in case of exception

   473

    # while loading secret (if empty or dont exist)

   474

    secret = LoadWampSecret(_WampSecret)

   475

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

   476

   477

   478

def RegisterWebSettings(NS):

   479

   480

    NS.ConfigurableSettings.addSettings(

   481

        "wamp",