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

import time

    26

import json

    27

import os

    28

import re

    29

from autobahn.twisted import wamp

    30

from autobahn.twisted.websocket import WampWebSocketClientFactory, connectWS

    31

from autobahn.wamp import types, auth

    32

from autobahn.wamp.serializer import MsgPackSerializer

    33

from twisted.internet.protocol import ReconnectingClientFactory

    34

from twisted.python.components import registerAdapter

    35

    36

from formless import annotate, webform

    37

import formless

    38

from nevow import tags, url, static

    39

from runtime import GetPLCObjectSingleton

    40

    41

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

    42

    43

_transportFactory = None

    44

_WampSession = None

    45

WorkingDir = None

    46

    47

# Find pre-existing project WAMP config file

    48

_WampConf = None

    49

_WampSecret = None

    50

    51

ExposedCalls = [

    52

    ("StartPLC", {}),

    53

    ("StopPLC", {}),

    54

    ("GetPLCstatus", {}),

    55

    ("GetPLCID", {}),

    56

    ("SeedBlob", {}),

    57

    ("AppendChunkToBlob", {}),

    58

    ("PurgeBlobs", {}),

    59

    ("NewPLC", {}),

    60

    ("RepairPLC", {}),

    61

    ("MatchMD5", {}),

    62

    ("SetTraceVariablesList", {}),

    63

    ("GetTraceVariables", {}),

    64

    ("RemoteExec", {}),

    65

    ("GetLogMessage", {}),

    66

    ("ResetLogCount", {})

    67

]

    68

    69

# de-activated dumb wamp config

    70

defaultWampConfig = {

    71

    "ID": "wamptest",

    72

    "active": False,

    73

    "realm": "Automation",

    74

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

    75

    "clientFactoryOptions": {

    76

        "maxDelay": 300

    77

    },

    78

    "protocolOptions": {

    79

        "autoPingInterval": 10,

    80

        "autoPingTimeout": 5

    81

    }

    82

}

    83

    84

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

    85

# or User python code.

    86

    87

""" crossbar Events to register to """

    88

SubscribedEvents = []

    89

    90

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

    91

DoOnJoin = []

    92

    93

lastKnownConfig = None

    94

    95

    96

def GetCallee(name):

    97

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

    98

    names = name.split('.')

    99

    obj = GetPLCObjectSingleton()

   100

    while names:

   101

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

   102

    return obj

   103

   104

   105

class WampSession(wamp.ApplicationSession):

   106

   107

    def onConnect(self):

   108

        if "secret" in self.config.extra:

   109

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

   110

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

   111

        else:

   112

            self.join("Automation")

   113

   114

    def onChallenge(self, challenge):

   115

        if challenge.method == "wampcra":

   116

            if "secret" in self.config.extra:

   117

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

   118

                signature = auth.compute_wcs(

   119

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

   120

                return signature.decode("ascii")

   121

            else:

   122

                raise Exception("no secret given for authentication")

   123

        else:

   124

            raise Exception(

   125

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

   126

   127

    def onJoin(self, details):

   128

        global _WampSession

   129

        _WampSession = self

   130

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

   131

   132

        for name, kwargs in ExposedCalls:

   133

            try:

   134

                registerOptions = types.RegisterOptions(**kwargs)

   135

            except TypeError as e:

   136

                registerOptions = None

   137

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

   138

   139

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

   140

   141

        for name in SubscribedEvents:

   142

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

   143

   144

        for func in DoOnJoin:

   145

            func(self)

   146

   147

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

   148

   149

    def onLeave(self, details):

   150

        global _WampSession, _transportFactory

   151

        super(WampSession, self).onLeave(details)

   152

        _WampSession = None

   153

        _transportFactory = None

   154

        print(_('WAMP session left'))

   155

   156

    def publishWithOwnID(self, eventID, value):

   157

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

   158

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

   159

   160

   161

class ReconnectingWampWebSocketClientFactory(WampWebSocketClientFactory, ReconnectingClientFactory):

   162

   163

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

   164

        global _transportFactory

   165

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

   166

   167

        try:

   168

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

   169

            if clientFactoryOptions:

   170

                self.setClientFactoryOptions(clientFactoryOptions)

   171

        except Exception as e:

   172

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

   173

            _transportFactory = None

   174

   175

        try:

   176

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

   177

            if protocolOptions:

   178

                self.setProtocolOptions(**protocolOptions)

   179

            _transportFactory = self

   180

        except Exception as e:

   181

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

   182

            _transportFactory = None

   183

   184

    def setClientFactoryOptions(self, options):

   185

        for key, value in list(options.items()):

   186

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

   187

                setattr(self, key, value)

   188

   189

    def buildProtocol(self, addr):

   190

        self.resetDelay()

   191

        return ReconnectingClientFactory.buildProtocol(self, addr)

   192

   193

    def clientConnectionFailed(self, connector, reason):

   194

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

   195

              time.ctime())

   196

        super(ReconnectingWampWebSocketClientFactory,

   197

              self).clientConnectionFailed(connector, reason)

   198

   199

    def clientConnectionLost(self, connector, reason):

   200

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

   201

              time.ctime())

   202

        super(ReconnectingWampWebSocketClientFactory,

   203

              self).clientConnectionFailed(connector, reason)

   204

   205

   206

def CheckConfiguration(WampClientConf):

   207

    url = WampClientConf["url"]

   208

    if not IsCorrectUri(url):

   209

        raise annotate.ValidateError(

   210

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

   211

            _("WAMP configuration error:"))

   212

   213

def UpdateWithDefault(d1, d2):

   214

    for k, v in list(d2.items()):

   215

        d1.setdefault(k, v)

   216

   217

def GetConfiguration():

   218

    global lastKnownConfig

   219

   220

    WampClientConf = None

   221

   222

    if os.path.exists(_WampConf):

   223

        try: 

   224

            WampClientConf = json.load(open(_WampConf))

   225

            UpdateWithDefault(WampClientConf, defaultWampConfig)

   226

        except ValueError:

   227

            pass

   228

   229

    if WampClientConf is None:

   230

        WampClientConf = defaultWampConfig.copy()

   231

   232

    for itemName in mandatoryConfigItems:

   233

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

   234

            raise Exception(

   235

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

   236

   237

    CheckConfiguration(WampClientConf)

   238

   239

    lastKnownConfig = WampClientConf.copy()

   240

    return WampClientConf

   241

   242

   243

def SetWampSecret(wampSecret):

   244

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

   245

        f.write(wampSecret)

   246

   247

   248

def SetConfiguration(WampClientConf):

   249

    global lastKnownConfig

   250

   251

    CheckConfiguration(WampClientConf)

   252

   253

    lastKnownConfig = WampClientConf.copy()

   254

   255

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

   256

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

   257

    StopReconnectWampClient()

   258

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

   259

        StartReconnectWampClient()

   260

   261

    return WampClientConf

   262

   263

   264

def LoadWampSecret(secretfname):

   265

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

   266

    if len(WSClientWampSecret) == 0:

   267

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

   268

    return WSClientWampSecret

   269

   270

   271

def IsCorrectUri(uri):

   272

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

   273

   274

   275

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

   276

    global _WampConf, _WampSecret

   277

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

   278

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

   279

   280

    # set config file path only if not already set

   281

    if _WampConf is None:

   282

        # default project's wampconf has precedance over commandline given

   283

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

   284

            _WampConf = _WampConfDefault

   285

        else:

   286

            _WampConf = wampconf

   287

   288

    WampClientConf = GetConfiguration()

   289

   290

    # set secret file path only if not already set

   291

    if _WampSecret is None:

   292

        # default project's wamp secret also

   293

        # has precedance over commandline given

   294

        if os.path.exists(_WampSecretDefault):

   295

            _WampSecret = _WampSecretDefault

   296

        else:

   297

            _WampSecret = wampsecret

   298

   299

    if _WampSecret is not None:

   300

        WampClientConf["secret"] = LoadWampSecret(_WampSecret)

   301

    else:

   302

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

   303

        _WampSecret = _WampSecretDefault

   304

   305

    if not WampClientConf["active"]:

   306

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

   307

        return

   308

   309

    # create a WAMP application session factory

   310

    component_config = types.ComponentConfig(

   311

        realm=WampClientConf["realm"],

   312

        extra=WampClientConf)

   313

    session_factory = wamp.ApplicationSessionFactory(

   314

        config=component_config)

   315

    session_factory.session = WampSession

   316

   317

    # create a WAMP-over-WebSocket transport client factory

   318

    ReconnectingWampWebSocketClientFactory(

   319

        component_config,

   320

        session_factory,

   321

        url=WampClientConf["url"],

   322

        serializers=[MsgPackSerializer()])

   323

   324

    # start the client from a Twisted endpoint

   325

    if _transportFactory:

   326

        connectWS(_transportFactory)

   327

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

   328

        return True

   329

    else:

   330

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

   331

        return False

   332

   333

   334

def StopReconnectWampClient():

   335

    if _transportFactory is not None:

   336

        _transportFactory.stopTrying()

   337

    if _WampSession is not None:

   338

        _WampSession.leave()

   339

   340

   341

def StartReconnectWampClient():

   342

    if _WampSession:

   343

        # do reconnect and reset continueTrying and initialDelay parameter

   344

        if _transportFactory is not None:

   345

            _transportFactory.resetDelay()

   346

        _WampSession.disconnect()

   347

        return True

   348

    else:

   349

        # do connect

   350

        RegisterWampClient()

   351

        return True

   352

   353

   354

def GetSession():

   355

    return _WampSession

   356

   357

   358

def getWampStatus():

   359

    if _transportFactory is not None:

   360

        if _WampSession is not None:

   361

            if _WampSession.is_attached():

   362

                return "Attached"

   363

            return "Established"

   364

        return "Connecting"

   365

    return "Disconnected"

   366

   367

   368

def PublishEvent(eventID, value):

   369

    if getWampStatus() == "Attached":

   370

        _WampSession.publish(str(eventID), value)

   371

   372

   373

def PublishEventWithOwnID(eventID, value):

   374

    if getWampStatus() == "Attached":

   375

        _WampSession.publishWithOwnID(str(eventID), value)

   376

   377

   378

# WEB CONFIGURATION INTERFACE

   379

WAMP_SECRET_URL = "secret"

   380

webExposedConfigItems = [

   381

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

   382

    "clientFactoryOptions.maxDelay",

   383

    "protocolOptions.autoPingInterval",

   384

    "protocolOptions.autoPingTimeout"

   385

]

   386

   387

   388

def wampConfigDefault(ctx, argument):

   389

    if lastKnownConfig is not None:

   390

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

   391

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

   392

        searchValue = lastKnownConfig

   393

        while argument_name_path:

   394

            if searchValue:

   395

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

   396

            else:

   397

                break

   398

        return searchValue

   399

   400

   401

def wampConfig(**kwargs):

   402

    secretfile_field = kwargs["secretfile"]

   403

    if secretfile_field is not None:

   404

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

   405

        if secretfile is not None:

   406

            secret = secretfile_field.file.read()

   407

            SetWampSecret(secret)

   408

   409

    newConfig = lastKnownConfig.copy()

   410

    for argname in webExposedConfigItems:

   411

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

   412

        #  and then set a new value.

   413

        argname_path = argname.split(".")

   414

        arg_last = argname_path.pop()

   415

        arg = kwargs.get(argname, None)

   416

        if arg is not None:

   417

            tmpConf = newConfig

   418

            while argname_path:

   419

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

   420

            tmpConf[arg_last] = arg

   421

   422

    SetConfiguration(newConfig)

   423

   424

   425

class FileUploadDownload(annotate.FileUpload):

   426

    pass

   427

   428

   429

class FileUploadDownloadRenderer(webform.FileUploadRenderer):

   430

   431

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

   432

        # pylint: disable=expression-not-assigned

   433

        slot[_("Upload:")]

   434

        slot = webform.FileUploadRenderer.input(

   435

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

   436

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

   437

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

   438

   439

   440

registerAdapter(FileUploadDownloadRenderer, FileUploadDownload,

   441

                formless.iformless.ITypedRenderer)

   442

   443

   444

def getDownloadUrl(ctx, argument):

   445

    if lastKnownConfig is not None:

   446

        return url.URL.fromContext(ctx).\

   447

            child(WAMP_SECRET_URL).\

   448

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

   449

   450

   451

webFormInterface = [

   452

    ("status",

   453

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

   454

                     immutable=True,

   455

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

   456

    ("ID",

   457

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

   458

                     default=wampConfigDefault)),

   459

    ("secretfile",

   460

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

   461

                        download_url=getDownloadUrl)),

   462

    ("active",

   463

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

   464

                      default=wampConfigDefault)),

   465

    ("url",

   466

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

   467

                     default=wampConfigDefault)),

   468

    ("clientFactoryOptions.maxDelay",

   469

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

   470

                      default=wampConfigDefault)),

   471

    ("protocolOptions.autoPingInterval",

   472

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

   473

                      default=wampConfigDefault)),

   474

    ("protocolOptions.autoPingTimeout",

   475

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

   476

                      default=wampConfigDefault))

   477

    ]

   478

   479

def deliverWampSecret(ctx, segments):

   480

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

   481