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

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

    ("GetPLCID", {}),

    59

    ("SeedBlob", {}),

    60

    ("AppendChunkToBlob", {}),

    61

    ("PurgeBlobs", {}),

    62

    ("NewPLC", {}),

    63

    ("RepairPLC", {}),

    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

    "clientFactoryOptions": {

    79

        "maxDelay": 300

    80

    },

    81

    "protocolOptions": {

    82

        "autoPingInterval": 10,

    83

        "autoPingTimeout": 5

    84

    }

    85

}

    86

    87

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

    88

# or User python code.

    89

    90

""" crossbar Events to register to """

    91

SubscribedEvents = []

    92

    93

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

    94

DoOnJoin = []

    95

    96

lastKnownConfig = None

    97

    98

    99

def GetCallee(name):

   100

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

   101

    names = name.split('.')

   102

    obj = GetPLCObjectSingleton()

   103

    while names:

   104

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

   105

    return obj

   106

   107

   108

class WampSession(wamp.ApplicationSession):

   109

   110

    def onConnect(self):

   111

        if "secret" in self.config.extra:

   112

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

   113

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

   114

        else:

   115

            self.join(u"Automation")

   116

   117

    def onChallenge(self, challenge):

   118

        if challenge.method == u"wampcra":

   119

            if "secret" in self.config.extra:

   120

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

   121

                signature = auth.compute_wcs(

   122

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

   123

                return signature.decode("ascii")

   124

            else:

   125

                raise Exception("no secret given for authentication")

   126

        else:

   127

            raise Exception(

   128

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

   129

   130

    def onJoin(self, details):

   131

        global _WampSession

   132

        _WampSession = self

   133

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

   134

   135

        for name, kwargs in ExposedCalls:

   136

            try:

   137

                registerOptions = types.RegisterOptions(**kwargs)

   138

            except TypeError as e:

   139

                registerOptions = None

   140

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

   141

   142

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

   143

   144

        for name in SubscribedEvents:

   145

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

   146

   147

        for func in DoOnJoin:

   148

            func(self)

   149

   150

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

   151

   152

    def onLeave(self, details):

   153

        global _WampSession, _transportFactory

   154

        super(WampSession, self).onLeave(details)

   155

        _WampSession = None

   156

        _transportFactory = None

   157

        print(_('WAMP session left'))

   158

   159

    def publishWithOwnID(self, eventID, value):

   160

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

   161

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

   162

   163

   164

class ReconnectingWampWebSocketClientFactory(WampWebSocketClientFactory, ReconnectingClientFactory):

   165

   166

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

   167

        global _transportFactory

   168

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

   169

   170

        try:

   171

            clientFactoryOptions = config.extra.get("clientFactoryOptions")

   172

            if clientFactoryOptions:

   173

                self.setClientFactoryOptions(clientFactoryOptions)

   174

        except Exception as e:

   175

            print(_("Custom client factory options failed : "), e)

   176

            _transportFactory = None

   177

   178

        try:

   179

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

   180

            if protocolOptions:

   181

                self.setProtocolOptions(**protocolOptions)

   182

            _transportFactory = self

   183

        except Exception as e:

   184

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

   185

            _transportFactory = None

   186

   187

    def setClientFactoryOptions(self, options):

   188

        for key, value in options.items():

   189

            if key in ["maxDelay", "initialDelay", "maxRetries", "factor", "jitter"]:

   190

                setattr(self, key, value)

   191

   192

    def buildProtocol(self, addr):

   193

        self.resetDelay()

   194

        return ReconnectingClientFactory.buildProtocol(self, addr)

   195

   196

    def clientConnectionFailed(self, connector, reason):

   197

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

   198

              time.ctime())

   199

        super(ReconnectingWampWebSocketClientFactory,

   200

              self).clientConnectionFailed(connector, reason)

   201

   202

    def clientConnectionLost(self, connector, reason):

   203

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

   204

              time.ctime())

   205

        super(ReconnectingWampWebSocketClientFactory,

   206

              self).clientConnectionFailed(connector, reason)

   207

   208

   209

def CheckConfiguration(WampClientConf):

   210

    url = WampClientConf["url"]

   211

    if not IsCorrectUri(url):

   212

        raise annotate.ValidateError(

   213

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

   214

            _("WAMP configuration error:"))

   215

   216

def UpdateWithDefault(d1, d2):

   217

    for k, v in d2.items():

   218

        d1.setdefault(k, v)

   219

   220

def GetConfiguration():

   221

    global lastKnownConfig

   222

   223

    WampClientConf = None

   224

   225

    if os.path.exists(_WampConf):

   226

        try: 

   227

            WampClientConf = json.load(open(_WampConf))

   228

            UpdateWithDefault(WampClientConf, defaultWampConfig)

   229

        except ValueError:

   230

            pass

   231

   232

    if WampClientConf is None:

   233

        WampClientConf = defaultWampConfig.copy()

   234

   235

    for itemName in mandatoryConfigItems:

   236

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

   237

            raise Exception(

   238

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

   239

   240

    CheckConfiguration(WampClientConf)

   241

   242

    lastKnownConfig = WampClientConf.copy()

   243

    return WampClientConf

   244

   245

   246

def SetWampSecret(wampSecret):

   247

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

   248

        f.write(wampSecret)

   249

   250

   251

def SetConfiguration(WampClientConf):

   252

    global lastKnownConfig

   253

   254

    CheckConfiguration(WampClientConf)

   255

   256

    lastKnownConfig = WampClientConf.copy()

   257

   258

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

   259

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

   260

    StopReconnectWampClient()

   261

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

   262

        StartReconnectWampClient()

   263

   264

    return WampClientConf

   265

   266

   267

def LoadWampSecret(secretfname):

   268

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

   269

    if len(WSClientWampSecret) == 0:

   270

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

   271

    return WSClientWampSecret

   272

   273

   274

def IsCorrectUri(uri):

   275

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

   276

   277

   278

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

   279

    global _WampConf, _WampSecret

   280

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

   281

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

   282

   283

    # set config file path only if not already set

   284

    if _WampConf is None:

   285

        # default project's wampconf has precedance over commandline given

   286

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

   287

            _WampConf = _WampConfDefault

   288

        else:

   289

            _WampConf = wampconf

   290

   291

    WampClientConf = GetConfiguration()

   292

   293

    # set secret file path only if not already set

   294

    if _WampSecret is None:

   295

        # default project's wamp secret also

   296

        # has precedance over commandline given

   297

        if os.path.exists(_WampSecretDefault):

   298

            _WampSecret = _WampSecretDefault

   299

        else:

   300

            _WampSecret = wampsecret

   301

   302

    if _WampSecret is not None:

   303

        WampClientConf["secret"] = LoadWampSecret(_WampSecret)

   304

    else:

   305

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

   306

        _WampSecret = _WampSecretDefault

   307

   308

    if not WampClientConf["active"]:

   309

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

   310

        return

   311

   312

    # create a WAMP application session factory

   313

    component_config = types.ComponentConfig(

   314

        realm=WampClientConf["realm"],

   315

        extra=WampClientConf)

   316

    session_factory = wamp.ApplicationSessionFactory(

   317

        config=component_config)

   318

    session_factory.session = WampSession

   319

   320

    # create a WAMP-over-WebSocket transport client factory

   321

    ReconnectingWampWebSocketClientFactory(

   322

        component_config,

   323

        session_factory,

   324

        url=WampClientConf["url"],

   325

        serializers=[MsgPackSerializer()])

   326

   327

    # start the client from a Twisted endpoint

   328

    if _transportFactory:

   329

        connectWS(_transportFactory)

   330

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

   331

        return True

   332

    else:

   333

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

   334

        return False

   335

   336

   337

def StopReconnectWampClient():

   338

    if _transportFactory is not None:

   339

        _transportFactory.stopTrying()

   340

    if _WampSession is not None:

   341

        _WampSession.leave()

   342

   343

   344

def StartReconnectWampClient():

   345

    if _WampSession:

   346

        # do reconnect and reset continueTrying and initialDelay parameter

   347

        if _transportFactory is not None:

   348

            _transportFactory.resetDelay()

   349

        _WampSession.disconnect()

   350

        return True

   351

    else:

   352

        # do connect

   353

        RegisterWampClient()

   354

        return True

   355

   356

   357

def GetSession():

   358

    return _WampSession

   359

   360

   361

def getWampStatus():

   362

    if _transportFactory is not None:

   363

        if _WampSession is not None:

   364

            if _WampSession.is_attached():

   365

                return "Attached"

   366

            return "Established"

   367

        return "Connecting"

   368

    return "Disconnected"

   369

   370

   371

def PublishEvent(eventID, value):

   372

    if getWampStatus() == "Attached":

   373

        _WampSession.publish(text(eventID), value)

   374

   375

   376

def PublishEventWithOwnID(eventID, value):

   377

    if getWampStatus() == "Attached":

   378

        _WampSession.publishWithOwnID(text(eventID), value)

   379

   380

   381

# WEB CONFIGURATION INTERFACE

   382

WAMP_SECRET_URL = "secret"

   383

webExposedConfigItems = [

   384

    'active', 'url', 'ID',

   385

    "clientFactoryOptions.maxDelay",

   386

    "protocolOptions.autoPingInterval",

   387

    "protocolOptions.autoPingTimeout"

   388

]

   389

   390

   391

def wampConfigDefault(ctx, argument):

   392

    if lastKnownConfig is not None:

   393

        # Check if name is composed with an intermediate dot symbol and go deep in lastKnownConfig if it is

   394

        argument_name_path = argument.name.split(".")

   395

        searchValue = lastKnownConfig

   396

        while argument_name_path:

   397

            if searchValue:

   398

                searchValue = searchValue.get(argument_name_path.pop(0), None)

   399

            else:

   400

                break

   401

        return searchValue

   402

   403

   404

def wampConfig(**kwargs):

   405

    secretfile_field = kwargs["secretfile"]

   406

    if secretfile_field is not None:

   407

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

   408

        if secretfile is not None:

   409

            secret = secretfile_field.file.read()

   410

            SetWampSecret(secret)

   411

   412

    newConfig = lastKnownConfig.copy()

   413

    for argname in webExposedConfigItems:

   414

        # Check if name is composed with an intermediate dot symbol and go deep in lastKnownConfig if it is

   415

        #  and then set a new value.

   416

        argname_path = argname.split(".")

   417

        arg_last = argname_path.pop()

   418

        arg = kwargs.get(argname, None)

   419

        if arg is not None:

   420

            tmpConf = newConfig

   421

            while argname_path:

   422

                tmpConf = tmpConf.setdefault(argname_path.pop(0), {})

   423

            tmpConf[arg_last] = arg

   424

   425

    SetConfiguration(newConfig)

   426

   427

   428

class FileUploadDownload(annotate.FileUpload):

   429

    pass

   430

   431

   432

class FileUploadDownloadRenderer(webform.FileUploadRenderer):

   433

   434

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

   435

        # pylint: disable=expression-not-assigned

   436

        slot[_("Upload:")]

   437

        slot = webform.FileUploadRenderer.input(

   438

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

   439

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

   440

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

   441

   442

   443

registerAdapter(FileUploadDownloadRenderer, FileUploadDownload,

   444

                formless.iformless.ITypedRenderer)

   445

   446

   447

def getDownloadUrl(ctx, argument):

   448

    if lastKnownConfig is not None:

   449

        return url.URL.fromContext(ctx).\

   450

            child(WAMP_SECRET_URL).\

   451

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

   452

   453

   454

webFormInterface = [

   455

    ("status",

   456

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

   457

                     immutable=True,

   458

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

   459

    ("ID",

   460

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

   461

                     default=wampConfigDefault)),

   462

    ("secretfile",

   463

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

   464

                        download_url=getDownloadUrl)),

   465

    ("active",

   466

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

   467

                      default=wampConfigDefault)),

   468

    ("url",

   469

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

   470

                     default=wampConfigDefault)),

   471

    ("clientFactoryOptions.maxDelay",

   472

     annotate.Integer(label=_("Max reconnection delay (s)"),

   473

                      default=wampConfigDefault)),

   474

    ("protocolOptions.autoPingInterval",

   475

     annotate.Integer(label=_("Auto ping interval (s)"),

   476

                      default=wampConfigDefault)),

   477

    ("protocolOptions.autoPingTimeout",

   478

     annotate.Integer(label=_("Auto ping timeout (s)"),

   479

                      default=wampConfigDefault))

   480

    ]

   481