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

    29

    30

svghmi_wait = PLCBinary.svghmi_wait

    31

svghmi_wait.restype = ctypes.c_int # error or 0

    32

svghmi_wait.argtypes = []

    33

    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

    41

svghmi_reset = PLCBinary.svghmi_reset

    42

svghmi_reset.restype = ctypes.c_int # error or 0

    43

svghmi_reset.argtypes = [

    44

    ctypes.c_uint32]  # index

    45

    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:

    94

            if session.is_watchdog_session :

    95

                if self.watchdog_session != session:

    96

                    return

    97

                self.watchdog_session = None

    98

            else:

    99

                try:

   100

                    self.multiclient_sessions.remove(self)

   101

                except KeyError:

   102

                    return

   103

            self.free_index(session.session_index)

   104

            self.session_count -= 1

   105

        session.kill()

   106

   107

    def close_all(self):

   108

        for session in self.iter_sessions():

   109

            self.unregister(session)

   110

   111

    def iter_sessions(self):

   112

        with self.lock:

   113

            lst = list(self.multiclient_sessions)

   114

            if self.watchdog_session is not None:

   115

                lst = [self.watchdog_session]+lst

   116

            for nxt_session in lst:

   117

                yield nxt_session

   118

   119

   120

svghmi_session_manager = HMISessionMgr()

   121

   122

   123

class HMISession(object):

   124

    def __init__(self, protocol_instance):

   125

        self.protocol_instance = protocol_instance

   126

        self._session_index = None

   127

        self.closed = False

   128

   129

    @property

   130

    def is_watchdog_session(self):

   131

        return self.protocol_instance.has_watchdog

   132

   133

    @property

   134

    def session_index(self):

   135

        return self._session_index

   136

   137

    @session_index.setter

   138

    def session_index(self, value):

   139

        self._session_index = value

   140

   141

    def reset(self):

   142

        return svghmi_reset(self.session_index)

   143

   144

    def close(self):

   145

        if self.closed: return

   146

        self.protocol_instance.sendClose(WebSocketProtocol.CLOSE_STATUS_CODE_NORMAL)

   147

   148

    def notify_closed(self):

   149

        self.closed = True

   150

   151

    def kill(self):

   152

        self.close()

   153

        self.reset()

   154

   155

    def onMessage(self, msg):

   156

        # pass message to the C side recieve_message()

   157

        if self.closed: return

   158

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

   159

   160

    def sendMessage(self, msg):

   161

        if self.closed: return

   162

        self.protocol_instance.sendMessage(msg, True)

   163

        return 0

   164

   165

class Watchdog(object):

   166

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

   167

        self._callback = callback

   168

        self.lock = RLock()

   169

        self.initial_timeout = initial_timeout

   170

        self.interval = interval

   171

        self.callback = callback

   172

        with self.lock:

   173

            self._start()

   174

   175

    def _start(self, rearm=False):

   176

        duration = self.interval if rearm else self.initial_timeout

   177

        if duration:

   178

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

   179

            self.timer.start()

   180

        else:

   181

            self.timer = None

   182

   183

    def _stop(self):

   184

        if self.timer is not None:

   185

            self.timer.cancel()

   186

            self.timer = None

   187

   188

    def cancel(self):

   189

        with self.lock:

   190

            self._stop()

   191

   192

    def feed(self, rearm=True):

   193

        with self.lock:

   194

            self._stop()

   195

            self._start(rearm)

   196

   197

    def trigger(self):

   198

        self._callback()

   199

        # Don't repeat trigger periodically

   200

        # # wait for initial timeout on re-start

   201

        # self.feed(rearm=False)

   202

   203

class HMIProtocol(WebSocketServerProtocol):

   204

   205

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

   206

        self._hmi_session = None

   207

        self.has_watchdog = False

   208

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

   209

   210

    def onConnect(self, request):

   211

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

   212

        return WebSocketServerProtocol.onConnect(self, request)

   213

   214

    def onOpen(self):

   215

        global svghmi_session_manager

   216

        assert(self._hmi_session is None)

   217

        self._hmi_session = HMISession(self)

   218

        registered = svghmi_session_manager.register(self._hmi_session)

   219

   220

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

   221

        global svghmi_session_manager

   222

        self._hmi_session.notify_closed()

   223

        svghmi_session_manager.unregister(self._hmi_session)

   224

        self._hmi_session = None

   225

   226

    def onMessage(self, msg, isBinary):

   227

        global svghmi_watchdog

   228

        assert(self._hmi_session is not None)

   229

   230

        result = self._hmi_session.onMessage(msg)

   231

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

   232

            if svghmi_watchdog is not None:

   233

                svghmi_watchdog.feed()

   234

   235

class HMIWebSocketServerFactory(WebSocketServerFactory):

   236

    protocol = HMIProtocol

   237

   238

svghmi_servers = {}

   239

svghmi_send_thread = None

   240

   241

def SendThreadProc():

   242

    global svghmi_session_manager

   243

    size = ctypes.c_uint32()

   244

    ptr = ctypes.c_void_p()

   245

    res = 0

   246

    finished = False

   247

    while not(finished):

   248

        svghmi_wait()

   249

        for svghmi_session in svghmi_session_manager.iter_sessions():

   250

            res = svghmi_send_collect(

   251

                svghmi_session.session_index,

   252

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

   253

            if res == 0:

   254

                svghmi_session.sendMessage(

   255

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

   256

            elif res == errno.ENODATA:

   257

                # this happens when there is no data after wakeup

   258

                # because of hmi data refresh period longer than

   259

                # PLC common ticktime

   260

                pass

   261

            else:

   262

                # this happens when finishing

   263

                finished = True

   264

                break

   265

   266

def AddPathToSVGHMIServers(path, factory):

   267

    for k,v in svghmi_servers.iteritems():

   268

        svghmi_root, svghmi_listener, path_list = v

   269

        svghmi_root.putChild(path, factory())

   270

   271

# Called by PLCObject at start

   272

def _runtime_00_svghmi_start():

   273

    global svghmi_send_thread

   274

   275

    # start a thread that call the C part of SVGHMI

   276

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

   277

    svghmi_send_thread.start()

   278

   279

   280

# Called by PLCObject at stop

   281

def _runtime_00_svghmi_stop():

   282

    global svghmi_send_thread, svghmi_session

   283

   284

    svghmi_session_manager.close_all()

   285

   286

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

   287

    svghmi_send_thread.join()

   288

    svghmi_send_thread = None

   289

   290

   291

class NoCacheFile(File):

   292

    def render_GET(self, request):

   293

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

   294

        return File.render_GET(self, request)

   295

    render_HEAD = render_GET

   296

   297