1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz

     5

# Copyright (C) 2019: Edouard TISSERANT

     6

# See COPYING file for copyrights details.

     7

     8

from __future__ import absolute_import

     9

import errno

    10

from threading import RLock, Timer

    11

    12

try:

    13

    from runtime.spawn_subprocess import Popen

    14

except ImportError:

    15

    from subprocess import Popen

    16

    17

from twisted.web.server import Site

    18

from twisted.web.resource import Resource

    19

from twisted.internet import reactor

    20

from twisted.web.static import File

    21

    22

from autobahn.twisted.websocket import WebSocketServerFactory, WebSocketServerProtocol

    23

from autobahn.websocket.protocol import WebSocketProtocol

    24

from autobahn.twisted.resource import  WebSocketResource

    25

    26

max_svghmi_sessions = None

    27

svghmi_watchdog = None

    28

    34

svghmi_send_collect = PLCBinary.svghmi_send_collect

    35

svghmi_send_collect.restype = ctypes.c_int # error or 0

    36

svghmi_send_collect.argtypes = [

    37

    ctypes.c_uint32,  # index

    38

    ctypes.POINTER(ctypes.c_uint32),  # size

    39

    ctypes.POINTER(ctypes.c_void_p)]  # data ptr

    40

    46

svghmi_recv_dispatch = PLCBinary.svghmi_recv_dispatch

    47

svghmi_recv_dispatch.restype = ctypes.c_int # error or 0

    48

svghmi_recv_dispatch.argtypes = [

    49

    ctypes.c_uint32,  # index

    50

    ctypes.c_uint32,  # size

    51

    ctypes.c_char_p]  # data ptr

    52

    53

class HMISessionMgr(object):

    54

    def __init__(self):

    55

        self.multiclient_sessions = set()

    56

        self.watchdog_session = None

    57

        self.session_count = 0

    58

        self.lock = RLock()

    59

        self.indexes = set()

    60

    61

    def next_index(self):

    62

        if self.indexes:

    63

            greatest = max(self.indexes)

    64

            holes = set(range(greatest)) - self.indexes

    65

            index = min(holes) if holes else greatest+1

    66

        else:

    67

            index = 0

    68

        self.indexes.add(index)

    69

        return index

    70

    71

    def free_index(self, index):

    72

        self.indexes.remove(index)

    73

    74

    def register(self, session):

    75

        global max_svghmi_sessions

    76

        with self.lock:

    77

            if session.is_watchdog_session:

    78

                # Creating a new watchdog session closes pre-existing one

    79

                if self.watchdog_session is not None:

    80

                    self.unregister(self.watchdog_session)

    81

                else:

    82

                    assert(self.session_count < max_svghmi_sessions)

    83

                    self.session_count += 1

    84

    85

                self.watchdog_session = session

    86

            else:

    87

                assert(self.session_count < max_svghmi_sessions)

    88

                self.multiclient_sessions.add(session)

    89

                self.session_count += 1

    90

            session.session_index = self.next_index()

    91

    92

    def unregister(self, session):

    93

        with self.lock:

    97

                self.watchdog_session = None

    98

            else:

   104

            self.session_count -= 1

   106

   107

    def close_all(self):

   108

        with self.lock:

   109

            close_list = list(self.multiclient_sessions)

   110

            if self.watchdog_session:

   111

                close_list.append(self.watchdog_session)

   112

            for session in close_list:

   113

                self.unregister(session)

   114

   115

    def iter_sessions(self):

   116

        with self.lock:

   117

            nxt_session = self.watchdog_session

   118

        if nxt_session is not None:

   119

            yield nxt_session

   120

        idx = 0

   121

        while True:

   122

            with self.lock:

   123

                if idx >= len(self.multiclient_sessions):

   124

                    return

   125

                nxt_session = self.multiclient_sessions[idx]

   126

            yield nxt_session

   127

            idx += 1

   128

   129

   130

svghmi_session_manager = HMISessionMgr()

   131

   132

   133

class HMISession(object):

   134

    def __init__(self, protocol_instance):

   135

        self.protocol_instance = protocol_instance

   136

        self._session_index = None

   138

   139

    @property

   140

    def is_watchdog_session(self):

   141

        return self.protocol_instance.has_watchdog

   142

   143

    @property

   144

    def session_index(self):

   145

        return self._session_index

   146

   147

    @session_index.setter

   148

    def session_index(self, value):

   149

        self._session_index = value

   150

   154

    def close(self):

   156

        self.protocol_instance.sendClose(WebSocketProtocol.CLOSE_STATUS_CODE_NORMAL)

   157

   165

    def onMessage(self, msg):

   166

        # pass message to the C side recieve_message()

   168

        return svghmi_recv_dispatch(self.session_index, len(msg), msg)

   169

   170

    def sendMessage(self, msg):

   172

        self.protocol_instance.sendMessage(msg, True)

   173

        return 0

   174

   175

class Watchdog(object):

   176

    def __init__(self, initial_timeout, interval, callback):

   177

        self._callback = callback

   178

        self.lock = RLock()

   179

        self.initial_timeout = initial_timeout

   180

        self.interval = interval

   181

        self.callback = callback

   182

        with self.lock:

   183

            self._start()

   184

   185

    def _start(self, rearm=False):

   186

        duration = self.interval if rearm else self.initial_timeout

   187

        if duration:

   188

            self.timer = Timer(duration, self.trigger)

   189

            self.timer.start()

   190

        else:

   191

            self.timer = None

   192

   193

    def _stop(self):

   194

        if self.timer is not None:

   195

            self.timer.cancel()

   196

            self.timer = None

   197

   198

    def cancel(self):

   199

        with self.lock:

   200

            self._stop()

   201

   202

    def feed(self, rearm=True):

   203

        with self.lock:

   204

            self._stop()

   205

            self._start(rearm)

   206

   207

    def trigger(self):

   208

        self._callback()

   209

        # Don't repeat trigger periodically

   210

        # # wait for initial timeout on re-start

   211

        # self.feed(rearm=False)

   212

   213

class HMIProtocol(WebSocketServerProtocol):

   214

   215

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

   216

        self._hmi_session = None

   217

        self.has_watchdog = False

   218

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

   219

   220

    def onConnect(self, request):

   221

        self.has_watchdog = request.params.get("mode", [None])[0] == "watchdog"

   222

        return WebSocketServerProtocol.onConnect(self, request)

   223

   224

    def onOpen(self):

   225

        global svghmi_session_manager

   226

        assert(self._hmi_session is None)

   227

        self._hmi_session = HMISession(self)

   229

   230

    def onClose(self, wasClean, code, reason):

   231

        global svghmi_session_manager

   233

        svghmi_session_manager.unregister(self._hmi_session)

   234

        self._hmi_session = None

   235

   236

    def onMessage(self, msg, isBinary):

   237

        global svghmi_watchdog

   238

        assert(self._hmi_session is not None)

   239

   240

        result = self._hmi_session.onMessage(msg)

   241

        if result == 1 and self.has_watchdog:  # was heartbeat

   242

            if svghmi_watchdog is not None:

   243

                svghmi_watchdog.feed()

   244

   245

class HMIWebSocketServerFactory(WebSocketServerFactory):

   246

    protocol = HMIProtocol

   247

   248

svghmi_servers = {}

   249

svghmi_send_thread = None

   250

   251

def SendThreadProc():

   252

    global svghmi_session_manager

   253

    size = ctypes.c_uint32()

   254

    ptr = ctypes.c_void_p()

   255

    res = 0

   256

    finished = False

   257

    while not(finished):

   259

        for svghmi_session in svghmi_session_manager.iter_sessions():

   262

            res = svghmi_send_collect(

   263

                svghmi_session.session_index,

   264

                ctypes.byref(size), ctypes.byref(ptr))

   265

            if res == 0:

   266

                svghmi_session.sendMessage(

   267

                    ctypes.string_at(ptr.value,size.value))

   268

            elif res == errno.ENODATA:

   269

                # this happens when there is no data after wakeup

   271

                # PLC common ticktime

   273

            else:

   274

                # this happens when finishing

   275

                finished = True

   276

                break

   277

   278

def AddPathToSVGHMIServers(path, factory):

   279

    for k,v in svghmi_servers.iteritems():

   280

        svghmi_root, svghmi_listener, path_list = v

   281

        svghmi_root.putChild(path, factory())

   282

   283

# Called by PLCObject at start

   284

def _runtime_00_svghmi_start():

   285

    global svghmi_send_thread

   286

   287

    # start a thread that call the C part of SVGHMI

   288

    svghmi_send_thread = Thread(target=SendThreadProc, name="SVGHMI Send")

   289

    svghmi_send_thread.start()

   290

   291

   292

# Called by PLCObject at stop

   293

def _runtime_00_svghmi_stop():

   294

    global svghmi_send_thread, svghmi_session

   295

   296

    svghmi_session_manager.close_all()

   297

   298

    # plc cleanup calls svghmi_(locstring)_cleanup and unlocks send thread

   299

    svghmi_send_thread.join()

   300

    svghmi_send_thread = None

   301

   302

   303

class NoCacheFile(File):

   304

    def render_GET(self, request):

   305

        request.setHeader(b"Cache-Control", b"no-cache, no-store")

   306

        return File.render_GET(self, request)

   307

    render_HEAD = render_GET

   308

   309