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_continue_collect = ctypes.c_int.in_dll(PLCBinary, "svghmi_continue_collect")

    35

    36

svghmi_send_collect = PLCBinary.svghmi_send_collect

    37

svghmi_send_collect.restype = ctypes.c_int # error or 0

    38

svghmi_send_collect.argtypes = [

    39

    ctypes.c_uint32,  # index

    40

    ctypes.POINTER(ctypes.c_uint32),  # size

    41

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

    42

    43

svghmi_reset = PLCBinary.svghmi_reset

    44

svghmi_reset.restype = ctypes.c_int # error or 0

    45

svghmi_reset.argtypes = [

    46

    ctypes.c_uint32]  # index

    47

    48

svghmi_recv_dispatch = PLCBinary.svghmi_recv_dispatch

    49

svghmi_recv_dispatch.restype = ctypes.c_int # error or 0

    50

svghmi_recv_dispatch.argtypes = [

    51

    ctypes.c_uint32,  # index

    52

    ctypes.c_uint32,  # size

    53

    ctypes.c_char_p]  # data ptr

    54

    55

class HMISessionMgr(object):

    56

    def __init__(self):

    57

        self.multiclient_sessions = set()

    58

        self.watchdog_session = None

    59

        self.session_count = 0

    60

        self.lock = RLock()

    61

        self.indexes = set()

    62

    63

    def next_index(self):

    64

        if self.indexes:

    65

            greatest = max(self.indexes)

    66

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

    67

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

    68

        else:

    69

            index = 0

    70

        self.indexes.add(index)

    71

        return index

    72

    73

    def free_index(self, index):

    74

        self.indexes.remove(index)

    75

    76

    def register(self, session):

    77

        global max_svghmi_sessions

    78

        with self.lock:

    79

            if session.is_watchdog_session:

    80

                # Creating a new watchdog session closes pre-existing one

    81

                if self.watchdog_session is not None:

    82

                    self.unregister(self.watchdog_session)

    83

                else:

    84

                    assert(self.session_count < max_svghmi_sessions)

    85

                    self.session_count += 1

    86

    87

                self.watchdog_session = session

    88

            else:

    89

                assert(self.session_count < max_svghmi_sessions)

    90

                self.multiclient_sessions.add(session)

    91

                self.session_count += 1

    92

            session.session_index = self.next_index()

    93

    94

    def unregister(self, session):

    95

        with self.lock:

    96

            if session.is_watchdog_session :

    97

                if self.watchdog_session != session:

    98

                    return

    99

                self.watchdog_session = None

   100

            else:

   101

                try:

   102

                    self.multiclient_sessions.remove(session)

   103

                except KeyError:

   104

                    return

   105

            self.free_index(session.session_index)

   106

            self.session_count -= 1

   107

        session.kill()

   108

   109

    def close_all(self):

   110

        for session in self.iter_sessions():

   111

            self.unregister(session)

   112

   113

    def iter_sessions(self):

   114

        with self.lock:

   115

            lst = list(self.multiclient_sessions)

   116

            if self.watchdog_session is not None:

   117

                lst = [self.watchdog_session]+lst

   118

            for nxt_session in lst:

   119

                yield nxt_session

   120

   121

   122

svghmi_session_manager = HMISessionMgr()

   123

   124

   125

class HMISession(object):

   126

    def __init__(self, protocol_instance):

   127

        self.protocol_instance = protocol_instance

   128

        self._session_index = None

   129

        self.closed = False

   130

   131

    @property

   132

    def is_watchdog_session(self):

   133

        return self.protocol_instance.has_watchdog

   134

   135

    @property

   136

    def session_index(self):

   137

        return self._session_index

   138

   139

    @session_index.setter

   140

    def session_index(self, value):

   141

        self._session_index = value

   142

   143

    def reset(self):

   144

        return svghmi_reset(self.session_index)

   145

   146

    def close(self):

   147

        if self.closed: return

   148

        self.protocol_instance.sendClose(WebSocketProtocol.CLOSE_STATUS_CODE_NORMAL)

   149

   150

    def notify_closed(self):

   151

        self.closed = True

   152

   153

    def kill(self):

   154

        self.close()

   155

        self.reset()

   156

   157

    def onMessage(self, msg):

   158

        # pass message to the C side recieve_message()

   159

        if self.closed: return

   160

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

   161

   162

    def sendMessage(self, msg):

   163

        if self.closed: return

   164

        self.protocol_instance.sendMessage(msg, True)

   165

        return 0

   166

   167

class Watchdog(object):

   168

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

   169

        self._callback = callback

   170

        self.lock = RLock()

   171

        self.initial_timeout = initial_timeout

   172

        self.interval = interval

   173

        self.callback = callback

   174

        with self.lock:

   175

            self._start()

   176

   177

    def _start(self, rearm=False):

   178

        duration = self.interval if rearm else self.initial_timeout

   179

        if duration:

   180

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

   181

            self.timer.start()

   182

        else:

   183

            self.timer = None

   184

   185

    def _stop(self):

   186

        if self.timer is not None:

   187

            self.timer.cancel()

   188

            self.timer = None

   189

   190

    def cancel(self):

   191

        with self.lock:

   192

            self._stop()

   193

   194

    def feed(self, rearm=True):

   195

        with self.lock:

   196

            self._stop()

   197

            self._start(rearm)

   198

   199

    def trigger(self):

   200

        self._callback()

   201

        # Don't repeat trigger periodically

   202

        # # wait for initial timeout on re-start

   203

        # self.feed(rearm=False)

   204

   205

class HMIProtocol(WebSocketServerProtocol):

   206

   207

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

   208

        self._hmi_session = None

   209

        self.has_watchdog = False

   210

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

   211

   212

    def onConnect(self, request):

   213

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

   214

        return WebSocketServerProtocol.onConnect(self, request)

   215

   216

    def onOpen(self):

   217

        global svghmi_session_manager

   218

        assert(self._hmi_session is None)

   219

        _hmi_session = HMISession(self)

   220

        registered = svghmi_session_manager.register(_hmi_session)

   221

        self._hmi_session = _hmi_session

   222

   223

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

   224

        global svghmi_session_manager

   225

        if self._hmi_session is None : return

   226

        self._hmi_session.notify_closed()

   227

        svghmi_session_manager.unregister(self._hmi_session)

   228

        self._hmi_session = None

   229

   230

    def onMessage(self, msg, isBinary):

   231

        global svghmi_watchdog

   232

        if self._hmi_session is None : return

   233

        result = self._hmi_session.onMessage(msg)

   234

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

   235

            if svghmi_watchdog is not None:

   236

                svghmi_watchdog.feed()

   237

   238

class HMIWebSocketServerFactory(WebSocketServerFactory):

   239

    protocol = HMIProtocol

   240

   241

svghmi_servers = {}

   242

svghmi_send_thread = None

   243

   244

# python's errno on windows seems to have no ENODATA

   245

ENODATA = errno.ENODATA if hasattr(errno,"ENODATA") else None

   246

   247

def SendThreadProc():

   248

    global svghmi_session_manager

   249

    size = ctypes.c_uint32()

   250

    ptr = ctypes.c_void_p()

   251

    res = 0

   252

    while svghmi_continue_collect:

   253

        svghmi_wait()

   254

        for svghmi_session in svghmi_session_manager.iter_sessions():

   255

            res = svghmi_send_collect(

   256

                svghmi_session.session_index,

   257

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

   258

            if res == 0:

   259

                svghmi_session.sendMessage(

   260

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

   261

            elif res == ENODATA:

   262

                # this happens when there is no data after wakeup

   263

                # because of hmi data refresh period longer than

   264

                # PLC common ticktime

   265

                pass

   266

            else:

   267

                # this happens when finishing

   268

                break

   269

   270

def AddPathToSVGHMIServers(path, factory, *args, **kwargs):

   271

    for k,v in svghmi_servers.iteritems():

   272

        svghmi_root, svghmi_listener, path_list = v

   273

        svghmi_root.putChild(path, factory(*args, **kwargs))

   274

   275

# Called by PLCObject at start

   276

def _runtime_00_svghmi_start():

   277

    global svghmi_send_thread

   278

   279

    # start a thread that call the C part of SVGHMI

   280

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

   281

    svghmi_send_thread.start()

   282

   283

   284

# Called by PLCObject at stop

   285

def _runtime_00_svghmi_stop():

   286

    global svghmi_send_thread, svghmi_session

   287

   288

    svghmi_session_manager.close_all()

   289

   290

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

   291

    svghmi_send_thread.join()

   292

    svghmi_send_thread = None

   293

   294

   295

class NoCacheFile(File):

   296

    def render_GET(self, request):

   297

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

   298

        return File.render_GET(self, request)

   299

    render_HEAD = render_GET

   300

   301