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 builtins import str 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

    ("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

    88

def GetCallee(name):

    89

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

    90

    names = name.split('.')

    91

    obj = GetPLCObjectSingleton()

    92

    while names:

    93

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

    94

    return obj

    95

    96

    97

class WampSession(wamp.ApplicationSession):

    98

    99

    def onConnect(self):

   100

        if "secret" in self.config.extra:

   101

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

   102

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

   103

        else:

   104

            self.join(u"Automation")

   105

   106

    def onChallenge(self, challenge):

   107

        if challenge.method == u"wampcra":

   108

            if "secret" in self.config.extra:

   109

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

   110

                signature = auth.compute_wcs(

   111

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

   112

                return signature.decode("ascii")

   113

            else:

   114

                raise Exception("no secret given for authentication")

   115

        else:

   116

            raise Exception(

   117

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

   118

   119

    def onJoin(self, details):

   120

        global _WampSession

   121

        _WampSession = self

   122

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

   123

   124

        for name, kwargs in ExposedCalls:

   125

            try:

   126

                registerOptions = types.RegisterOptions(**kwargs)

   127

            except TypeError as e:

   128

                registerOptions = None

   129

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

   130

   131

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

   132

   133

        for name in SubscribedEvents:

   134

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

   135

   136

        for func in DoOnJoin:

   137

            func(self)

   138

   139

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

   140

   141

    def onLeave(self, details):

   142

        global _WampSession, _transportFactory

   143

        super(WampSession, self).onLeave(details)

   144

        _WampSession = None

   145

        _transportFactory = None

   146

        print(_('WAMP session left'))

   147

   148

    def publishWithOwnID(self, eventID, value):

   149

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

   150

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

   151

   152

   153

class ReconnectingWampWebSocketClientFactory(WampWebSocketClientFactory, ReconnectingClientFactory):

   154

   155

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

   156

        global _transportFactory

   157

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

   158

   159

        try:

   160

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

   161

            if protocolOptions:

   162

                self.setProtocolOptions(**protocolOptions)

   163

            _transportFactory = self

   164

        except Exception as e:

   165

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

   166

            _transportFactory = None

   167

   168

    def buildProtocol(self, addr):

   169

        self.resetDelay()

   170

        return ReconnectingClientFactory.buildProtocol(self, addr)

   171

   172

    def clientConnectionFailed(self, connector, reason):

   173

        if self.continueTrying:

   174

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

   175

                  time.ctime())

   176

            super(ReconnectingWampWebSocketClientFactory,

   177

                  self).clientConnectionFailed(connector, reason)

   178

        else:

   179

            del connector

   180

   181

    def clientConnectionLost(self, connector, reason):

   182

        if self.continueTrying:

   183

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

   184

                  time.ctime())

   185

            super(ReconnectingWampWebSocketClientFactory,

   186

                  self).clientConnectionFailed(connector, reason)

   187

        else:

   188

            del connector

   189

   190

   191

def CheckConfiguration(WampClientConf):

   192

    url = WampClientConf["url"]

   193

    if not IsCorrectUri(url):

   194

        raise annotate.ValidateError(

   195

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

   196

            _("WAMP configuration error:"))

   197

   198

   199

def GetConfiguration():

   200

    global lastKnownConfig

   201

   202

    if os.path.exists(_WampConf):

   203

        WampClientConf = json.load(open(_WampConf))

   204

    else:

   205

        WampClientConf = defaultWampConfig.copy()

   206

   207

    for itemName in mandatoryConfigItems:

   208

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

   209

            raise Exception(

   210

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

   211

   212

    CheckConfiguration(WampClientConf)

   213

   214

    lastKnownConfig = WampClientConf.copy()

   215

    return WampClientConf

   216

   217

   218

def SetWampSecret(wampSecret):

   219

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

   220

        f.write(wampSecret)

   221

   222

   223

def SetConfiguration(WampClientConf):

   224

    global lastKnownConfig

   225

   226

    CheckConfiguration(WampClientConf)

   227

   228

    lastKnownConfig = WampClientConf.copy()

   229

   230

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

   231

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

   232

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

   233

        if _transportFactory and _WampSession:

   234

            StopReconnectWampClient()

   235

        StartReconnectWampClient()

   236

    else:

   237

        StopReconnectWampClient()

   238

   239

    return WampClientConf

   240

   241

   242

def LoadWampSecret(secretfname):

   243

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

   244

    if len(WSClientWampSecret) == 0:

   245

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

   246

    return WSClientWampSecret

   247

   248

   249

def IsCorrectUri(uri):

   250

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

   251

   252

   253

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

   254

    global _WampConf, _WampSecret

   255

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

   256

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

   257

   258

    # set config file path only if not already set

   259

    if _WampConf is None:

   260

        # default project's wampconf has precedance over commandline given

   261

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

   262

            _WampConf = _WampConfDefault

   263

        else:

   264

            _WampConf = wampconf

   265

   266

    WampClientConf = GetConfiguration()

   267

   268

    # set secret file path only if not already set

   269

    if _WampSecret is None:

   270

        # default project's wamp secret also

   271

        # has precedance over commandline given

   272

        if os.path.exists(_WampSecretDefault):

   273

            _WampSecret = _WampSecretDefault

   274

        else:

   275

            _WampSecret = wampsecret

   276

   277

    if _WampSecret is not None:

   278

        WampClientConf["secret"] = LoadWampSecret(_WampSecret)

   279

    else:

   280

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

   281

        _WampSecret = _WampSecretDefault

   282

   283

    if not WampClientConf["active"]:

   284

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

   285

        return

   286

   287

    # create a WAMP application session factory

   288

    component_config = types.ComponentConfig(

   289

        realm=WampClientConf["realm"],

   290

        extra=WampClientConf)

   291

    session_factory = wamp.ApplicationSessionFactory(

   292

        config=component_config)

   293

    session_factory.session = WampSession

   294

   295

    # create a WAMP-over-WebSocket transport client factory

   296

    ReconnectingWampWebSocketClientFactory(

   297

        component_config,

   298

        session_factory,

   299

        url=WampClientConf["url"],

   300

        serializers=[MsgPackSerializer()])

   301

   302

    # start the client from a Twisted endpoint

   303

    if _transportFactory:

   304

        connectWS(_transportFactory)

   305

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

   306

        return True

   307

    else:

   308

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

   309

        return False

   310

   311

   312

def StopReconnectWampClient():

   313

    if _transportFactory is not None:

   314

        _transportFactory.stopTrying()

   315

    if _WampSession is not None:

   316

        _WampSession.leave()

   317

   318

   319

def StartReconnectWampClient():

   320

    if _WampSession:

   321

        # do reconnect

   322

        _WampSession.disconnect()

   323

        return True

   324

    else:

   325

        # do connect

   326

        RegisterWampClient()

   327

        return True

   328

   329

   330

def GetSession():

   331

    return _WampSession

   332

   333

   334

def getWampStatus():

   335

    if _transportFactory is not None:

   336

        if _WampSession is not None:

   337

            if _WampSession.is_attached():

   338

                return "Attached"

   339

            return "Established"

   340

        return "Connecting"

   341

    return "Disconnected"

   342

   343

   344

def SetServer(pysrv):

   345

    global _PySrv

   346

    _PySrv = pysrv

   347

   348

   349

def PublishEvent(eventID, value):

   350

    if getWampStatus() == "Attached":

   351

        _WampSession.publish(unicode(eventID), value)

   352

   353

   354

def PublishEventWithOwnID(eventID, value):

   355

    if getWampStatus() == "Attached":

   356

        _WampSession.publishWithOwnID(unicode(eventID), value)

   357

   358

   359

# WEB CONFIGURATION INTERFACE

   360

WAMP_SECRET_URL = "secret"

   361

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

   362

   363

   364

def wampConfigDefault(ctx, argument):

   365

    if lastKnownConfig is not None:

   366

        return lastKnownConfig.get(argument.name, None)

   367

   368

   369

def wampConfig(**kwargs):

   370

    secretfile_field = kwargs["secretfile"]

   371

    if secretfile_field is not None:

   372

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

   373

        if secretfile is not None:

   374

            secret = secretfile_field.file.read()

   375

            SetWampSecret(secret)

   376

   377

    newConfig = lastKnownConfig.copy()

   378

    for argname in webExposedConfigItems:

   379

        arg = kwargs.get(argname, None)

   380

        if arg is not None:

   381

            newConfig[argname] = arg

   382

   383

    SetConfiguration(newConfig)

   384

   385

   386

class FileUploadDownload(annotate.FileUpload):

   387

    pass

   388

   389

   390

class FileUploadDownloadRenderer(webform.FileUploadRenderer):

   391

   392

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

   393

        # pylint: disable=expression-not-assigned

   394

        slot[_("Upload:")]

   395

        slot = webform.FileUploadRenderer.input(

   396

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

   397

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

   398

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

   399

   400

   401

registerAdapter(FileUploadDownloadRenderer, FileUploadDownload,

   402

                formless.iformless.ITypedRenderer)

   403

   404

   405

def getDownloadUrl(ctx, argument):

   406

    if lastKnownConfig is not None:

   407

        return url.URL.fromContext(ctx).\

   408

            child(WAMP_SECRET_URL).\

   409

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

   410

   411

   412

webFormInterface = [

   413

    ("status",

   414

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

   415

                     immutable=True,

   416

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

   417

    ("ID",

   418

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

   419

                     default=wampConfigDefault)),

   420

    ("secretfile",

   421

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

   422

                        download_url=getDownloadUrl)),

   423

    ("active",

   424

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

   425

                      default=wampConfigDefault)),

   426

    ("url",

   427

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

   428

                     default=wampConfigDefault))]

   429

   430

   431

def deliverWampSecret(ctx, segments):

   432

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

   433

   434

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

   435

    # for now all url under /secret returns the secret

   436

   437

    # TODO: make beautifull message in case of exception

   438

    # while loading secret (if empty or dont exist)

   439

    secret = LoadWampSecret(_WampSecret)

   440

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

   441

   442

   443

def RegisterWebSettings(NS):

   444

   445

    NS.ConfigurableSettings.addSettings(

   446

        "wamp",

   447

        _("Wamp Settings"),

   448

        webFormInterface,

   449

        _("Set"),

   450

        wampConfig)

   451

   452

    NS.customSettingsURLs[WAMP_SECRET_URL] = deliverWampSecret