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:

   165

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

   166

            if protocolOptions:

   167

                self.setProtocolOptions(**protocolOptions)

   168

            _transportFactory = self

   169

        except Exception as e:

   170

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

   171

            _transportFactory = None

   172

   173

    def buildProtocol(self, addr):

   174

        self.resetDelay()

   175

        return ReconnectingClientFactory.buildProtocol(self, addr)

   176

   177

    def clientConnectionFailed(self, connector, reason):

   178

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

   179

              time.ctime())

   180

        super(ReconnectingWampWebSocketClientFactory,

   181

              self).clientConnectionFailed(connector, reason)

   182

   183

    def clientConnectionLost(self, connector, reason):

   184

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

   185

              time.ctime())

   186

        super(ReconnectingWampWebSocketClientFactory,

   187

              self).clientConnectionFailed(connector, reason)

   188

   189

   190

def CheckConfiguration(WampClientConf):

   191

    url = WampClientConf["url"]

   192

    if not IsCorrectUri(url):

   193

        raise annotate.ValidateError(

   194

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

   195

            _("WAMP configuration error:"))

   196

   197

   198

def GetConfiguration():

   199

    global lastKnownConfig

   200

   201

    if os.path.exists(_WampConf):

   202

        WampClientConf = json.load(open(_WampConf))

   203

    else:

   204

        WampClientConf = defaultWampConfig.copy()

   205

   206

    for itemName in mandatoryConfigItems:

   207

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

   208

            raise Exception(

   209

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

   210

   211

    CheckConfiguration(WampClientConf)

   212

   213

    lastKnownConfig = WampClientConf.copy()

   214

    return WampClientConf

   215

   216

   217

def SetWampSecret(wampSecret):

   218

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

   219

        f.write(wampSecret)

   220

   221

   222

def SetConfiguration(WampClientConf):

   223

    global lastKnownConfig

   224

   225

    CheckConfiguration(WampClientConf)

   226

   227

    lastKnownConfig = WampClientConf.copy()

   228

   229

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

   230

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

   231

    StopReconnectWampClient()

   232

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

   233

        StartReconnectWampClient()

   234

   235

    return WampClientConf

   236

   237

   238

def LoadWampSecret(secretfname):

   239

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

   240

    if len(WSClientWampSecret) == 0:

   241

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

   242

    return WSClientWampSecret

   243

   244

   245

def IsCorrectUri(uri):

   246

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

   247

   248

   249

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

   250

    global _WampConf, _WampSecret

   251

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

   252

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

   253

   254

    # set config file path only if not already set

   255

    if _WampConf is None:

   256

        # default project's wampconf has precedance over commandline given

   257

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

   258

            _WampConf = _WampConfDefault

   259

        else:

   260

            _WampConf = wampconf

   261

   262

    WampClientConf = GetConfiguration()

   263

   264

    # set secret file path only if not already set

   265

    if _WampSecret is None:

   266

        # default project's wamp secret also

   267

        # has precedance over commandline given

   268

        if os.path.exists(_WampSecretDefault):

   269

            _WampSecret = _WampSecretDefault

   270

        else:

   271

            _WampSecret = wampsecret

   272

   273

    if _WampSecret is not None:

   274

        WampClientConf["secret"] = LoadWampSecret(_WampSecret)

   275

    else:

   276

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

   277

        _WampSecret = _WampSecretDefault

   278

   279

    if not WampClientConf["active"]:

   280

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

   281

        return

   282

   283

    # create a WAMP application session factory

   284

    component_config = types.ComponentConfig(

   285

        realm=WampClientConf["realm"],

   286

        extra=WampClientConf)

   287

    session_factory = wamp.ApplicationSessionFactory(

   288

        config=component_config)

   289

    session_factory.session = WampSession

   290

   291

    # create a WAMP-over-WebSocket transport client factory

   292

    ReconnectingWampWebSocketClientFactory(

   293

        component_config,

   294

        session_factory,

   295

        url=WampClientConf["url"],

   296

        serializers=[MsgPackSerializer()])

   297

   298

    # start the client from a Twisted endpoint

   299

    if _transportFactory:

   300

        connectWS(_transportFactory)

   301

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

   302

        return True

   303

    else:

   304

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

   305

        return False

   306

   307

   308

def StopReconnectWampClient():

   309

    if _transportFactory is not None:

   310

        _transportFactory.stopTrying()

   311

    if _WampSession is not None:

   312

        _WampSession.leave()

   313

   314

   315

def StartReconnectWampClient():

   316

    if _WampSession:

   317

        # do reconnect

   318

        _WampSession.disconnect()

   319

        return True

   320

    else:

   321

        # do connect

   322

        RegisterWampClient()

   323

        return True

   324

   325

   326

def GetSession():

   327

    return _WampSession

   328

   329

   330

def getWampStatus():

   331

    if _transportFactory is not None:

   332

        if _WampSession is not None:

   333

            if _WampSession.is_attached():

   334

                return "Attached"

   335

            return "Established"

   336

        return "Connecting"

   337

    return "Disconnected"

   338

   339

   340

def SetServer(pysrv):

   341

    global _PySrv

   342

    _PySrv = pysrv

   343

   344

   345

def PublishEvent(eventID, value):

   346

    if getWampStatus() == "Attached":

   347

        _WampSession.publish(text(eventID), value)

   348

   349

   350

def PublishEventWithOwnID(eventID, value):

   351

    if getWampStatus() == "Attached":

   352

        _WampSession.publishWithOwnID(text(eventID), value)

   353

   354

   355

# WEB CONFIGURATION INTERFACE

   356

WAMP_SECRET_URL = "secret"

   357

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

   358

   359

   360

def wampConfigDefault(ctx, argument):

   361

    if lastKnownConfig is not None:

   362

        return lastKnownConfig.get(argument.name, None)

   363

   364

   365

def wampConfig(**kwargs):

   366

    secretfile_field = kwargs["secretfile"]

   367

    if secretfile_field is not None:

   368

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

   369

        if secretfile is not None:

   370

            secret = secretfile_field.file.read()

   371

            SetWampSecret(secret)

   372

   373

    newConfig = lastKnownConfig.copy()

   374

    for argname in webExposedConfigItems:

   375

        arg = kwargs.get(argname, None)

   376

        if arg is not None:

   377

            newConfig[argname] = arg

   378

   379

    SetConfiguration(newConfig)

   380

   381

   382

class FileUploadDownload(annotate.FileUpload):

   383

    pass

   384

   385

   386

class FileUploadDownloadRenderer(webform.FileUploadRenderer):

   387

   388

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

   389

        # pylint: disable=expression-not-assigned

   390

        slot[_("Upload:")]

   391

        slot = webform.FileUploadRenderer.input(

   392

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

   393

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

   394

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

   395

   396

   397

registerAdapter(FileUploadDownloadRenderer, FileUploadDownload,

   398

                formless.iformless.ITypedRenderer)

   399

   400

   401

def getDownloadUrl(ctx, argument):

   402

    if lastKnownConfig is not None:

   403

        return url.URL.fromContext(ctx).\

   404

            child(WAMP_SECRET_URL).\

   405

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

   406

   407

   408

webFormInterface = [

   409

    ("status",

   410

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

   411

                     immutable=True,

   412

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

   413

    ("ID",

   414

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

   415

                     default=wampConfigDefault)),

   416

    ("secretfile",

   417

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

   418

                        download_url=getDownloadUrl)),

   419

    ("active",

   420

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

   421

                      default=wampConfigDefault)),

   422

    ("url",

   423

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

   424

                     default=wampConfigDefault))]

   425

   426

   427

def deliverWampSecret(ctx, segments):

   428

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

   429

   430

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

   431

    # for now all url under /secret returns the secret

   432

   433

    # TODO: make beautifull message in case of exception

   434

    # while loading secret (if empty or dont exist)

   435

    secret = LoadWampSecret(_WampSecret)

   436

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

   437

   438

   439

def RegisterWebSettings(NS):

   440

   441

    NS.ConfigurableSettings.addSettings(

   442

        "wamp",

   443

        _("Wamp Settings"),

   444

        webFormInterface,

   445

        _("Set"),

   446

        wampConfig)

   447

   448

    NS.customSettingsURLs[WAMP_SECRET_URL] = deliverWampSecret