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

import shutil

    30

from autobahn.twisted import wamp

    31

from autobahn.twisted.websocket import WampWebSocketClientFactory, connectWS

    32

from autobahn.wamp import types, auth

    33

from autobahn.wamp.serializer import MsgPackSerializer

    34

from twisted.internet.protocol import ReconnectingClientFactory

    35

from twisted.python.components import registerAdapter

    36

from twisted.internet.ssl import optionsForClientTLS, CertificateOptions

    37

from twisted.internet._sslverify import OpenSSLCertificateAuthorities

    38

from OpenSSL import crypto

    39

    40

from formless import annotate, webform

    41

import formless

    42

from nevow import tags, url, static

    43

from runtime import GetPLCObjectSingleton

    44

from runtime.Stunnel import getPSKID

    45

    46

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

    47

    48

_transportFactory = None

    49

_WampSession = None

    50

WorkingDir = None

    51

    52

# Find pre-existing project WAMP config file

    53

_WampConf = None

    54

_WampSecret = None

    55

_WampTrust = None

    56

    57

ExposedCalls = [

    58

    ("StartPLC", {}),

    59

    ("StopPLC", {}),

    60

    ("GetPLCstatus", {}),

    61

    ("GetPLCID", {}),

    62

    ("SeedBlob", {}),

    63

    ("AppendChunkToBlob", {}),

    64

    ("PurgeBlobs", {}),

    65

    ("NewPLC", {}),

    66

    ("RepairPLC", {}),

    67

    ("MatchMD5", {}),

    68

    ("SetTraceVariablesList", {}),

    69

    ("GetTraceVariables", {}),

    70

    ("GetLogMessage", {}),

    71

    ("ResetLogCount", {}),

    72

    ("ExtendedCall", {})

    73

]

    74

    75

# de-activated dumb wamp config

    76

defaultWampConfig = {

    77

    "ID": "wamptest", # replaced by service name (-n in CLI)

    78

    "active": False,

    79

    "realm": "Automation",

    80

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

    81

    "clientFactoryOptions": {

    82

        "maxDelay": 300

    83

    },

    84

    "protocolOptions": {

    85

        "autoPingInterval": 10,

    86

        "autoPingTimeout": 5

    87

    },

    88

    "verifyHostname": True

    89

}

    90

    91

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

    92

# or User python code.

    93

    94

""" crossbar Events to register to """

    95

SubscribedEvents = []

    96

    97

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

    98

DoOnJoin = []

    99

   100

lastKnownConfig = None

   101

   102

   103

def GetCallee(name):

   104

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

   105

    names = name.split('.')

   106

    obj = GetPLCObjectSingleton()

   107

    while names:

   108

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

   109

    return obj

   110

   111

   112

class WampSession(wamp.ApplicationSession):

   113

   114

    def onConnect(self):

   115

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

   116

        self.join(self.config.realm, ["wampcra"], user)

   117

   118

    def onChallenge(self, challenge):

   119

        if challenge.method == "wampcra":

   120

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

   121

            if 'salt' in challenge.extra:

   122

                # salted secret

   123

                key = auth.derive_key(secret,

   124

                                      challenge.extra['salt'],

   125

                                      challenge.extra['iterations'],

   126

                                      challenge.extra['keylen'])

   127

            else:

   128

                # plain, unsalted secret

   129

                key = secret

   130

   131

            signature = auth.compute_wcs(key, challenge.extra['challenge'])

   132

            return signature

   133

        else:

   134

            raise Exception("Invalid authmethod {}".format(challenge.method))

   135

   136

    def onJoin(self, details):

   137

        global _WampSession

   138

        _WampSession = self

   139

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

   140

   141

        for name, kwargs in ExposedCalls:

   142

            try:

   143

                registerOptions = types.RegisterOptions(**kwargs)

   144

            except TypeError as e:

   145

                registerOptions = None

   146

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

   147

   148

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

   149

   150

        for name in SubscribedEvents:

   151

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

   152

   153

        for func in DoOnJoin:

   154

            func(self)

   155

   156

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

   157

   158

    def onLeave(self, details):

   159

        global _WampSession, _transportFactory

   160

        _WampSession = None

   161

        _transportFactory = None

   162

   163

    def publishWithOwnID(self, eventID, value):

   164

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

   165

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

   166

   167

   168

class ReconnectingWampWebSocketClientFactory(WampWebSocketClientFactory, ReconnectingClientFactory):

   169

   170

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

   171

        global _transportFactory

   172

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

   173

   174

        try:

   175

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

   176

            if clientFactoryOptions:

   177

                self.setClientFactoryOptions(clientFactoryOptions)

   178

        except Exception as e:

   179

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

   180

            _transportFactory = None

   181

   182

        try:

   183

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

   184

            if protocolOptions:

   185

                self.setProtocolOptions(**protocolOptions)

   186

            _transportFactory = self

   187

        except Exception as e:

   188

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

   189

            _transportFactory = None

   190

   191

    def setClientFactoryOptions(self, options):

   192

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

   193

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

   194

                setattr(self, key, value)

   195

   196

    def buildProtocol(self, addr):

   197

        self.resetDelay()

   198

        return ReconnectingClientFactory.buildProtocol(self, addr)

   199

   200

    def clientConnectionFailed(self, connector, reason):

   201

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

   202

              time.ctime())

   203

        super(ReconnectingWampWebSocketClientFactory,

   204

              self).clientConnectionFailed(connector, reason)

   205

   206

    def clientConnectionLost(self, connector, reason):

   207

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

   208

              time.ctime())

   209

        super(ReconnectingWampWebSocketClientFactory,

   210

              self).clientConnectionFailed(connector, reason)

   211

   212

   213

def CheckConfiguration(WampClientConf):

   214

    url = WampClientConf["url"]

   215

    if not IsCorrectUri(url):

   216

        raise annotate.ValidateError(

   217

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

   218

            _("WAMP configuration error:"))

   219

   220

def UpdateWithDefault(d1, d2):

   221

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

   222

        d1.setdefault(k, v)

   223

   224

def GetConfiguration():

   225

    global lastKnownConfig

   226

   227

    WampClientConf = None

   228

   229

    if os.path.exists(_WampConf):

   230

        try:

   231

            WampClientConf = json.load(open(_WampConf))

   232

            UpdateWithDefault(WampClientConf, defaultWampConfig)

   233

        except ValueError:

   234

            pass

   235

   236

    if WampClientConf is None:

   237

        WampClientConf = defaultWampConfig.copy()

   238

   239

    for itemName in mandatoryConfigItems:

   240

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

   241

            raise Exception(

   242

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

   243

   244

    CheckConfiguration(WampClientConf)

   245

   246

    lastKnownConfig = WampClientConf.copy()

   247

    return WampClientConf

   248

   249

   250

def SetConfiguration(WampClientConf):

   251

    global lastKnownConfig

   252

   253

    CheckConfiguration(WampClientConf)

   254

   255

    lastKnownConfig = WampClientConf.copy()

   256

   257

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

   258

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

   259

    StopReconnectWampClient()

   260

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

   261

        StartReconnectWampClient()

   262

   263

    return WampClientConf

   264

   265

   266

def LoadWampSecret(secretfname):

   267

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

   268

    if len(WSClientWampSecret) == 0:

   269

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

   270

    return WSClientWampSecret

   271

   272

   273

def IsCorrectUri(uri):

   274

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

   275

   276

   277

def RegisterWampClient(wampconf=None, wampsecret=None, ConfDir=None, KeyStore=None, servicename=None):

   278

    global _WampConf, _WampSecret, _WampTrust, defaultWampConfig

   279

   280

    if servicename:

   281

        defaultWampConfig["ID"] = servicename

   282

   283

    ConfDir = ConfDir if ConfDir else WorkingDir

   284

    KeyStore = KeyStore if KeyStore else WorkingDir

   285

   286

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

   287

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

   288

   289

    if _WampTrust is None:

   290

        _WampTrust = os.path.join(KeyStore, "wampTrustStore.crt")

   291

   292

    # set config file path only if not already set

   293

    if _WampConf is None:

   294

        # default project's wampconf has precedance over commandline given

   295

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

   296

            _WampConf = _WampConfDefault

   297

        else:

   298

            _WampConf = wampconf

   299

   300

    WampClientConf = GetConfiguration()

   301

   302

    # set secret file path only if not already set

   303

    if _WampSecret is None:

   304

        # default project's wamp secret also

   305

        # has precedance over commandline given

   306

        if os.path.exists(_WampSecretDefault):

   307

            _WampSecret = _WampSecretDefault

   308

        else:

   309

            _WampSecret = wampsecret

   310

   311

    if _WampSecret is not None:

   312

        if _WampSecret == _WampSecretDefault:

   313

            # secret from project dir is raw (no ID prefix)

   314

            secret = LoadWampSecret(_WampSecret)

   315

        else:

   316

            # secret from command line is formated ID:PSK

   317

            # fall back to PSK data (works because wampsecret is PSKpath)

   318

            _ID, secret = getPSKID()

   319

   320

        WampClientConf["secret"] = secret

   321

   322

    else:

   323

        raise Exception(_("WAMP no secret file given"))

   324

   325

    if not WampClientConf["active"]:

   326

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

   327

        return

   328

   329

    # create a WAMP application session factory

   330

    component_config = types.ComponentConfig(

   331

        realm=WampClientConf["realm"],

   332

        extra=WampClientConf)

   333

    session_factory = wamp.ApplicationSessionFactory(

   334

        config=component_config)

   335

    session_factory.session = WampSession

   336

   337

    # create a WAMP-over-WebSocket transport client factory

   338

    ReconnectingWampWebSocketClientFactory(

   339

        component_config,

   340

        session_factory,

   341

        url=WampClientConf["url"],

   342

        serializers=[MsgPackSerializer()])

   343

   344

    # start the client from a Twisted endpoint

   345

    if _transportFactory:

   346

        contextFactory=None

   347

        if _transportFactory.isSecure:

   348

            contextFactory = MakeSecureContextFactory(WampClientConf["verifyHostname"])

   349

   350

        connectWS(_transportFactory, contextFactory)

   351

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

   352

        return True

   353

    else:

   354

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

   355

        return False

   356

   357

def MakeSecureContextFactory(verifyHostname):

   358

    if not verifyHostname:

   359

        return None

   360

    trustRoot=None

   361

    if os.path.exists(_WampTrust):

   362

        cert = crypto.load_certificate(

   363

            crypto.FILETYPE_PEM,

   364

            open(_WampTrust, 'rb').read()

   365

        )

   366

        trustRoot=OpenSSLCertificateAuthorities([cert])

   367

    return optionsForClientTLS(_transportFactory.host, trustRoot=trustRoot)

   368

   369

def StopReconnectWampClient():

   370

    if _transportFactory is not None:

   371

        _transportFactory.stopTrying()

   372

    if _WampSession is not None:

   373

        _WampSession.leave()

   374

   375

   376

def StartReconnectWampClient():

   377

    if _WampSession:

   378

        # do reconnect and reset continueTrying and initialDelay parameter

   379

        if _transportFactory is not None:

   380

            _transportFactory.resetDelay()

   381

        _WampSession.disconnect()

   382

        return True

   383

    else:

   384

        # do connect

   385

        RegisterWampClient()

   386

        return True

   387

   388

   389

def GetSession():

   390

    return _WampSession

   391

   392

   393

def getWampStatus():

   394

    if _transportFactory is not None:

   395

        if _WampSession is not None:

   396

            if _WampSession.is_attached():

   397

                return "Attached"

   398

            return "Established"

   399

        return "Connecting"

   400

    return "Disconnected"

   401

   402

   403

def PublishEvent(eventID, value):

   404

    if getWampStatus() == "Attached":

   405

        _WampSession.publish(str(eventID), value)

   406

   407

   408

def PublishEventWithOwnID(eventID, value):

   409

    if getWampStatus() == "Attached":

   410

        _WampSession.publishWithOwnID(str(eventID), value)

   411

   412

   413

# WEB CONFIGURATION INTERFACE

   414

WAMP_SECRET_URL = "secret"

   415

WAMP_DELETE_TRUSTSTORE_URL = "delete_truststore"

   416

webExposedConfigItems = [

   417

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

   418

    "clientFactoryOptions.maxDelay",

   419

    "protocolOptions.autoPingInterval",

   420

    "protocolOptions.autoPingTimeout",

   421

    "verifyHostname"

   422

]

   423

   424

   425

def wampConfigDefault(ctx, argument):

   426

    if lastKnownConfig is not None:

   427

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

   428

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

   429

        searchValue = lastKnownConfig

   430

        while argument_name_path:

   431

            if searchValue:

   432

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

   433

            else:

   434

                break

   435

        return searchValue

   436

   437

   438

def wampConfig(**kwargs):

   439

    secretfile_field = kwargs["secretfile"]

   440

    if secretfile_field is not None:

   441

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

   442

        if secretfile is not None:

   443

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

   444

                secretfile.seek(0)

   445

                shutil.copyfileobj(secretfile,destfd)

   446

   447

    trustStore_field = kwargs["trustStore"]

   448

    if trustStore_field is not None:

   449

        trustStore_file = getattr(trustStore_field, "file", None)

   450

        if trustStore_file is not None:

   451

            with open(os.path.realpath(_WampTrust), 'w') as destfd:

   452

                trustStore_file.seek(0)

   453

                shutil.copyfileobj(trustStore_file,destfd)

   454

   455

    newConfig = lastKnownConfig.copy()

   456

    for argname in webExposedConfigItems:

   457

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

   458

        #  and then set a new value.

   459

        argname_path = argname.split(".")

   460

        arg_last = argname_path.pop()

   461

        arg = kwargs.get(argname, None)

   462

        if arg is not None:

   463

            tmpConf = newConfig

   464

            while argname_path:

   465

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

   466

            tmpConf[arg_last] = arg

   467

   468

    SetConfiguration(newConfig)

   469

   470

   471

class FileUploadDownload(annotate.FileUpload):

   472

    pass

   473

   474

   475

class FileUploadDownloadRenderer(webform.FileUploadRenderer):

   476

   477

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

   478

        # pylint: disable=expression-not-assigned

   479

        slot[_("Upload:")]

   480

        slot = webform.FileUploadRenderer.input(

   481

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

   482

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