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

    "clientFactoryOptions": {

    80

        "maxDelay": 300

    81

    },

    82

    "protocolOptions": {

    83

        "autoPingInterval": 10,

    84

        "autoPingTimeout": 5

    85

    }

    86

}

    87

    88

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

    89

# or User python code.

    90

    91

""" crossbar Events to register to """

    92

SubscribedEvents = []

    93

    94

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

    95

DoOnJoin = []

    96

    97

lastKnownConfig = None

    98

    99

   100

def GetCallee(name):

   101

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

   102

    names = name.split('.')

   103

    obj = GetPLCObjectSingleton()

   104

    while names:

   105

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

   106

    return obj

   107

   108

   109

class WampSession(wamp.ApplicationSession):

   110

   111

    def onConnect(self):

   112

        if "secret" in self.config.extra:

   113

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

   114

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

   115

        else:

   116

            self.join(u"Automation")

   117

   118

    def onChallenge(self, challenge):

   119

        if challenge.method == u"wampcra":

   120

            if "secret" in self.config.extra:

   121

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

   122

                signature = auth.compute_wcs(

   123

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

   124

                return signature.decode("ascii")

   125

            else:

   126

                raise Exception("no secret given for authentication")

   127

        else:

   128

            raise Exception(

   129

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

   130

   131

    def onJoin(self, details):

   132

        global _WampSession

   133

        _WampSession = self

   134

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

   135

   136

        for name, kwargs in ExposedCalls:

   137

            try:

   138

                registerOptions = types.RegisterOptions(**kwargs)

   139

            except TypeError as e:

   140

                registerOptions = None

   141

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

   142

   143

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

   144

   145

        for name in SubscribedEvents:

   146

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

   147

   148

        for func in DoOnJoin:

   149

            func(self)

   150

   151

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

   152

   153

    def onLeave(self, details):

   154

        global _WampSession, _transportFactory

   155

        super(WampSession, self).onLeave(details)

   156

        _WampSession = None

   157

        _transportFactory = None

   158

        print(_('WAMP session left'))

   159

   160

    def publishWithOwnID(self, eventID, value):

   161

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

   162

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

   163

   164

   165

class ReconnectingWampWebSocketClientFactory(WampWebSocketClientFactory, ReconnectingClientFactory):

   166

   167

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

   168

        global _transportFactory

   169

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

   170

   171

        try:

   172

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

   173

            if clientFactoryOptions:

   174

                self.setClientFactoryOptions(clientFactoryOptions)

   175

        except Exception as e:

   176

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

   177

            _transportFactory = None

   178

   179

        try:

   180

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

   181

            if protocolOptions:

   182

                self.setProtocolOptions(**protocolOptions)

   183

            _transportFactory = self

   184

        except Exception as e:

   185

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

   186

            _transportFactory = None

   187

   188

    def setClientFactoryOptions(self, options):

   189

        for key, value in options.items():

   190

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

   191

                setattr(self, key, value)

   192

   193

    def buildProtocol(self, addr):

   194

        self.resetDelay()

   195

        return ReconnectingClientFactory.buildProtocol(self, addr)

   196

   197

    def clientConnectionFailed(self, connector, reason):

   198

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

   199

              time.ctime())

   200

        super(ReconnectingWampWebSocketClientFactory,

   201

              self).clientConnectionFailed(connector, reason)

   202

   203

    def clientConnectionLost(self, connector, reason):

   204

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

   205

              time.ctime())

   206

        super(ReconnectingWampWebSocketClientFactory,

   207

              self).clientConnectionFailed(connector, reason)

   208

   209

   210

def CheckConfiguration(WampClientConf):

   211

    url = WampClientConf["url"]

   212

    if not IsCorrectUri(url):

   213

        raise annotate.ValidateError(

   214

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

   215

            _("WAMP configuration error:"))

   216

   217

def UpdateWithDefault(d1, d2):

   218

    for k, v in d2.items():

   219

        d1.setdefault(k, v)

   220

   221

def GetConfiguration():

   222

    global lastKnownConfig

   223

   224

    WampClientConf = None

   225

   226

    if os.path.exists(_WampConf):

   227

        try: 

   228

            WampClientConf = json.load(open(_WampConf))

   229

            UpdateWithDefault(WampClientConf, defaultWampConfig)

   230

        except ValueError:

   231

            pass

   232

   233

    if WampClientConf is None:

   234

        WampClientConf = defaultWampConfig.copy()

   235

   236

    for itemName in mandatoryConfigItems:

   237

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

   238

            raise Exception(

   239

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

   240

   241

    CheckConfiguration(WampClientConf)

   242

   243

    lastKnownConfig = WampClientConf.copy()

   244

    return WampClientConf

   245

   246

   247

def SetWampSecret(wampSecret):

   248

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

   249

        f.write(wampSecret)

   250

   251

   252

def SetConfiguration(WampClientConf):

   253

    global lastKnownConfig

   254

   255

    CheckConfiguration(WampClientConf)

   256

   257

    lastKnownConfig = WampClientConf.copy()

   258

   259

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

   260

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

   261

    StopReconnectWampClient()

   262

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

   263

        StartReconnectWampClient()

   264

   265

    return WampClientConf

   266

   267

   268

def LoadWampSecret(secretfname):

   269

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

   270

    if len(WSClientWampSecret) == 0:

   271

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

   272

    return WSClientWampSecret

   273

   274

   275

def IsCorrectUri(uri):

   276

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

   277

   278

   279

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

   280

    global _WampConf, _WampSecret

   281

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

   282

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

   283

   284

    # set config file path only if not already set

   285

    if _WampConf is None:

   286

        # default project's wampconf has precedance over commandline given

   287

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

   288

            _WampConf = _WampConfDefault

   289

        else:

   290

            _WampConf = wampconf

   291

   292

    WampClientConf = GetConfiguration()

   293

   294

    # set secret file path only if not already set

   295

    if _WampSecret is None:

   296

        # default project's wamp secret also

   297

        # has precedance over commandline given

   298

        if os.path.exists(_WampSecretDefault):

   299

            _WampSecret = _WampSecretDefault

   300

        else:

   301

            _WampSecret = wampsecret

   302

   303

    if _WampSecret is not None:

   304

        WampClientConf["secret"] = LoadWampSecret(_WampSecret)

   305

    else:

   306

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

   307

        _WampSecret = _WampSecretDefault

   308

   309

    if not WampClientConf["active"]:

   310

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

   311

        return

   312

   313

    # create a WAMP application session factory

   314

    component_config = types.ComponentConfig(

   315

        realm=WampClientConf["realm"],

   316

        extra=WampClientConf)

   317

    session_factory = wamp.ApplicationSessionFactory(

   318

        config=component_config)

   319

    session_factory.session = WampSession

   320

   321

    # create a WAMP-over-WebSocket transport client factory

   322

    ReconnectingWampWebSocketClientFactory(

   323

        component_config,

   324

        session_factory,

   325

        url=WampClientConf["url"],

   326

        serializers=[MsgPackSerializer()])

   327

   328

    # start the client from a Twisted endpoint

   329

    if _transportFactory:

   330

        connectWS(_transportFactory)

   331

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

   332

        return True

   333

    else:

   334

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

   335

        return False

   336

   337

   338

def StopReconnectWampClient():

   339

    if _transportFactory is not None:

   340

        _transportFactory.stopTrying()

   341

    if _WampSession is not None:

   342

        _WampSession.leave()

   343

   344

   345

def StartReconnectWampClient():

   346

    if _WampSession:

   347

        # do reconnect and reset continueTrying and initialDelay parameter

   348

        if _transportFactory is not None:

   349

            _transportFactory.resetDelay()

   350

        _WampSession.disconnect()

   351

        return True

   352

    else:

   353

        # do connect

   354

        RegisterWampClient()

   355

        return True

   356

   357

   358

def GetSession():

   359

    return _WampSession

   360

   361

   362

def getWampStatus():

   363

    if _transportFactory is not None:

   364

        if _WampSession is not None:

   365

            if _WampSession.is_attached():

   366

                return "Attached"

   367

            return "Established"

   368

        return "Connecting"

   369

    return "Disconnected"

   370

   371

   372

def SetServer(pysrv):

   373

    global _PySrv

   374

    _PySrv = pysrv

   375

   376

   377

def PublishEvent(eventID, value):

   378

    if getWampStatus() == "Attached":

   379

        _WampSession.publish(text(eventID), value)

   380

   381

   382

def PublishEventWithOwnID(eventID, value):

   383

    if getWampStatus() == "Attached":

   384

        _WampSession.publishWithOwnID(text(eventID), value)

   385

   386

   387

# WEB CONFIGURATION INTERFACE

   388

WAMP_SECRET_URL = "secret"

   389

webExposedConfigItems = [

   390

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

   391

    "clientFactoryOptions.maxDelay",

   392

    "protocolOptions.autoPingInterval",

   393

    "protocolOptions.autoPingTimeout"

   394

]

   395

   396

   397

def wampConfigDefault(ctx, argument):

   398

    if lastKnownConfig is not None:

   399

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

   400

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

   401

        searchValue = lastKnownConfig

   402

        while argument_name_path:

   403

            if searchValue:

   404

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

   405

            else:

   406

                break

   407

        return searchValue

   408

   409

   410

def wampConfig(**kwargs):

   411

    secretfile_field = kwargs["secretfile"]

   412

    if secretfile_field is not None:

   413

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

   414

        if secretfile is not None:

   415

            secret = secretfile_field.file.read()

   416

            SetWampSecret(secret)

   417

   418

    newConfig = lastKnownConfig.copy()

   419

    for argname in webExposedConfigItems:

   420

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

   421

        #  and then set a new value.

   422

        argname_path = argname.split(".")

   423

        arg_last = argname_path.pop()

   424

        arg = kwargs.get(argname, None)

   425

        if arg is not None:

   426

            tmpConf = newConfig

   427

            while argname_path:

   428

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

   429

            tmpConf[arg_last] = arg

   430

   431

    SetConfiguration(newConfig)

   432

   433

   434

class FileUploadDownload(annotate.FileUpload):

   435

    pass

   436

   437

   438

class FileUploadDownloadRenderer(webform.FileUploadRenderer):

   439

   440

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

   441

        # pylint: disable=expression-not-assigned

   442

        slot[_("Upload:")]

   443

        slot = webform.FileUploadRenderer.input(

   444

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

   445

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

   446

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

   447

   448

   449

registerAdapter(FileUploadDownloadRenderer, FileUploadDownload,

   450

                formless.iformless.ITypedRenderer)

   451

   452

   453

def getDownloadUrl(ctx, argument):

   454

    if lastKnownConfig is not None:

   455

        return url.URL.fromContext(ctx).\

   456

            child(WAMP_SECRET_URL).\

   457

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

   458

   459

   460

webFormInterface = [

   461

    ("status",

   462

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

   463

                     immutable=True,

   464

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

   465

    ("ID",

   466

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

   467

                     default=wampConfigDefault)),

   468

    ("secretfile",

   469

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

   470

                        download_url=getDownloadUrl)),

   471

    ("active",

   472

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

   473

                      default=wampConfigDefault)),

   474

    ("url",

   475

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

   476

                     default=wampConfigDefault)),

   477

    ("clientFactoryOptions.maxDelay",

   478

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

   479

                      default=wampConfigDefault)),

   480

    ("protocolOptions.autoPingInterval",

   481

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