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 autobahn.twisted import wamp

    32

from autobahn.twisted.websocket import WampWebSocketClientFactory, connectWS

    33

from autobahn.wamp import types, auth

    34

from autobahn.wamp.serializer import MsgPackSerializer

    35

from twisted.internet.defer import inlineCallbacks

    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

    43

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

    44

    45

_transportFactory = None

    46

_WampSession = None

    47

_PySrv = None

    48

WorkingDir = None

    49

    50

# Find pre-existing project WAMP config file

    51

_WampConf = None

    52

_WampSecret = None

    53

    54

ExposedCalls = [

    55

    ("StartPLC", {}),

    56

    ("StopPLC", {}),

    57

    ("GetPLCstatus", {}),

    58

    ("NewPLC", {}),

    59

    ("MatchMD5", {}),

    60

    ("SetTraceVariablesList", {}),

    61

    ("GetTraceVariables", {}),

    62

    ("RemoteExec", {}),

    63

    ("GetLogMessage", {}),

    64

    ("ResetLogCount", {})

    65

]

    66

    67

# de-activated dumb wamp config

    68

defaultWampConfig = {

    69

    "ID": "wamptest",

    70

    "active": False,

    71

    "realm": "Automation",

    72

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

    73

}

    74

    75

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

    76

# or User python code.

    77

    78

""" crossbar Events to register to """

    79

SubscribedEvents = []

    80

    81

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

    82

DoOnJoin = []

    83

    84

lastKnownConfig = None

    85

    86

    87

def GetCallee(name):

    88

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

    89

    names = name.split('.')

    90

    obj = _PySrv.plcobj

    91

    while names:

    92

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

    93

    return obj

    94

    95

    96

class WampSession(wamp.ApplicationSession):

    97

    98

    def onConnect(self):

    99

        if "secret" in self.config.extra:

   100

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

   101

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

   102

        else:

   103

            self.join(u"Automation")

   104

   105

    def onChallenge(self, challenge):

   106

        if challenge.method == u"wampcra":

   107

            if "secret" in self.config.extra:

   108

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

   109

                signature = auth.compute_wcs(

   110

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

   111

                return signature.decode("ascii")

   112

            else:

   113

                raise Exception("no secret given for authentication")

   114

        else:

   115

            raise Exception(

   116

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

   117

   118

    @inlineCallbacks

   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

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

   132

   133

        for name in SubscribedEvents:

   134

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

   135

   136

        for func in DoOnJoin:

   137

            yield 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

   149

class ReconnectingWampWebSocketClientFactory(WampWebSocketClientFactory, ReconnectingClientFactory):

   150

   151

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

   152

        global _transportFactory

   153

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

   154

   155

        try:

   156

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

   157

            if protocolOptions:

   158

                self.setProtocolOptions(**protocolOptions)

   159

            _transportFactory = self

   160

        except Exception, e:

   161

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

   162

            _transportFactory = None

   163

   164

    def buildProtocol(self, addr):

   165

        self.resetDelay()

   166

        return ReconnectingClientFactory.buildProtocol(self, addr)

   167

   168

    def clientConnectionFailed(self, connector, reason):

   169

        if self.continueTrying:

   170

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

   171

                  time.ctime())

   172

            super(ReconnectingWampWebSocketClientFactory,

   173

                  self).clientConnectionFailed(connector, reason)

   174

        else:

   175

            del connector

   176

   177

    def clientConnectionLost(self, connector, reason):

   178

        if self.continueTrying:

   179

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

   180

                  time.ctime())

   181

            super(ReconnectingWampWebSocketClientFactory,

   182

                  self).clientConnectionFailed(connector, reason)

   183

        else:

   184

            del connector

   185

   186

   187

def CheckConfiguration(WampClientConf):

   188

    url = WampClientConf["url"]

   189

    if not IsCorrectUri(url):

   190

        raise annotate.ValidateError(

   191

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

   192

            _("WAMP configuration error:"))

   193

   194

   195

def GetConfiguration():

   196

    global lastKnownConfig

   197

   198

    if os.path.exists(_WampConf):

   199

        WampClientConf = json.load(open(_WampConf))

   200

    else:

   201

        WampClientConf = defaultWampConfig.copy()

   202

   203

    for itemName in mandatoryConfigItems:

   204

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

   205

            raise Exception(

   206

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

   207

   208

    CheckConfiguration(WampClientConf)

   209

   210

    lastKnownConfig = WampClientConf.copy()

   211

    return WampClientConf

   212

   213

   214

def SetWampSecret(wampSecret):

   215

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

   216

        f.write(wampSecret)

   217

   218

   219

def SetConfiguration(WampClientConf):

   220

    global lastKnownConfig

   221

   222

    CheckConfiguration(WampClientConf)

   223

   224

    lastKnownConfig = WampClientConf.copy()

   225

   226

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

   227

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

   228

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

   229

        if _transportFactory and _WampSession:

   230

            StopReconnectWampClient()

   231

        StartReconnectWampClient()

   232

    else:

   233

        StopReconnectWampClient()

   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

# WEB CONFIGURATION INTERFACE

   346

WAMP_SECRET_URL = "secret"

   347

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

   348

   349

   350

def wampConfigDefault(ctx, argument):

   351

    if lastKnownConfig is not None:

   352

        return lastKnownConfig.get(argument.name, None)

   353

   354

   355

def wampConfig(**kwargs):

   356

    secretfile_field = kwargs["secretfile"]

   357

    if secretfile_field is not None:

   358

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

   359

        if secretfile is not None:

   360

            secret = secretfile_field.file.read()

   361

            SetWampSecret(secret)

   362

   363

    newConfig = lastKnownConfig.copy()

   364

    for argname in webExposedConfigItems:

   365

        arg = kwargs.get(argname, None)

   366

        if arg is not None:

   367

            newConfig[argname] = arg

   368

   369

    SetConfiguration(newConfig)

   370

   371

   372

class FileUploadDownload(annotate.FileUpload):

   373

    pass

   374

   375

   376

class FileUploadDownloadRenderer(webform.FileUploadRenderer):

   377

   378

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

   379

        # pylint: disable=expression-not-assigned

   380

        slot[_("Upload:")]

   381

        slot = webform.FileUploadRenderer.input(

   382

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

   383

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

   384

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

   385

   386

   387

registerAdapter(FileUploadDownloadRenderer, FileUploadDownload,

   388

                formless.iformless.ITypedRenderer)

   389

   390

   391

def getDownloadUrl(ctx, argument):

   392

    if lastKnownConfig is not None:

   393

        return url.URL.fromContext(ctx).\

   394

            child(WAMP_SECRET_URL).\

   395

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

   396

   397

   398

webFormInterface = [

   399

    ("status",

   400

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

   401

                     immutable=True,

   402

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

   403

    ("ID",

   404

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

   405

                     default=wampConfigDefault)),

   406

    ("secretfile",

   407

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

   408

                        download_url=getDownloadUrl)),

   409

    ("active",

   410

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

   411

                      default=wampConfigDefault)),

   412

    ("url",

   413

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

   414

                     default=wampConfigDefault))]

   415

   416

   417

def deliverWampSecret(ctx, segments):

   418

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

   419

   420

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

   421

    # for now all url under /secret returns the secret

   422

   423

    # TODO: make beautifull message in case of exception

   424

    # while loading secret (if empty or dont exist)

   425

    secret = LoadWampSecret(_WampSecret)

   426

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

   427

   428

   429

def RegisterWebSettings(NS):

   430

   431

    NS.ConfigurableSettings.addSettings(

   432

        "wamp",

   433

        _("Wamp Settings"),

   434

        webFormInterface,

   435

        _("Set"),

   436

        wampConfig)

   437

   438

    NS.customSettingsURLs[WAMP_SECRET_URL] = deliverWampSecret