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

    ("RemoteExec", {}),

    71

    ("GetLogMessage", {}),

    72

    ("ResetLogCount", {})

    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

        super(WampSession, self).onLeave(details)

   161

        _WampSession = None

   162

        _transportFactory = None

   163

   164

    def publishWithOwnID(self, eventID, value):

   165

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

   166

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

   167

   168

   169

class ReconnectingWampWebSocketClientFactory(WampWebSocketClientFactory, ReconnectingClientFactory):

   170

   171

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

   172

        global _transportFactory

   173

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

   174

   175

        try:

   176

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

   177

            if clientFactoryOptions:

   178

                self.setClientFactoryOptions(clientFactoryOptions)

   179

        except Exception as e:

   180

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

   181

            _transportFactory = None

   182

   183

        try:

   184

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

   185

            if protocolOptions:

   186

                self.setProtocolOptions(**protocolOptions)

   187

            _transportFactory = self

   188

        except Exception as e:

   189

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

   190

            _transportFactory = None

   191

   192

    def setClientFactoryOptions(self, options):

   193

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

   194

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

   195

                setattr(self, key, value)

   196

   197

    def buildProtocol(self, addr):

   198

        self.resetDelay()

   199

        return ReconnectingClientFactory.buildProtocol(self, addr)

   200

   201

    def clientConnectionFailed(self, connector, reason):

   202

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

   203

              time.ctime())

   204

        super(ReconnectingWampWebSocketClientFactory,

   205

              self).clientConnectionFailed(connector, reason)

   206

   207

    def clientConnectionLost(self, connector, reason):

   208

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

   209

              time.ctime())

   210

        super(ReconnectingWampWebSocketClientFactory,

   211

              self).clientConnectionFailed(connector, reason)

   212

   213

   214

def CheckConfiguration(WampClientConf):

   215

    url = WampClientConf["url"]

   216

    if not IsCorrectUri(url):

   217

        raise annotate.ValidateError(

   218

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

   219

            _("WAMP configuration error:"))

   220

   221

def UpdateWithDefault(d1, d2):

   222

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

   223

        d1.setdefault(k, v)

   224

   225

def GetConfiguration():

   226

    global lastKnownConfig

   227

   228

    WampClientConf = None

   229

   230

    if os.path.exists(_WampConf):

   231

        try:

   232

            WampClientConf = json.load(open(_WampConf))

   233

            UpdateWithDefault(WampClientConf, defaultWampConfig)

   234

        except ValueError:

   235

            pass

   236

   237

    if WampClientConf is None:

   238

        WampClientConf = defaultWampConfig.copy()

   239

   240

    for itemName in mandatoryConfigItems:

   241

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

   242

            raise Exception(

   243

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

   244

   245

    CheckConfiguration(WampClientConf)

   246

   247

    lastKnownConfig = WampClientConf.copy()

   248

    return WampClientConf

   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, ConfDir=None, KeyStore=None, servicename=None):

   279

    global _WampConf, _WampSecret, _WampTrust, defaultWampConfig

   280

   281

    if servicename:

   282

        defaultWampConfig["ID"] = servicename

   283

   284

    ConfDir = ConfDir if ConfDir else WorkingDir

   285

    KeyStore = KeyStore if KeyStore else WorkingDir

   286

   287

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

   288

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

   289

   290

    if _WampTrust is None:

   291

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

   292

   293

    # set config file path only if not already set

   294

    if _WampConf is None:

   295

        # default project's wampconf has precedance over commandline given

   296

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

   297

            _WampConf = _WampConfDefault

   298

        else:

   299

            _WampConf = wampconf

   300

   301

    WampClientConf = GetConfiguration()

   302

   303

    # set secret file path only if not already set

   304

    if _WampSecret is None:

   305

        # default project's wamp secret also

   306

        # has precedance over commandline given

   307

        if os.path.exists(_WampSecretDefault):

   308

            _WampSecret = _WampSecretDefault

   309

        else:

   310

            _WampSecret = wampsecret

   311

   312

    if _WampSecret is not None:

   313

        if _WampSecret == _WampSecretDefault:

   314

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

   315

            secret = LoadWampSecret(_WampSecret)

   316

        else:

   317

            # secret from command line is formated ID:PSK

   318

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

   319

            _ID, secret = getPSKID()

   320

   321

        WampClientConf["secret"] = secret

   322

   323

    else:

   324

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

   325

   326

    if not WampClientConf["active"]:

   327

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

   328

        return

   329

   330

    # create a WAMP application session factory

   331

    component_config = types.ComponentConfig(

   332

        realm=WampClientConf["realm"],

   333

        extra=WampClientConf)

   334

    session_factory = wamp.ApplicationSessionFactory(

   335

        config=component_config)

   336

    session_factory.session = WampSession

   337

   338

    # create a WAMP-over-WebSocket transport client factory

   339

    ReconnectingWampWebSocketClientFactory(

   340

        component_config,

   341

        session_factory,

   342

        url=WampClientConf["url"],

   343

        serializers=[MsgPackSerializer()])

   344

   345

    # start the client from a Twisted endpoint

   346

    if _transportFactory:

   347

        contextFactory=None

   348

        if _transportFactory.isSecure:

   349

            contextFactory = MakeSecureContextFactory(WampClientConf["verifyHostname"])

   350

   351

        connectWS(_transportFactory, contextFactory)

   352

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

   353

        return True

   354

    else:

   355

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

   356

        return False

   357

   358

def MakeSecureContextFactory(verifyHostname):

   359

    if not verifyHostname:

   360

        return None

   361

    trustRoot=None

   362

    if os.path.exists(_WampTrust):

   363

        cert = crypto.load_certificate(

   364

            crypto.FILETYPE_PEM,

   365

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

   366

        )

   367

        trustRoot=OpenSSLCertificateAuthorities([cert])

   368

    return optionsForClientTLS(_transportFactory.host, trustRoot=trustRoot)

   369

   370

def StopReconnectWampClient():

   371

    if _transportFactory is not None:

   372

        _transportFactory.stopTrying()

   373

    if _WampSession is not None:

   374

        _WampSession.leave()

   375

   376

   377

def StartReconnectWampClient():

   378

    if _WampSession:

   379

        # do reconnect and reset continueTrying and initialDelay parameter

   380

        if _transportFactory is not None:

   381

            _transportFactory.resetDelay()

   382

        _WampSession.disconnect()

   383

        return True

   384

    else:

   385

        # do connect

   386

        RegisterWampClient()

   387

        return True

   388

   389

   390

def GetSession():

   391

    return _WampSession

   392

   393

   394

def getWampStatus():

   395

    if _transportFactory is not None:

   396

        if _WampSession is not None:

   397

            if _WampSession.is_attached():

   398

                return "Attached"

   399

            return "Established"

   400

        return "Connecting"

   401

    return "Disconnected"

   402

   403

   404

def PublishEvent(eventID, value):

   405

    if getWampStatus() == "Attached":

   406

        _WampSession.publish(str(eventID), value)

   407

   408

   409

def PublishEventWithOwnID(eventID, value):

   410

    if getWampStatus() == "Attached":

   411

        _WampSession.publishWithOwnID(str(eventID), value)

   412

   413

   414

# WEB CONFIGURATION INTERFACE

   415

WAMP_SECRET_URL = "secret"

   416

WAMP_DELETE_TRUSTSTORE_URL = "delete_truststore"

   417

webExposedConfigItems = [

   418

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

   419

    "clientFactoryOptions.maxDelay",

   420

    "protocolOptions.autoPingInterval",

   421

    "protocolOptions.autoPingTimeout",

   422

    "verifyHostname"

   423

]

   424

   425

   426

def wampConfigDefault(ctx, argument):

   427

    if lastKnownConfig is not None:

   428

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

   429

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

   430

        searchValue = lastKnownConfig

   431

        while argument_name_path:

   432

            if searchValue:

   433

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

   434

            else:

   435

                break

   436

        return searchValue

   437

   438

   439

def wampConfig(**kwargs):

   440

    secretfile_field = kwargs["secretfile"]

   441

    if secretfile_field is not None:

   442

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

   443

        if secretfile is not None:

   444

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

   445

                secretfile.seek(0)

   446

                shutil.copyfileobj(secretfile,destfd)

   447

   448

    trustStore_field = kwargs["trustStore"]

   449

    if trustStore_field is not None:

   450

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

   451

        if trustStore_file is not None:

   452

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

   453

                trustStore_file.seek(0)

   454

                shutil.copyfileobj(trustStore_file,destfd)

   455

   456

    newConfig = lastKnownConfig.copy()

   457

    for argname in webExposedConfigItems:

   458

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

   459

        #  and then set a new value.

   460

        argname_path = argname.split(".")

   461

        arg_last = argname_path.pop()

   462

        arg = kwargs.get(argname, None)

   463

        if arg is not None:

   464

            tmpConf = newConfig

   465

            while argname_path:

   466

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

   467

            tmpConf[arg_last] = arg

   468

   469

    SetConfiguration(newConfig)

   470

   471

   472

class FileUploadDownload(annotate.FileUpload):

   473

    pass

   474

   475

   476

class FileUploadDownloadRenderer(webform.FileUploadRenderer):

   477

   478

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

   479

        # pylint: disable=expression-not-assigned

   480

        slot[_("Upload:")]

   481

        slot = webform.FileUploadRenderer.input(

   482

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