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

    WampClientConf = None

   202

   203

    if os.path.exists(_WampConf):

   204

        try: 

   205

            WampClientConf = json.load(open(_WampConf))

   206

        except ValueError:

   207

            pass

   208

   209

    if WampClientConf is None:

   210

        WampClientConf = defaultWampConfig.copy()

   211

   212

    for itemName in mandatoryConfigItems:

   213

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

   214

            raise Exception(

   215

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

   216

   217

    CheckConfiguration(WampClientConf)

   218

   219

    lastKnownConfig = WampClientConf.copy()

   220

    return WampClientConf

   221

   222

   223

def SetWampSecret(wampSecret):

   224

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

   225

        f.write(wampSecret)

   226

   227

   228

def SetConfiguration(WampClientConf):

   229

    global lastKnownConfig

   230

   231

    CheckConfiguration(WampClientConf)

   232

   233

    lastKnownConfig = WampClientConf.copy()

   234

   235

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

   236

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

   237

    StopReconnectWampClient()

   238

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

   239

        StartReconnectWampClient()

   240

   241

    return WampClientConf

   242

   243

   244

def LoadWampSecret(secretfname):

   245

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

   246

    if len(WSClientWampSecret) == 0:

   247

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

   248

    return WSClientWampSecret

   249

   250

   251

def IsCorrectUri(uri):

   252

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

   253

   254

   255

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

   256

    global _WampConf, _WampSecret

   257

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

   258

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

   259

   260

    # set config file path only if not already set

   261

    if _WampConf is None:

   262

        # default project's wampconf has precedance over commandline given

   263

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

   264

            _WampConf = _WampConfDefault

   265

        else:

   266

            _WampConf = wampconf

   267

   268

    WampClientConf = GetConfiguration()

   269

   270

    # set secret file path only if not already set

   271

    if _WampSecret is None:

   272

        # default project's wamp secret also

   273

        # has precedance over commandline given

   274

        if os.path.exists(_WampSecretDefault):

   275

            _WampSecret = _WampSecretDefault

   276

        else:

   277

            _WampSecret = wampsecret

   278

   279

    if _WampSecret is not None:

   280

        WampClientConf["secret"] = LoadWampSecret(_WampSecret)

   281

    else:

   282

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

   283

        _WampSecret = _WampSecretDefault

   284

   285

    if not WampClientConf["active"]:

   286

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

   287

        return

   288

   289

    # create a WAMP application session factory

   290

    component_config = types.ComponentConfig(

   291

        realm=WampClientConf["realm"],

   292

        extra=WampClientConf)

   293

    session_factory = wamp.ApplicationSessionFactory(

   294

        config=component_config)

   295

    session_factory.session = WampSession

   296

   297

    # create a WAMP-over-WebSocket transport client factory

   298

    ReconnectingWampWebSocketClientFactory(

   299

        component_config,

   300

        session_factory,

   301

        url=WampClientConf["url"],

   302

        serializers=[MsgPackSerializer()])

   303

   304

    # start the client from a Twisted endpoint

   305

    if _transportFactory:

   306

        connectWS(_transportFactory)

   307

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

   308

        return True

   309

    else:

   310

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

   311

        return False

   312

   313

   314

def StopReconnectWampClient():

   315

    if _transportFactory is not None:

   316

        _transportFactory.stopTrying()

   317

    if _WampSession is not None:

   318

        _WampSession.leave()

   319

   320

   321

def StartReconnectWampClient():

   322

    if _WampSession:

   323

        # do reconnect

   324

        _WampSession.disconnect()

   325

        return True

   326

    else:

   327

        # do connect

   328

        RegisterWampClient()

   329

        return True

   330

   331

   332

def GetSession():

   333

    return _WampSession

   334

   335

   336

def getWampStatus():

   337

    if _transportFactory is not None:

   338

        if _WampSession is not None:

   339

            if _WampSession.is_attached():

   340

                return "Attached"

   341

            return "Established"

   342

        return "Connecting"

   343

    return "Disconnected"

   344

   345

   346

def SetServer(pysrv):

   347

    global _PySrv

   348

    _PySrv = pysrv

   349

   350

   351

def PublishEvent(eventID, value):

   352

    if getWampStatus() == "Attached":

   353

        _WampSession.publish(text(eventID), value)

   354

   355

   356

def PublishEventWithOwnID(eventID, value):

   357

    if getWampStatus() == "Attached":

   358

        _WampSession.publishWithOwnID(text(eventID), value)

   359

   360

   361

# WEB CONFIGURATION INTERFACE

   362

WAMP_SECRET_URL = "secret"

   363

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

   364

   365

   366

def wampConfigDefault(ctx, argument):

   367

    if lastKnownConfig is not None:

   368

        return lastKnownConfig.get(argument.name, None)

   369

   370

   371

def wampConfig(**kwargs):

   372

    secretfile_field = kwargs["secretfile"]

   373

    if secretfile_field is not None:

   374

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

   375

        if secretfile is not None:

   376

            secret = secretfile_field.file.read()

   377

            SetWampSecret(secret)

   378

   379

    newConfig = lastKnownConfig.copy()

   380

    for argname in webExposedConfigItems:

   381

        arg = kwargs.get(argname, None)

   382

        if arg is not None:

   383

            newConfig[argname] = arg

   384

   385

    SetConfiguration(newConfig)

   386

   387

   388

class FileUploadDownload(annotate.FileUpload):

   389

    pass

   390

   391

   392

class FileUploadDownloadRenderer(webform.FileUploadRenderer):

   393

   394

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

   395

        # pylint: disable=expression-not-assigned

   396

        slot[_("Upload:")]

   397

        slot = webform.FileUploadRenderer.input(

   398

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

   399

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

   400

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

   401

   402

   403

registerAdapter(FileUploadDownloadRenderer, FileUploadDownload,

   404

                formless.iformless.ITypedRenderer)

   405

   406

   407

def getDownloadUrl(ctx, argument):

   408

    if lastKnownConfig is not None:

   409

        return url.URL.fromContext(ctx).\

   410

            child(WAMP_SECRET_URL).\

   411

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

   412

   413

   414

webFormInterface = [

   415

    ("status",

   416

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

   417

                     immutable=True,

   418

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

   419

    ("ID",

   420

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

   421

                     default=wampConfigDefault)),

   422

    ("secretfile",

   423

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

   424

                        download_url=getDownloadUrl)),

   425

    ("active",

   426

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

   427

                      default=wampConfigDefault)),

   428

    ("url",

   429

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

   430

                     default=wampConfigDefault))]

   431

   432

   433

def deliverWampSecret(ctx, segments):

   434

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

   435

   436

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

   437

    # for now all url under /secret returns the secret

   438

   439

    # TODO: make beautifull message in case of exception

   440

    # while loading secret (if empty or dont exist)

   441

    secret = LoadWampSecret(_WampSecret)

   442

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

   443

   444

   445

def RegisterWebSettings(NS):

   446

   447

    NS.ConfigurableSettings.addSettings(

   448

        "wamp",

   449

        _("Wamp Settings"),

   450

        webFormInterface,

   451

        _("Set"),

   452

        wampConfig)

   453

   454

    NS.customSettingsURLs[WAMP_SECRET_URL] = deliverWampSecret