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

     9

import errno

    10

from threading import RLock, Timer

    11

import os, time

    12

    13

try:

    14

    from runtime.spawn_subprocess import Popen

    15

except ImportError:

    16

    from subprocess import Popen

    17

    18

from twisted.web.server import Site

    19

from twisted.web.resource import Resource

    20

from twisted.internet import reactor

    21

from twisted.web.static import File

    22

    23

from autobahn.twisted.websocket import WebSocketServerFactory, WebSocketServerProtocol

    24

from autobahn.websocket.protocol import WebSocketProtocol

    25

from autobahn.twisted.resource import  WebSocketResource

    26

    27

from runtime.loglevels import LogLevelsDict

    28

from runtime import GetPLCObjectSingleton

    29

    30

max_svghmi_sessions = None

    31

svghmi_watchdog = None

    32

    33

    34

svghmi_wait = PLCBinary.svghmi_wait

    35

svghmi_wait.restype = ctypes.c_int # error or 0

    36

svghmi_wait.argtypes = []

    37

    38

svghmi_continue_collect = ctypes.c_int.in_dll(PLCBinary, "svghmi_continue_collect")

    39

    40

svghmi_send_collect = PLCBinary.svghmi_send_collect

    41

svghmi_send_collect.restype = ctypes.c_int # error or 0

    42

svghmi_send_collect.argtypes = [

    43

    ctypes.c_uint32,  # index

    44

    ctypes.POINTER(ctypes.c_uint32),  # size

    45

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

    46

    47

svghmi_reset = PLCBinary.svghmi_reset

    48

svghmi_reset.restype = ctypes.c_int # error or 0

    49

svghmi_reset.argtypes = [

    50

    ctypes.c_uint32]  # index

    51

    52

svghmi_recv_dispatch = PLCBinary.svghmi_recv_dispatch

    53

svghmi_recv_dispatch.restype = ctypes.c_int # error or 0

    54

svghmi_recv_dispatch.argtypes = [

    55

    ctypes.c_uint32,  # index

    56

    ctypes.c_uint32,  # size

    57

    ctypes.c_char_p]  # data ptr

    58

    59

class HMISessionMgr(object):

    60

    def __init__(self):

    61

        self.multiclient_sessions = set()

    62

        self.watchdog_session = None

    63

        self.session_count = 0

    64

        self.lock = RLock()

    65

        self.indexes = set()

    66

    67

    def next_index(self):

    68

        if self.indexes:

    69

            greatest = max(self.indexes)

    70

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

    71

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

    72

        else:

    73

            index = 0

    74

        self.indexes.add(index)

    75

        return index

    76

    77

    def free_index(self, index):

    78

        self.indexes.remove(index)

    79

    80

    def register(self, session):

    81

        global max_svghmi_sessions

    82

        with self.lock:

    83

            if session.is_watchdog_session:

    84

                # Creating a new watchdog session closes pre-existing one

    85

                if self.watchdog_session is not None:

    86

                    self.unregister(self.watchdog_session)

    87

                else:

    88

                    assert(self.session_count < max_svghmi_sessions)

    89

                    self.session_count += 1

    90

    91

                self.watchdog_session = session

    92

            else:

    93

                assert(self.session_count < max_svghmi_sessions)

    94

                self.multiclient_sessions.add(session)

    95

                self.session_count += 1

    96

            session.session_index = self.next_index()

    97

    98

    def unregister(self, session):

    99

        with self.lock:

   100

            if session.is_watchdog_session :

   101

                if self.watchdog_session != session:

   102

                    return

   103

                self.watchdog_session = None

   104

            else:

   105

                try:

   106

                    self.multiclient_sessions.remove(session)

   107

                except KeyError:

   108

                    return

   109

            self.free_index(session.session_index)

   110

            self.session_count -= 1

   111

        session.kill()

   112

   113

    def close_all(self):

   114

        for session in self.iter_sessions():

   115

            self.unregister(session)

   116

   117

    def iter_sessions(self):

   118

        with self.lock:

   119

            lst = list(self.multiclient_sessions)

   120

            if self.watchdog_session is not None:

   121

                lst = [self.watchdog_session]+lst

   122

            for nxt_session in lst:

   123

                yield nxt_session

   124

   125

   126

svghmi_session_manager = HMISessionMgr()

   127

   128

   129

class HMISession(object):

   130

    def __init__(self, protocol_instance):

   131

        self.protocol_instance = protocol_instance

   132

        self._session_index = None

   133

        self.closed = False

   134

   135

    @property

   136

    def is_watchdog_session(self):

   137

        return self.protocol_instance.has_watchdog

   138

   139

    @property

   140

    def session_index(self):

   141

        return self._session_index

   142

   143

    @session_index.setter

   144

    def session_index(self, value):

   145

        self._session_index = value

   146

   147

    def reset(self):

   148

        return svghmi_reset(self.session_index)

   149

   150

    def close(self):

   151

        if self.closed: return

   152

        self.protocol_instance.sendClose(WebSocketProtocol.CLOSE_STATUS_CODE_NORMAL)

   153

   154

    def notify_closed(self):

   155

        self.closed = True

   156

   157

    def kill(self):

   158

        self.close()

   159

        self.reset()

   160

   161

    def onMessage(self, msg):

   162

        # pass message to the C side recieve_message()

   163

        if self.closed: return

   164

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

   165

   166

    def sendMessage(self, msg):

   167

        if self.closed: return

   168

        self.protocol_instance.sendMessage(msg, True)

   169

        return 0

   170

   171

class Watchdog(object):

   172

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

   173

        self._callback = callback

   174

        self.lock = RLock()

   175

        self.initial_timeout = initial_timeout

   176

        self.interval = interval

   177

        self.callback = callback

   178

        with self.lock:

   179

            self._start()

   180

   181

    def _start(self, rearm=False):

   182

        duration = self.interval if rearm else self.initial_timeout

   183

        if duration:

   184

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

   185

            self.timer.start()

   186

        else:

   187

            self.timer = None

   188

   189

    def _stop(self):

   190

        if self.timer is not None:

   191

            self.timer.cancel()

   192

            self.timer = None

   193

   194

    def cancel(self):

   195

        with self.lock:

   196

            self._stop()

   197

   198

    def feed(self, rearm=True):

   199

        with self.lock:

   200

            self._stop()

   201

            self._start(rearm)

   202

   203

    def trigger(self):

   204

        self._callback()

   205

        # Don't repeat trigger periodically

   206

        # # wait for initial timeout on re-start

   207

        # self.feed(rearm=False)

   208

   209

class HMIProtocol(WebSocketServerProtocol):

   210

   211

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

   212

        self._hmi_session = None

   213

        self.has_watchdog = False

   214

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

   215

   216

    def onConnect(self, request):

   217

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

   218

        return WebSocketServerProtocol.onConnect(self, request)

   219

   220

    def onOpen(self):

   221

        global svghmi_session_manager

   222

        assert(self._hmi_session is None)

   223

        _hmi_session = HMISession(self)

   224

        registered = svghmi_session_manager.register(_hmi_session)

   225

        self._hmi_session = _hmi_session

   226

        self._hmi_session.reset()

   227

   228

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

   229

        global svghmi_session_manager

   230

        if self._hmi_session is None : return

   231

        self._hmi_session.notify_closed()

   232

        svghmi_session_manager.unregister(self._hmi_session)

   233

        self._hmi_session = None

   234

   235

    def onMessage(self, msg, isBinary):

   236

        global svghmi_watchdog

   237

        if self._hmi_session is None : return

   238

        result = self._hmi_session.onMessage(msg)

   239

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

   240

            if svghmi_watchdog is not None:

   241

                svghmi_watchdog.feed()

   242

   243

class HMIWebSocketServerFactory(WebSocketServerFactory):

   244

    protocol = HMIProtocol

   245

   246

svghmi_servers = {}

   247

svghmi_send_thread = None

   248

   249

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

   250

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

   251

   252

def SendThreadProc():

   253

    global svghmi_session_manager

   254

    size = ctypes.c_uint32()

   255

    ptr = ctypes.c_void_p()

   256

    res = 0

   257

    while svghmi_continue_collect:

   258

        svghmi_wait()

   259

        for svghmi_session in svghmi_session_manager.iter_sessions():

   260

            res = svghmi_send_collect(

   261

                svghmi_session.session_index,

   262

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

   263

            if res == 0:

   264

                svghmi_session.sendMessage(

   265

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

   266

            elif res == ENODATA:

   267

                # this happens when there is no data after wakeup

   268

                # because of hmi data refresh period longer than

   269

                # PLC common ticktime

   270

                pass

   271

            else:

   272

                # this happens when finishing

   273

                break

   274

   275

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

   276

    for k,v in svghmi_servers.items():

   277

        svghmi_root, svghmi_listener, path_list = v

   278

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

   279

   280

# Called by PLCObject at start

   281

def _runtime_00_svghmi_start():

   282

    global svghmi_send_thread

   283

   284

    # start a thread that call the C part of SVGHMI

   285

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

   286

    svghmi_send_thread.start()

   287

   288

   289

# Called by PLCObject at stop

   290

def _runtime_00_svghmi_stop():

   291

    global svghmi_send_thread, svghmi_session

   292

   293

    svghmi_session_manager.close_all()

   294

   295

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

   296

    svghmi_send_thread.join()

   297

    svghmi_send_thread = None

   298

   299

   300

class NoCacheFile(File):

   301

    def render_GET(self, request):

   302

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

   303

        return File.render_GET(self, request)

   304

    render_HEAD = render_GET

   305

   306

   307

def waitpid_timeout(proc, helpstr="", timeout = 3):

   308

    if proc is None:

   309

        return

   310

    def waitpid_timeout_loop(proc = proc, timeout = timeout):

   311

        try:

   312

            while proc.poll() is None:

   313

                time.sleep(1)

   314

                timeout = timeout - 1

   315

                if not timeout:

   316

                    GetPLCObjectSingleton().LogMessage(

   317

                        LogLevelsDict["WARNING"], 

   318

                        "Timeout waiting for {} PID: {}".format(helpstr, str(proc.pid)))

   319

                    break

   320

        except OSError:

   321

            # workaround exception "OSError: [Errno 10] No child processes"

   322

            pass

   323

    Thread(target=waitpid_timeout_loop, name="Zombie hunter").start()

   324