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

    ("MatchMD5", {}),

    65

    ("SetTraceVariablesList", {}),

    66

    ("GetTraceVariables", {}),

    67

    ("RemoteExec", {}),

    68

    ("GetLogMessage", {}),

    69

    ("ResetLogCount", {})

    70

]

    71

    72

# de-activated dumb wamp config

    73

defaultWampConfig = {

    74

    "ID": "wamptest",

    75

    "active": False,

    76

    "realm": "Automation",

    77

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

    78

}

    79

    80

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

    81

# or User python code.

    82

    83

""" crossbar Events to register to """

    84

SubscribedEvents = []

    85

    86

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

    87

DoOnJoin = []

    88

    89

lastKnownConfig = None

    90

    91

    92

def GetCallee(name):

    93

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

    94

    names = name.split('.')

    95

    obj = GetPLCObjectSingleton()

    96

    while names:

    97

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

    98

    return obj

    99

   100

   101

class WampSession(wamp.ApplicationSession):

   102

   103

    def onConnect(self):

   104

        if "secret" in self.config.extra:

   105

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

   106

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

   107

        else:

   108

            self.join(u"Automation")

   109

   110

    def onChallenge(self, challenge):

   111

        if challenge.method == u"wampcra":

   112

            if "secret" in self.config.extra:

   113

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

   114

                signature = auth.compute_wcs(

   115

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

   116

                return signature.decode("ascii")

   117

            else:

   118

                raise Exception("no secret given for authentication")

   119

        else:

   120

            raise Exception(

   121

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

   122

   123

    def onJoin(self, details):

   124

        global _WampSession

   125

        _WampSession = self

   126

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

   127

   128

        for name, kwargs in ExposedCalls:

   129

            try:

   130

                registerOptions = types.RegisterOptions(**kwargs)

   131

            except TypeError as e:

   132

                registerOptions = None

   133

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

   134

   135

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

   136

   137

        for name in SubscribedEvents:

   138

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

   139

   140

        for func in DoOnJoin:

   141

            func(self)

   142

   143

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

   144

   145

    def onLeave(self, details):

   146

        global _WampSession, _transportFactory

   147

        super(WampSession, self).onLeave(details)

   148

        _WampSession = None

   149

        _transportFactory = None

   150

        print(_('WAMP session left'))

   151

   152

    def publishWithOwnID(self, eventID, value):

   153

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

   154

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

   155

   156

   157

class ReconnectingWampWebSocketClientFactory(WampWebSocketClientFactory, ReconnectingClientFactory):

   158

   159

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

   160

        global _transportFactory

   161

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

   162

   163

        try:

   164

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

   165

            if protocolOptions:

   166

                self.setProtocolOptions(**protocolOptions)

   167

            _transportFactory = self

   168

        except Exception as e:

   169

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

   170

            _transportFactory = None

   171

   172

    def buildProtocol(self, addr):

   173

        self.resetDelay()

   174

        return ReconnectingClientFactory.buildProtocol(self, addr)

   175

   176

    def clientConnectionFailed(self, connector, reason):

   177

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

   178

              time.ctime())

   179

        super(ReconnectingWampWebSocketClientFactory,

   180

              self).clientConnectionFailed(connector, reason)

   181

   182

    def clientConnectionLost(self, connector, reason):

   183

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

   184

              time.ctime())

   185

        super(ReconnectingWampWebSocketClientFactory,

   186

              self).clientConnectionFailed(connector, reason)

   187

   188

   189

def CheckConfiguration(WampClientConf):

   190

    url = WampClientConf["url"]

   191

    if not IsCorrectUri(url):

   192

        raise annotate.ValidateError(

   193

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

   194

            _("WAMP configuration error:"))

   195

   196

   197

def GetConfiguration():

   198

    global lastKnownConfig

   199

   200

    if os.path.exists(_WampConf):

   201

        WampClientConf = json.load(open(_WampConf))

   202

    else:

   203

        WampClientConf = defaultWampConfig.copy()

   204

   205

    for itemName in mandatoryConfigItems:

   206

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

   207

            raise Exception(

   208

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

   209

   210

    CheckConfiguration(WampClientConf)

   211

   212

    lastKnownConfig = WampClientConf.copy()

   213

    return WampClientConf

   214

   215

   216

def SetWampSecret(wampSecret):

   217

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

   218

        f.write(wampSecret)

   219

   220

   221

def SetConfiguration(WampClientConf):

   222

    global lastKnownConfig

   223

   224

    CheckConfiguration(WampClientConf)

   225

   226

    lastKnownConfig = WampClientConf.copy()

   227

   228

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

   229

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

   230

    StopReconnectWampClient()

   231

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

   232

        StartReconnectWampClient()

   233

   234

    return WampClientConf

   235

   236

   237

def LoadWampSecret(secretfname):

   238

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

   239

    if len(WSClientWampSecret) == 0:

   240

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

   241

    return WSClientWampSecret

   242

   243

   244

def IsCorrectUri(uri):

   245

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

   246

   247

   248

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

   249

    global _WampConf, _WampSecret

   250

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

   251

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

   252

   253

    # set config file path only if not already set

   254

    if _WampConf is None:

   255

        # default project's wampconf has precedance over commandline given

   256

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

   257

            _WampConf = _WampConfDefault

   258

        else:

   259

            _WampConf = wampconf

   260

   261

    WampClientConf = GetConfiguration()

   262

   263

    # set secret file path only if not already set

   264

    if _WampSecret is None:

   265

        # default project's wamp secret also

   266

        # has precedance over commandline given

   267

        if os.path.exists(_WampSecretDefault):

   268

            _WampSecret = _WampSecretDefault

   269

        else:

   270

            _WampSecret = wampsecret

   271

   272

    if _WampSecret is not None:

   273

        WampClientConf["secret"] = LoadWampSecret(_WampSecret)

   274

    else:

   275

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

   276

        _WampSecret = _WampSecretDefault

   277

   278

    if not WampClientConf["active"]:

   279

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

   280

        return

   281

   282

    # create a WAMP application session factory

   283

    component_config = types.ComponentConfig(

   284

        realm=WampClientConf["realm"],

   285

        extra=WampClientConf)

   286

    session_factory = wamp.ApplicationSessionFactory(

   287

        config=component_config)

   288

    session_factory.session = WampSession

   289

   290

    # create a WAMP-over-WebSocket transport client factory

   291

    ReconnectingWampWebSocketClientFactory(

   292

        component_config,

   293

        session_factory,

   294

        url=WampClientConf["url"],

   295

        serializers=[MsgPackSerializer()])

   296

   297

    # start the client from a Twisted endpoint

   298

    if _transportFactory:

   299

        connectWS(_transportFactory)

   300

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

   301

        return True

   302

    else:

   303

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

   304

        return False

   305

   306

   307

def StopReconnectWampClient():

   308

    if _transportFactory is not None:

   309

        _transportFactory.stopTrying()

   310

    if _WampSession is not None:

   311

        _WampSession.leave()

   312

   313

   314

def StartReconnectWampClient():

   315

    if _WampSession:

   316

        # do reconnect

   317

        _WampSession.disconnect()

   318

        return True

   319

    else:

   320

        # do connect

   321

        RegisterWampClient()

   322

        return True

   323

   324

   325

def GetSession():

   326

    return _WampSession

   327

   328

   329

def getWampStatus():

   330

    if _transportFactory is not None:

   331

        if _WampSession is not None:

   332

            if _WampSession.is_attached():

   333

                return "Attached"

   334

            return "Established"

   335

        return "Connecting"

   336

    return "Disconnected"

   337

   338

   339

def SetServer(pysrv):

   340

    global _PySrv

   341

    _PySrv = pysrv

   342

   343

   344

def PublishEvent(eventID, value):

   345

    if getWampStatus() == "Attached":

   346

        _WampSession.publish(text(eventID), value)

   347

   348

   349

def PublishEventWithOwnID(eventID, value):

   350

    if getWampStatus() == "Attached":

   351

        _WampSession.publishWithOwnID(text(eventID), value)

   352

   353

   354

# WEB CONFIGURATION INTERFACE

   355

WAMP_SECRET_URL = "secret"

   356

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

   357

   358

   359

def wampConfigDefault(ctx, argument):

   360

    if lastKnownConfig is not None:

   361

        return lastKnownConfig.get(argument.name, None)

   362

   363

   364

def wampConfig(**kwargs):

   365

    secretfile_field = kwargs["secretfile"]

   366

    if secretfile_field is not None:

   367

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

   368

        if secretfile is not None:

   369

            secret = secretfile_field.file.read()

   370

            SetWampSecret(secret)

   371

   372

    newConfig = lastKnownConfig.copy()

   373

    for argname in webExposedConfigItems:

   374

        arg = kwargs.get(argname, None)

   375

        if arg is not None:

   376

            newConfig[argname] = arg

   377

   378

    SetConfiguration(newConfig)

   379

   380

   381

class FileUploadDownload(annotate.FileUpload):

   382

    pass

   383

   384

   385

class FileUploadDownloadRenderer(webform.FileUploadRenderer):

   386

   387

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

   388

        # pylint: disable=expression-not-assigned

   389

        slot[_("Upload:")]

   390

        slot = webform.FileUploadRenderer.input(

   391

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

   392

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

   393

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

   394

   395

   396

registerAdapter(FileUploadDownloadRenderer, FileUploadDownload,

   397

                formless.iformless.ITypedRenderer)

   398

   399

   400

def getDownloadUrl(ctx, argument):

   401

    if lastKnownConfig is not None:

   402

        return url.URL.fromContext(ctx).\

   403

            child(WAMP_SECRET_URL).\

   404

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

   405

   406

   407

webFormInterface = [

   408

    ("status",

   409

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

   410

                     immutable=True,

   411

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

   412

    ("ID",

   413

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

   414

                     default=wampConfigDefault)),

   415

    ("secretfile",

   416

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

   417

                        download_url=getDownloadUrl)),

   418

    ("active",

   419

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

   420

                      default=wampConfigDefault)),

   421

    ("url",

   422

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

   423

                     default=wampConfigDefault))]

   424

   425

   426

def deliverWampSecret(ctx, segments):

   427

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

   428

   429

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

   430

    # for now all url under /secret returns the secret

   431

   432

    # TODO: make beautifull message in case of exception

   433

    # while loading secret (if empty or dont exist)

   434

    secret = LoadWampSecret(_WampSecret)

   435

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

   436

   437

   438

def RegisterWebSettings(NS):

   439

   440

    NS.ConfigurableSettings.addSettings(

   441

        "wamp",

   442

        _("Wamp Settings"),

   443

        webFormInterface,

   444

        _("Set"),

   445

        wampConfig)

   446

   447

    NS.customSettingsURLs[WAMP_SECRET_URL] = deliverWampSecret