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:

   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)

   220

   221

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

   222

        global svghmi_session_manager

   224

        self._hmi_session.notify_closed()

   225

        svghmi_session_manager.unregister(self._hmi_session)

   226

        self._hmi_session = None

   227

   228

    def onMessage(self, msg, isBinary):

   229

        global svghmi_watchdog

   231

        result = self._hmi_session.onMessage(msg)

   232

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

   233

            if svghmi_watchdog is not None:

   234

                svghmi_watchdog.feed()

   235

   236

class HMIWebSocketServerFactory(WebSocketServerFactory):

   237

    protocol = HMIProtocol

   238

   239

svghmi_servers = {}

   240

svghmi_send_thread = None

   241

   242

def SendThreadProc():

   243

    global svghmi_session_manager

   244

    size = ctypes.c_uint32()

   245

    ptr = ctypes.c_void_p()

   246

    res = 0

   247

    finished = False

   248

    while not(finished):

   249

        svghmi_wait()

   250

        for svghmi_session in svghmi_session_manager.iter_sessions():

   251

            res = svghmi_send_collect(

   252

                svghmi_session.session_index,

   253

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

   254

            if res == 0:

   255

                svghmi_session.sendMessage(

   256

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

   257

            elif res == errno.ENODATA:

   258

                # this happens when there is no data after wakeup

   259

                # because of hmi data refresh period longer than

   260

                # PLC common ticktime

   261

                pass

   262

            else:

   263

                # this happens when finishing

   264

                finished = True

   265

                break

   266

   267

def AddPathToSVGHMIServers(path, factory):

   268

    for k,v in svghmi_servers.iteritems():

   269

        svghmi_root, svghmi_listener, path_list = v

   270

        svghmi_root.putChild(path, factory())

   271

   272

# Called by PLCObject at start

   273

def _runtime_00_svghmi_start():

   274

    global svghmi_send_thread

   275

   276

    # start a thread that call the C part of SVGHMI

   277

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

   278

    svghmi_send_thread.start()

   279

   280

   281

# Called by PLCObject at stop

   282

def _runtime_00_svghmi_stop():

   283

    global svghmi_send_thread, svghmi_session

   284

   285

    svghmi_session_manager.close_all()

   286

   287

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

   288

    svghmi_send_thread.join()

   289

    svghmi_send_thread = None

   290

   291

   292

class NoCacheFile(File):

   293

    def render_GET(self, request):

   294

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

   295

        return File.render_GET(self, request)

   296

    render_HEAD = render_GET

   297

   298