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

    45

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

    46

    47

_transportFactory = None

    48

_WampSession = None

    49

WorkingDir = None

    50

    51

# Find pre-existing project WAMP config file

    52

_WampConf = None

    53

_WampSecret = None

    54

_WampTrust = None

    55

    56

ExposedCalls = [

    57

    ("StartPLC", {}),

    58

    ("StopPLC", {}),

    59

    ("GetPLCstatus", {}),

    60

    ("GetPLCID", {}),

    61

    ("SeedBlob", {}),

    62

    ("AppendChunkToBlob", {}),

    63

    ("PurgeBlobs", {}),

    64

    ("NewPLC", {}),

    65

    ("RepairPLC", {}),

    66

    ("MatchMD5", {}),

    67

    ("SetTraceVariablesList", {}),

    68

    ("GetTraceVariables", {}),

    69

    ("RemoteExec", {}),

    70

    ("GetLogMessage", {}),

    71

    ("ResetLogCount", {})

    72

]

    73

    74

# de-activated dumb wamp config

    75

defaultWampConfig = {

    76

    "ID": "wamptest",

    77

    "active": False,

    78

    "realm": "Automation",

    79

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

    80

    "clientFactoryOptions": {

    81

        "maxDelay": 300

    82

    },

    83

    "protocolOptions": {

    84

        "autoPingInterval": 10,

    85

        "autoPingTimeout": 5

    86

    },

    87

    "verifyHostname": True

    88

}

    89

    90

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

    91

# or User python code.

    92

    93

""" crossbar Events to register to """

    94

SubscribedEvents = []

    95

    96

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

    97

DoOnJoin = []

    98

    99

lastKnownConfig = None

   100

   101

   102

def GetCallee(name):

   103

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

   104

    names = name.split('.')

   105

    obj = GetPLCObjectSingleton()

   106

    while names:

   107

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

   108

    return obj

   109

   110

   111

class WampSession(wamp.ApplicationSession):

   112

   113

    def onConnect(self):

   114

        if "secret" in self.config.extra:

   115

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

   116

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

   117

        else:

   118

            self.join("Automation")

   119

   120

    def onChallenge(self, challenge):

   121

        if challenge.method == "wampcra":

   122

            if "secret" in self.config.extra:

   123

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

   124

                signature = auth.compute_wcs(

   125

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

   126

                return signature.decode("ascii")

   127

            else:

   128

                raise Exception("no secret given for authentication")

   129

        else:

   130

            raise Exception(

   131

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

   132

   133

    def onJoin(self, details):

   134

        global _WampSession

   135

        _WampSession = self

   136

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

   137

   138

        for name, kwargs in ExposedCalls:

   139

            try:

   140

                registerOptions = types.RegisterOptions(**kwargs)

   141

            except TypeError as e:

   142

                registerOptions = None

   143

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

   144

   145

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

   146

   147

        for name in SubscribedEvents:

   148

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

   149

   150

        for func in DoOnJoin:

   151

            func(self)

   152

   153

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

   154

   155

    def onLeave(self, details):

   156

        global _WampSession, _transportFactory

   157

        super(WampSession, self).onLeave(details)

   158

        _WampSession = None

   159

        _transportFactory = None

   160

        print(_('WAMP session left'))

   161

   162

    def publishWithOwnID(self, eventID, value):

   163

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

   164

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

   165

   166

   167

class ReconnectingWampWebSocketClientFactory(WampWebSocketClientFactory, ReconnectingClientFactory):

   168

   169

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

   170

        global _transportFactory

   171

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

   172

   173

        try:

   174

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

   175

            if clientFactoryOptions:

   176

                self.setClientFactoryOptions(clientFactoryOptions)

   177

        except Exception as e:

   178

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

   179

            _transportFactory = None

   180

   181

        try:

   182

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

   183

            if protocolOptions:

   184

                self.setProtocolOptions(**protocolOptions)

   185

            _transportFactory = self

   186

        except Exception as e:

   187

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

   188

            _transportFactory = None

   189

   190

    def setClientFactoryOptions(self, options):

   191

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

   192

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

   193

                setattr(self, key, value)

   194

   195

    def buildProtocol(self, addr):

   196

        self.resetDelay()

   197

        return ReconnectingClientFactory.buildProtocol(self, addr)

   198

   199

    def clientConnectionFailed(self, connector, reason):

   200

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

   201

              time.ctime())

   202

        super(ReconnectingWampWebSocketClientFactory,

   203

              self).clientConnectionFailed(connector, reason)

   204

   205

    def clientConnectionLost(self, connector, reason):

   206

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

   207

              time.ctime())

   208

        super(ReconnectingWampWebSocketClientFactory,

   209

              self).clientConnectionFailed(connector, reason)

   210

   211

   212

def CheckConfiguration(WampClientConf):

   213

    url = WampClientConf["url"]

   214

    if not IsCorrectUri(url):

   215

        raise annotate.ValidateError(

   216

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

   217

            _("WAMP configuration error:"))

   218

   219

def UpdateWithDefault(d1, d2):

   220

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

   221

        d1.setdefault(k, v)

   222

   223

def GetConfiguration():

   224

    global lastKnownConfig

   225

   226

    WampClientConf = None

   227

   228

    if os.path.exists(_WampConf):

   229

        try:

   230

            WampClientConf = json.load(open(_WampConf))

   231

            UpdateWithDefault(WampClientConf, defaultWampConfig)

   232

        except ValueError:

   233

            pass

   234

   235

    if WampClientConf is None:

   236

        WampClientConf = defaultWampConfig.copy()

   237

   238

    for itemName in mandatoryConfigItems:

   239

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

   240

            raise Exception(

   241

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

   242

   243

    CheckConfiguration(WampClientConf)

   244

   245

    lastKnownConfig = WampClientConf.copy()

   246

    return WampClientConf

   247

   248

   249

def SetConfiguration(WampClientConf):

   250

    global lastKnownConfig

   251

   252

    CheckConfiguration(WampClientConf)

   253

   254

    lastKnownConfig = WampClientConf.copy()

   255

   256

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

   257

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

   258

    StopReconnectWampClient()

   259

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

   260

        StartReconnectWampClient()

   261

   262

    return WampClientConf

   263

   264

   265

def LoadWampSecret(secretfname):

   266

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

   267

    if len(WSClientWampSecret) == 0:

   268

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

   269

    return WSClientWampSecret

   270

   271

   272

def IsCorrectUri(uri):

   273

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

   274

   275

   276

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

   277

    global _WampConf, _WampSecret, _WampTrust

   278

    ConfDir = ConfDir if ConfDir else WorkingDir

   279

    KeyStore = KeyStore if KeyStore else WorkingDir

   280

   281

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

   282

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

   283

   284

    if _WampTrust is None:

   285

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

   286

   287

    # set config file path only if not already set

   288

    if _WampConf is None:

   289

        # default project's wampconf has precedance over commandline given

   290

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

   291

            _WampConf = _WampConfDefault

   292

        else:

   293

            _WampConf = wampconf

   294

   295

    WampClientConf = GetConfiguration()

   296

   297

    # set secret file path only if not already set

   298

    if _WampSecret is None:

   299

        # default project's wamp secret also

   300

        # has precedance over commandline given

   301

        if os.path.exists(_WampSecretDefault):

   302

            _WampSecret = _WampSecretDefault

   303

        else:

   304

            _WampSecret = wampsecret

   305

   306

    if _WampSecret is not None:

   307

        WampClientConf["secret"] = LoadWampSecret(_WampSecret)

   308

    else:

   309

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

   310

        _WampSecret = _WampSecretDefault

   311

   312

    if not WampClientConf["active"]:

   313

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

   314

        return

   315

   316

    # create a WAMP application session factory

   317

    component_config = types.ComponentConfig(

   318

        realm=WampClientConf["realm"],

   319

        extra=WampClientConf)

   320

    session_factory = wamp.ApplicationSessionFactory(

   321

        config=component_config)

   322

    session_factory.session = WampSession

   323

   324

    # create a WAMP-over-WebSocket transport client factory

   325

    ReconnectingWampWebSocketClientFactory(

   326

        component_config,

   327

        session_factory,

   328

        url=WampClientConf["url"],

   329

        serializers=[MsgPackSerializer()])

   330

   331

    # start the client from a Twisted endpoint

   332

    if _transportFactory:

   333

        contextFactory=None

   334

        if _transportFactory.isSecure:

   335

            contextFactory = MakeSecureContextFactory(WampClientConf["verifyHostname"])

   336

   337

        connectWS(_transportFactory, contextFactory)

   338

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

   339

        return True

   340

    else:

   341

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

   342

        return False

   343

   344

def MakeSecureContextFactory(verifyHostname):

   345

    if not verifyHostname:

   346

        return None

   347

    trustRoot=None

   348

    if os.path.exists(_WampTrust):

   349

        cert = crypto.load_certificate(

   350

            crypto.FILETYPE_PEM,

   351

            six.u(open(_WampTrust, 'r').read())

   352

        )

   353

        trustRoot=OpenSSLCertificateAuthorities([cert])

   354

    return optionsForClientTLS(_transportFactory.host, trustRoot=trustRoot)

   355

   356

def StopReconnectWampClient():

   357

    if _transportFactory is not None:

   358

        _transportFactory.stopTrying()

   359

    if _WampSession is not None:

   360

        _WampSession.leave()

   361

   362

   363

def StartReconnectWampClient():

   364

    if _WampSession:

   365

        # do reconnect and reset continueTrying and initialDelay parameter

   366

        if _transportFactory is not None:

   367

            _transportFactory.resetDelay()

   368

        _WampSession.disconnect()

   369

        return True

   370

    else:

   371

        # do connect

   372

        RegisterWampClient()

   373

        return True

   374

   375

   376

def GetSession():

   377

    return _WampSession

   378

   379

   380

def getWampStatus():

   381

    if _transportFactory is not None:

   382

        if _WampSession is not None:

   383

            if _WampSession.is_attached():

   384

                return "Attached"

   385

            return "Established"

   386

        return "Connecting"

   387

    return "Disconnected"

   388

   389

   390

def PublishEvent(eventID, value):

   391

    if getWampStatus() == "Attached":

   392

        _WampSession.publish(str(eventID), value)

   393

   394

   395

def PublishEventWithOwnID(eventID, value):

   396

    if getWampStatus() == "Attached":

   397

        _WampSession.publishWithOwnID(str(eventID), value)

   398

   399

   400

# WEB CONFIGURATION INTERFACE

   401

WAMP_SECRET_URL = "secret"

   402

WAMP_DELETE_TRUSTSTORE_URL = "delete_truststore"

   403

webExposedConfigItems = [

   404

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

   405

    "clientFactoryOptions.maxDelay",

   406

    "protocolOptions.autoPingInterval",

   407

    "protocolOptions.autoPingTimeout",

   408

    "verifyHostname"

   409

]

   410

   411

   412

def wampConfigDefault(ctx, argument):

   413

    if lastKnownConfig is not None:

   414

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

   415

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

   416

        searchValue = lastKnownConfig

   417

        while argument_name_path:

   418

            if searchValue:

   419

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

   420

            else:

   421

                break

   422

        return searchValue

   423

   424

   425

def wampConfig(**kwargs):

   426

    secretfile_field = kwargs["secretfile"]

   427

    if secretfile_field is not None:

   428

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

   429

        if secretfile is not None:

   430

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

   431

                secretfile.seek(0)

   432

                shutil.copyfileobj(secretfile,destfd)

   433

   434

    trustStore_field = kwargs["trustStore"]

   435

    if trustStore_field is not None:

   436

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

   437

        if trustStore_file is not None:

   438

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

   439

                trustStore_file.seek(0)

   440

                shutil.copyfileobj(trustStore_file,destfd)

   441

   442

    newConfig = lastKnownConfig.copy()

   443

    for argname in webExposedConfigItems:

   444

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

   445

        #  and then set a new value.

   446

        argname_path = argname.split(".")

   447

        arg_last = argname_path.pop()

   448

        arg = kwargs.get(argname, None)

   449

        if arg is not None:

   450

            tmpConf = newConfig

   451

            while argname_path:

   452

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

   453

            tmpConf[arg_last] = arg

   454

   455

    SetConfiguration(newConfig)

   456

   457

   458

class FileUploadDownload(annotate.FileUpload):

   459

    pass

   460

   461

   462

class FileUploadDownloadRenderer(webform.FileUploadRenderer):

   463

   464

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

   465

        # pylint: disable=expression-not-assigned

   466

        slot[_("Upload:")]

   467

        slot = webform.FileUploadRenderer.input(

   468

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

   469

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

   470

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

   471

   472

   473

registerAdapter(FileUploadDownloadRenderer, FileUploadDownload,

   474

                formless.iformless.ITypedRenderer)

   475

   476

   477

def getDownloadUrl(ctx, argument):

   478

    if lastKnownConfig is not None:

   479

        return url.URL.fromContext(ctx).\

   480

            child(WAMP_SECRET_URL).\

   481

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