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

        with self.lock:

   178

            self._start()

   179

   180

    def _start(self, rearm=False):

   181

        duration = self.interval if rearm else self.initial_timeout

   182

        if duration:

   183

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

   184

            self.timer.start()

   185

        else:

   186

            self.timer = None

   187

   188

    def _stop(self):

   189

        if self.timer is not None:

   190

            self.timer.cancel()

   191

            self.timer = None

   192

   193

    def cancel(self):

   194

        with self.lock:

   195

            self._stop()

   196

   197

    def feed(self, rearm=True):

   198

        with self.lock:

   199

            self._stop()

   200

            self._start(rearm)

   201

   202

    def trigger(self):

   203

        self._callback()

   204

        # Don't repeat trigger periodically

   205

        # # wait for initial timeout on re-start

   206

        # self.feed(rearm=False)

   207

   208

class HMIProtocol(WebSocketServerProtocol):

   209

   210

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

   211

        self._hmi_session = None

   212

        self.has_watchdog = False

   213

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

   214

   215

    def onConnect(self, request):

   216

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

   217

        return WebSocketServerProtocol.onConnect(self, request)

   218

   219

    def onOpen(self):

   220

        global svghmi_session_manager

   221

        assert(self._hmi_session is None)

   222

        _hmi_session = HMISession(self)

   223

        registered = svghmi_session_manager.register(_hmi_session)

   224

        self._hmi_session = _hmi_session

   225

        self._hmi_session.reset()

   226

   227

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

   228

        global svghmi_session_manager

   229

        if self._hmi_session is None : return

   230

        self._hmi_session.notify_closed()

   231

        svghmi_session_manager.unregister(self._hmi_session)

   232

        self._hmi_session = None

   233

   234

    def onMessage(self, msg, isBinary):

   235

        global svghmi_watchdog

   236

        if self._hmi_session is None : return

   237

        result = self._hmi_session.onMessage(msg)

   238

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

   239

            if svghmi_watchdog is not None:

   240

                svghmi_watchdog.feed()

   241

   242

class HMIWebSocketServerFactory(WebSocketServerFactory):

   243

    protocol = HMIProtocol

   244

   245

svghmi_servers = {}

   246

svghmi_send_thread = None

   247

   248

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

   249

ENODATA = errno.ENODATA if hasattr(errno,"ENODATA") else 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

    while svghmi_continue_collect:

   257

        svghmi_wait()

   258

        for svghmi_session in svghmi_session_manager.iter_sessions():

   259

            res = svghmi_send_collect(

   260

                svghmi_session.session_index,

   261

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

   262

            if res == 0:

   263

                svghmi_session.sendMessage(

   264

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

   265

            elif res == ENODATA:

   266

                # this happens when there is no data after wakeup

   267

                # because of hmi data refresh period longer than

   268

                # PLC common ticktime

   269

                pass

   270

            else:

   271

                # this happens when finishing

   272

                break

   273

   274

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

   275

    for k,v in svghmi_servers.items():

   276

        svghmi_root, svghmi_listener, path_list = v

   277

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

   278

   279

# Called by PLCObject at start

   280

def _runtime_00_svghmi_start():

   281

    global svghmi_send_thread

   282

   283

    # start a thread that call the C part of SVGHMI

   284

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

   285

    svghmi_send_thread.start()

   286

   287

   288

# Called by PLCObject at stop

   289

def _runtime_00_svghmi_stop():

   290

    global svghmi_send_thread, svghmi_session

   291

   292

    svghmi_session_manager.close_all()

   293

   294

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

   295

    svghmi_send_thread.join()

   296

    svghmi_send_thread = None

   297

   298

   299

class NoCacheFile(File):

   300

    def render_GET(self, request):

   301

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

   302

        return File.render_GET(self, request)

   303

    render_HEAD = render_GET

   304

   305

   306

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

   307

    if proc is None:

   308

        return

   309

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

   310

        try:

   311

            while proc.poll() is None:

   312

                time.sleep(.1)

   313

                timeout = timeout - .1

   314

                if timeout <= 0:

   315

                    GetPLCObjectSingleton().LogMessage(

   316

                        LogLevelsDict["WARNING"], 

   317

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

   318

                    break

   319

        except OSError:

   320

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

   321

            pass

   322

    waitpid_timeout_loop()

   323