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.defer import inlineCallbacks

    37

from twisted.internet.protocol import ReconnectingClientFactory

    38

from twisted.python.components import registerAdapter

    39

    40

from formless import annotate, webform

    41

import formless

    42

from nevow import tags, url, static

    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 = _PySrv.plcobj

    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

    @inlineCallbacks

   120

    def onJoin(self, details):

   121

        global _WampSession

   122

        _WampSession = self

   123

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

   124

   125

        for name, kwargs in ExposedCalls:

   126

            try:

   127

                registerOptions = types.RegisterOptions(**kwargs)

   128

            except TypeError as e:

   129

                registerOptions = None

   130

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

   131

   132

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

   133

   134

        for name in SubscribedEvents:

   135

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

   136

   137

        for func in DoOnJoin:

   138

            yield func(self)

   139

   140

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

   141

   142

    def onLeave(self, details):

   143

        global _WampSession, _transportFactory

   144

        super(WampSession, self).onLeave(details)

   145

        _WampSession = None

   146

        _transportFactory = None

   147

        print(_('WAMP session left'))

   148

   149

   150

class ReconnectingWampWebSocketClientFactory(WampWebSocketClientFactory, ReconnectingClientFactory):

   151

   152

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

   153

        global _transportFactory

   154

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

   155

   156

        try:

   157

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

   158

            if protocolOptions:

   159

                self.setProtocolOptions(**protocolOptions)

   160

            _transportFactory = self

   161

        except Exception as e:

   162

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

   163

            _transportFactory = None

   164

   165

    def buildProtocol(self, addr):

   166

        self.resetDelay()

   167

        return ReconnectingClientFactory.buildProtocol(self, addr)

   168

   169

    def clientConnectionFailed(self, connector, reason):

   170

        if self.continueTrying:

   171

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

   172

                  time.ctime())

   173

            super(ReconnectingWampWebSocketClientFactory,

   174

                  self).clientConnectionFailed(connector, reason)

   175

        else:

   176

            del connector

   177

   178

    def clientConnectionLost(self, connector, reason):

   179

        if self.continueTrying:

   180

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

   181

                  time.ctime())

   182

            super(ReconnectingWampWebSocketClientFactory,

   183

                  self).clientConnectionFailed(connector, reason)

   184

        else:

   185

            del connector

   186

   187

   188

def CheckConfiguration(WampClientConf):

   189

    url = WampClientConf["url"]

   190

    if not IsCorrectUri(url):

   191

        raise annotate.ValidateError(

   192

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

   193

            _("WAMP configuration error:"))

   194

   195

   196

def GetConfiguration():

   197

    global lastKnownConfig

   198

   199

    if os.path.exists(_WampConf):

   200

        WampClientConf = json.load(open(_WampConf))

   201

    else:

   202

        WampClientConf = defaultWampConfig.copy()

   203

   204

    for itemName in mandatoryConfigItems:

   205

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

   206

            raise Exception(

   207

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

   208

   209

    CheckConfiguration(WampClientConf)

   210

   211

    lastKnownConfig = WampClientConf.copy()

   212

    return WampClientConf

   213

   214

   215

def SetWampSecret(wampSecret):

   216

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

   217

        f.write(wampSecret)

   218

   219

   220

def SetConfiguration(WampClientConf):

   221

    global lastKnownConfig

   222

   223

    CheckConfiguration(WampClientConf)

   224

   225

    lastKnownConfig = WampClientConf.copy()

   226

   227

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

   228

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

   229

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

   230

        if _transportFactory and _WampSession:

   231

            StopReconnectWampClient()

   232

        StartReconnectWampClient()

   233

    else:

   234

        StopReconnectWampClient()

   235

   236

    return WampClientConf

   237

   238

   239

def LoadWampSecret(secretfname):

   240

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

   241

    if len(WSClientWampSecret) == 0:

   242

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

   243

    return WSClientWampSecret

   244

   245

   246

def IsCorrectUri(uri):

   247

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

   248

   249

   250

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

   251

    global _WampConf, _WampSecret

   252

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

   253

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

   254

   255

    # set config file path only if not already set

   256

    if _WampConf is None:

   257

        # default project's wampconf has precedance over commandline given

   258

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

   259

            _WampConf = _WampConfDefault

   260

        else:

   261

            _WampConf = wampconf

   262

   263

    WampClientConf = GetConfiguration()

   264

   265

    # set secret file path only if not already set

   266

    if _WampSecret is None:

   267

        # default project's wamp secret also

   268

        # has precedance over commandline given

   269

        if os.path.exists(_WampSecretDefault):

   270

            _WampSecret = _WampSecretDefault

   271

        else:

   272

            _WampSecret = wampsecret

   273

   274

    if _WampSecret is not None:

   275

        WampClientConf["secret"] = LoadWampSecret(_WampSecret)

   276

    else:

   277

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

   278

        _WampSecret = _WampSecretDefault

   279

   280

    if not WampClientConf["active"]:

   281

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

   282

        return

   283

   284

    # create a WAMP application session factory

   285

    component_config = types.ComponentConfig(

   286

        realm=WampClientConf["realm"],

   287

        extra=WampClientConf)

   288

    session_factory = wamp.ApplicationSessionFactory(

   289

        config=component_config)

   290

    session_factory.session = WampSession

   291

   292

    # create a WAMP-over-WebSocket transport client factory

   293

    ReconnectingWampWebSocketClientFactory(

   294

        component_config,

   295

        session_factory,

   296

        url=WampClientConf["url"],

   297

        serializers=[MsgPackSerializer()])

   298

   299

    # start the client from a Twisted endpoint

   300

    if _transportFactory:

   301

        connectWS(_transportFactory)

   302

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

   303

        return True

   304

    else:

   305

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

   306

        return False

   307

   308

   309

def StopReconnectWampClient():

   310

    if _transportFactory is not None:

   311

        _transportFactory.stopTrying()

   312

    if _WampSession is not None:

   313

        _WampSession.leave()

   314

   315

   316

def StartReconnectWampClient():

   317

    if _WampSession:

   318

        # do reconnect

   319

        _WampSession.disconnect()

   320

        return True

   321

    else:

   322

        # do connect

   323

        RegisterWampClient()

   324

        return True

   325

   326

   327

def GetSession():

   328

    return _WampSession

   329

   330

   331

def getWampStatus():

   332

    if _transportFactory is not None:

   333

        if _WampSession is not None:

   334

            if _WampSession.is_attached():

   335

                return "Attached"

   336

            return "Established"

   337

        return "Connecting"

   338

    return "Disconnected"

   339

   340

   341

def SetServer(pysrv):

   342

    global _PySrv

   343

    _PySrv = pysrv

   344

   345

   346

# WEB CONFIGURATION INTERFACE

   347

WAMP_SECRET_URL = "secret"

   348

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

   349

   350

   351

def wampConfigDefault(ctx, argument):

   352

    if lastKnownConfig is not None:

   353

        return lastKnownConfig.get(argument.name, None)

   354

   355

   356

def wampConfig(**kwargs):

   357

    secretfile_field = kwargs["secretfile"]

   358

    if secretfile_field is not None:

   359

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

   360

        if secretfile is not None:

   361

            secret = secretfile_field.file.read()

   362

            SetWampSecret(secret)

   363

   364

    newConfig = lastKnownConfig.copy()

   365

    for argname in webExposedConfigItems:

   366

        arg = kwargs.get(argname, None)

   367

        if arg is not None:

   368

            newConfig[argname] = arg

   369

   370

    SetConfiguration(newConfig)

   371

   372

   373

class FileUploadDownload(annotate.FileUpload):

   374

    pass

   375

   376

   377

class FileUploadDownloadRenderer(webform.FileUploadRenderer):

   378

   379

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

   380

        # pylint: disable=expression-not-assigned

   381

        slot[_("Upload:")]

   382

        slot = webform.FileUploadRenderer.input(

   383

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

   384

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

   385

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

   386

   387

   388

registerAdapter(FileUploadDownloadRenderer, FileUploadDownload,

   389

                formless.iformless.ITypedRenderer)

   390

   391

   392

def getDownloadUrl(ctx, argument):

   393

    if lastKnownConfig is not None:

   394

        return url.URL.fromContext(ctx).\

   395

            child(WAMP_SECRET_URL).\

   396

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

   397

   398

   399

webFormInterface = [

   400

    ("status",

   401

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

   402

                     immutable=True,

   403

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

   404

    ("ID",

   405

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

   406

                     default=wampConfigDefault)),

   407

    ("secretfile",

   408

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

   409

                        download_url=getDownloadUrl)),

   410

    ("active",

   411

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

   412

                      default=wampConfigDefault)),

   413

    ("url",

   414

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

   415

                     default=wampConfigDefault))]

   416

   417

   418

def deliverWampSecret(ctx, segments):

   419

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

   420

   421

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

   422

    # for now all url under /secret returns the secret

   423

   424

    # TODO: make beautifull message in case of exception

   425

    # while loading secret (if empty or dont exist)

   426

    secret = LoadWampSecret(_WampSecret)

   427

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

   428

   429

   430

def RegisterWebSettings(NS):

   431

    NS.ConfigurableSettings.addExtension(

   432

        "wamp",

   433

        _("Wamp Settings"),

   434

        webFormInterface,

   435

        _("Set"),

   436

        wampConfig)

   437

   438

    NS.customSettingsURLs[WAMP_SECRET_URL] = deliverWampSecret