1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz runtime.

     5

#

     6

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     7

#

     8

# See COPYING.Runtime file for copyrights details.

     9

#

    10

# This library is free software; you can redistribute it and/or

    11

# modify it under the terms of the GNU Lesser General Public

    12

# License as published by the Free Software Foundation; either

    13

# version 2.1 of the License, or (at your option) any later version.

    14

    15

# This library is distributed in the hope that it will be useful,

    16

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    17

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    18

# Lesser General Public License for more details.

    19

    20

# You should have received a copy of the GNU Lesser General Public

    21

# License along with this library; if not, write to the Free Software

    22

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

    23

    24

    25

from threading import Thread, Lock, Event, Condition

    26

import ctypes

    27

import os

    28

import sys

    29

import traceback

    30

import shutil

    31

from time import time

    32

import hashlib

    33

from tempfile import mkstemp

    34

from functools import wraps, partial

    35

import _ctypes

    36

    37

from runtime.typemapping import TypeTranslator

    38

from runtime.loglevels import LogLevelsDefault, LogLevelsCount

    39

from runtime.Stunnel import getPSKID

    40

from runtime import PlcStatus

    41

from runtime import MainWorker

    42

from runtime import default_evaluator

    43

    44

if os.name in ("nt", "ce"):

    45

    dlopen = _ctypes.LoadLibrary

    46

    dlclose = _ctypes.FreeLibrary

    47

elif os.name == "posix":

    48

    dlopen = _ctypes.dlopen

    49

    dlclose = _ctypes.dlclose

    50

    51

    52

def get_last_traceback(tb):

    53

    while tb.tb_next:

    54

        tb = tb.tb_next

    55

    return tb

    56

    57

    58

lib_ext = {

    59

    "linux": ".so",

    60

    "win32":  ".dll",

    61

}.get(sys.platform, "")

    62

    63

    64

def PLCprint(message):

    65

    if sys.stdout:

    66

        sys.stdout.write("PLCobject : "+message+"\n")

    67

        sys.stdout.flush()

    68

    69

    70

def RunInMain(func):

    71

    @wraps(func)

    72

    def func_wrapper(*args, **kwargs):

    73

        return MainWorker.call(func, *args, **kwargs)

    74

    return func_wrapper

    75

    76

    77

class PLCObject(object):

    78

    def __init__(self, WorkingDir, argv, statuschange, evaluator, pyruntimevars):

    79

        self.workingdir = WorkingDir  # must exits already

    80

        self.tmpdir = os.path.join(WorkingDir, 'tmp')

    81

        if os.path.exists(self.tmpdir):

    82

            shutil.rmtree(self.tmpdir)

    83

        os.mkdir(self.tmpdir)

    84

        self.argv = []

    85

        self.statuschange = statuschange

    86

        self.evaluator = evaluator

    87

        self.pyruntimevars = pyruntimevars

    88

        self.PLCStatus = PlcStatus.Empty

    89

        self.PLClibraryHandle = None

    90

        self.PLClibraryLock = Lock()

    91

        # Creates fake C funcs proxies

    92

        self._InitPLCStubCalls()

    93

        self._loading_error = None

    94

        self.python_runtime_vars = None

    95

        self.TraceThread = None

    96

        self.TraceLock = Lock()

    97

        self.Traces = []

    98

        self.DebugToken = 0

    99

   100

        self._init_blobs()

   101

   102

    # First task of worker -> no @RunInMain

   103

    def AutoLoad(self, autostart):

   104

        # Get the last transfered PLC

   105

        try:

   106

            self.CurrentPLCFilename = open(

   107

                self._GetMD5FileName(),

   108

                "r").read().strip() + lib_ext

   109

            self.PLCStatus = PlcStatus.Stopped

   110

            if autostart:

   111

                if self.LoadPLC():

   112

                    self.StartPLC()

   113

                else:

   114

                    self._fail(_("Problem autostarting PLC : can't load PLC"))

   115

                return

   116

        except Exception:

   117

            self.PLCStatus = PlcStatus.Empty

   118

            self.CurrentPLCFilename = None

   119

   120

        self.StatusChange()

   121

   122

    def StatusChange(self):

   123

        if self.statuschange is not None:

   124

            for callee in self.statuschange:

   125

                callee(self.PLCStatus)

   126

   127

    def LogMessage(self, *args):

   128

        if len(args) == 2:

   129

            level, msg = args

   130

        else:

   131

            level = LogLevelsDefault

   132

            msg, = args

   133

        PLCprint(msg)

   134

        if self._LogMessage is not None:

   135

            bmsg = msg.encode()

   136

            return self._LogMessage(level, bmsg, len(bmsg))

   137

        return None

   138

   139

    @RunInMain

   140

    def ResetLogCount(self):

   141

        if self._ResetLogCount is not None:

   142

            self._ResetLogCount()

   143

   144

    # used internaly

   145

    def GetLogCount(self, level):

   146

        if self._GetLogCount is not None:

   147

            return int(self._GetLogCount(level))

   148

        elif self._loading_error is not None and level == 0:

   149

            return 1

   150

   151

    @RunInMain

   152

    def GetLogMessage(self, level, msgid):

   153

        tick = ctypes.c_uint32()

   154

        tv_sec = ctypes.c_uint32()

   155

        tv_nsec = ctypes.c_uint32()

   156

        if self._GetLogMessage is not None:

   157

            maxsz = len(self._log_read_buffer)-1

   158

            sz = self._GetLogMessage(level, msgid,

   159

                                     self._log_read_buffer, maxsz,

   160

                                     ctypes.byref(tick),

   161

                                     ctypes.byref(tv_sec),

   162

                                     ctypes.byref(tv_nsec))

   163

            if sz and sz <= maxsz:

   164

                return (self._log_read_buffer[:sz].decode(), tick.value,

   165

                        tv_sec.value, tv_nsec.value)

   166

        elif self._loading_error is not None and level == 0:

   167

            return self._loading_error, 0, 0, 0

   168

        return None

   169

   170

    def _GetMD5FileName(self):

   171

        return os.path.join(self.workingdir, "lasttransferedPLC.md5")

   172

   173

    def _GetLibFileName(self):

   174

        return os.path.join(self.workingdir, self.CurrentPLCFilename)

   175

   176

    def _LoadPLC(self):

   177

        """

   178

        Load PLC library

   179

        Declare all functions, arguments and return values

   180

        """

   181

        md5 = open(self._GetMD5FileName(), "r").read()

   182

        self.PLClibraryLock.acquire()

   183

        try:

   184

            self._PLClibraryHandle = dlopen(self._GetLibFileName())

   185

            self.PLClibraryHandle = ctypes.CDLL(self.CurrentPLCFilename, handle=self._PLClibraryHandle)

   186

   187

            self.PLC_ID = ctypes.c_char_p.in_dll(self.PLClibraryHandle, "PLC_ID")

   188

            if len(md5) == 32:

   189

                self.PLC_ID.value = md5.encode()

   190

   191

            self._startPLC = self.PLClibraryHandle.startPLC

   192

            self._startPLC.restype = ctypes.c_int

   193

            self._startPLC.argtypes = [ctypes.c_int, ctypes.POINTER(ctypes.c_char_p)]

   194

   195

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   196

            self._stopPLC_real.restype = None

   197

   198

            self._PythonIterator = getattr(self.PLClibraryHandle, "PythonIterator", None)

   199

            if self._PythonIterator is not None:

   200

                self._PythonIterator.restype = ctypes.c_char_p

   201

                self._PythonIterator.argtypes = [ctypes.c_char_p, ctypes.POINTER(ctypes.c_void_p)]

   202

   203

                self._stopPLC = self._stopPLC_real

   204

            else:

   205

                # If python confnode is not enabled, we reuse _PythonIterator

   206

                # as a call that block pythonthread until StopPLC

   207

                self.PlcStopping = Event()

   208

   209

                def PythonIterator(res, blkid):

   210

                    self.PlcStopping.clear()

   211

                    self.PlcStopping.wait()

   212

                    return None

   213

                self._PythonIterator = PythonIterator

   214

   215

                def __StopPLC():

   216

                    self._stopPLC_real()

   217

                    self.PlcStopping.set()

   218

                self._stopPLC = __StopPLC

   219

   220

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   221

            self._ResetDebugVariables.restype = None

   222

   223

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   224

            self._RegisterDebugVariable.restype = ctypes.c_int

   225

            self._RegisterDebugVariable.argtypes = [ctypes.c_int, ctypes.c_void_p]

   226

   227

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   228

            self._FreeDebugData.restype = None

   229

   230

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   231

            self._GetDebugData.restype = ctypes.c_int

   232

            self._GetDebugData.argtypes = [ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_void_p)]

   233

   234

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   235

            self._suspendDebug.restype = ctypes.c_int

   236

            self._suspendDebug.argtypes = [ctypes.c_int]

   237

   238

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   239

            self._resumeDebug.restype = None

   240

   241

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   242

            self._ResetLogCount.restype = None

   243

   244

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   245

            self._GetLogCount.restype = ctypes.c_uint32

   246

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   247

   248

            self._LogMessage = self.PLClibraryHandle.LogMessage

   249

            self._LogMessage.restype = ctypes.c_int

   250

            self._LogMessage.argtypes = [ctypes.c_uint8, ctypes.c_char_p, ctypes.c_uint32]

   251

   252

            self._log_read_buffer = ctypes.create_string_buffer(1 << 14)  # 16K

   253

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   254

            self._GetLogMessage.restype = ctypes.c_uint32

   255

            self._GetLogMessage.argtypes = [ctypes.c_uint8, ctypes.c_uint32, ctypes.c_char_p, ctypes.c_uint32, ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32)]

   256

   257

            self._loading_error = None

   258

   259

        except Exception:

   260

            self._loading_error = traceback.format_exc()

   261

            PLCprint(self._loading_error)

   262

            return False

   263

        finally:

   264

            self.PLClibraryLock.release()

   265

   266

        return True

   267

   268

    @RunInMain

   269

    def LoadPLC(self):

   270

        res = self._LoadPLC()

   271

        if res:

   272

            try:

   273

                self.PythonRuntimeInit()

   274

            except Exception:

   275

                self._loading_error = traceback.format_exc()

   276

                PLCprint(self._loading_error)

   277

                return False

   278

        else:

   279

            self._FreePLC()

   280

   281

        return res

   282

   283

    @RunInMain

   284

    def UnLoadPLC(self):

   285

        self.PythonRuntimeCleanup()

   286

        self._FreePLC()

   287

   288

    def _InitPLCStubCalls(self):

   289

        """

   290

        create dummy C func proxies

   291

        """

   292

        self._startPLC = lambda x, y: None

   293

        self._stopPLC = lambda: None

   294

        self._ResetDebugVariables = lambda: None

   295

        self._RegisterDebugVariable = lambda x, y: 0

   296

        self._IterDebugData = lambda x, y: None

   297

        self._FreeDebugData = lambda: None

   298

        self._GetDebugData = lambda: -1

   299

        self._suspendDebug = lambda x: -1

   300

        self._resumeDebug = lambda: None

   301

        self._PythonIterator = lambda: ""

   302

        self._GetLogCount = None

   303

        self._LogMessage = None

   304

        self._GetLogMessage = None

   305

        self._PLClibraryHandle = None

   306

        self.PLClibraryHandle = None

   307

   308

    def _FreePLC(self):

   309

        """

   310

        Unload PLC library.

   311

        This is also called by __init__ to create dummy C func proxies

   312

        """

   313

        self.PLClibraryLock.acquire()

   314

        try:

   315

            # Unload library explicitely

   316

            if getattr(self, "_PLClibraryHandle", None) is not None:

   317

                dlclose(self._PLClibraryHandle)

   318

   319

            # Forget all refs to library

   320

            self._InitPLCStubCalls()

   321

   322

        finally:

   323

            self.PLClibraryLock.release()

   324

   325

        return False

   326

   327

    def PythonRuntimeCall(self, methodname, use_evaluator=True, reverse_order=False):

   328

        """

   329

        Calls init, start, stop or cleanup method provided by

   330

        runtime python files, loaded when new PLC uploaded

   331

        """

   332

        methods = self.python_runtime_vars.get("_runtime_%s" % methodname, [])

   333

        if reverse_order:

   334

            methods = reversed(methods)

   335

        for method in methods:

   336

            if use_evaluator:

   337

                _res, exp = self.evaluator(method)

   338

            else:

   339

                _res, exp = default_evaluator(method)

   340

            if exp is not None:

   341

                self.LogMessage(0, '\n'.join(traceback.format_exception(*exp)))

   342

   343

    # used internaly

   344

    def PythonRuntimeInit(self):

   345

        MethodNames = ["init", "start", "stop", "cleanup"]

   346

        self.python_runtime_vars = globals().copy()

   347

        self.python_runtime_vars.update(self.pyruntimevars)

   348

        parent = self

   349

   350

        class PLCSafeGlobals(object):

   351

            def __getattr__(self, name):

   352

                try:

   353

                    t = parent.python_runtime_vars["_"+name+"_ctype"]

   354

                except KeyError:

   355

                    raise KeyError("Try to get unknown shared global variable : %s" % name)

   356

                v = t()

   357

                parent.python_runtime_vars["_PySafeGetPLCGlob_"+name](ctypes.byref(v))

   358

                return parent.python_runtime_vars["_"+name+"_unpack"](v)

   359

   360

            def __setattr__(self, name, value):

   361

                try:

   362

                    t = parent.python_runtime_vars["_"+name+"_ctype"]

   363

                except KeyError:

   364

                    raise KeyError("Try to set unknown shared global variable : %s" % name)

   365

                v = parent.python_runtime_vars["_"+name+"_pack"](t, value)

   366

                parent.python_runtime_vars["_PySafeSetPLCGlob_"+name](ctypes.byref(v))

   367

   368

        class OnChangeStateClass(object):

   369

            def __getattr__(self, name):

   370

                u = parent.python_runtime_vars["_"+name+"_unpack"]

   371

                return type("changedesc",(),dict(

   372

                    count = parent.python_runtime_vars["_PyOnChangeCount_"+name].value,

   373

                    first = u(parent.python_runtime_vars["_PyOnChangeFirst_"+name]),

   374

                    last = u(parent.python_runtime_vars["_PyOnChangeLast_"+name])))

   375

   376

   377

        self.python_runtime_vars.update({

   378

            "PLCGlobals":     PLCSafeGlobals(),

   379

            "OnChange":       OnChangeStateClass(),

   380

            "WorkingDir":     self.workingdir,

   381

            "PLCObject":      self,

   382

            "PLCBinary":      self.PLClibraryHandle,

   383

            "PLCGlobalsDesc": []})

   384

   385

        for methodname in MethodNames:

   386

            self.python_runtime_vars["_runtime_%s" % methodname] = []

   387

   388

        try:

   389

            filenames = os.listdir(self.workingdir)

   390

            filenames.sort()

   391

            for filename in filenames:

   392

                name, ext = os.path.splitext(filename)

   393

                if name.upper().startswith("RUNTIME") and ext.upper() == ".PY":

   394

                    exec(compile(open(os.path.join(self.workingdir, filename), "rb").read(), os.path.join(self.workingdir, filename), 'exec'), self.python_runtime_vars)

   395

                    for methodname in MethodNames:

   396

                        method = self.python_runtime_vars.get("_%s_%s" % (name, methodname), None)

   397

                        if method is not None:

   398

                            self.python_runtime_vars["_runtime_%s" % methodname].append(method)

   399

        except Exception:

   400

            self.LogMessage(0, traceback.format_exc())

   401

            raise

   402

   403

        self.PythonRuntimeCall("init", use_evaluator=False)

   404

   405

        self.PythonThreadCondLock = Lock()

   406

        self.PythonThreadCmdCond = Condition(self.PythonThreadCondLock)

   407

        self.PythonThreadAckCond = Condition(self.PythonThreadCondLock)

   408

        self.PythonThreadCmd = None

   409

        self.PythonThreadAck = None

   410

        self.PythonThread = Thread(target=self.PythonThreadProc, name="PLCPythonThread")

   411

        self.PythonThread.start()

   412

   413

    # used internaly

   414

    def PythonRuntimeCleanup(self):

   415

        if self.python_runtime_vars is not None:

   416

            self.PythonThreadCommand("Finish")

   417

            self.PythonThread.join()

   418

            self.PythonRuntimeCall("cleanup", use_evaluator=False, reverse_order=True)

   419

   420

        self.python_runtime_vars = None

   421

   422

    def PythonThreadLoop(self):

   423

        res, cmd, blkid = "None", "None", ctypes.c_void_p()

   424

        compile_cache = {}

   425

        while True:

   426

            cmd = self._PythonIterator(res.encode(), blkid)

   427

            FBID = blkid.value

   428

            if cmd is None:

   429

                break

   430

            cmd = cmd.decode()

   431

            try:

   432

                self.python_runtime_vars["FBID"] = FBID

   433

                ccmd, AST = compile_cache.get(FBID, (None, None))

   434

                if ccmd is None or ccmd != cmd:

   435

                    AST = compile(cmd, '<plc>', 'eval')

   436

                    compile_cache[FBID] = (cmd, AST)

   437

                result, exp = self.evaluator(eval, AST, self.python_runtime_vars)

   438

                if exp is not None:

   439

                    res = "#EXCEPTION : "+str(exp[1])

   440

                    self.LogMessage(1, ('PyEval@0x%x(Code="%s") Exception "%s"') % (

   441

                        FBID, cmd, '\n'.join(traceback.format_exception(*exp))))

   442

                else:

   443

                    res = str(result)

   444

                self.python_runtime_vars["FBID"] = None

   445

            except Exception as e:

   446

                res = "#EXCEPTION : "+str(e)

   447

                self.LogMessage(1, ('PyEval@0x%x(Code="%s") Exception "%s"') % (FBID, cmd, str(e)))

   448

   449

    def PythonThreadProc(self):

   450

        while True:

   451

            self.PythonThreadCondLock.acquire()

   452

            cmd = self.PythonThreadCmd

   453

            while cmd is None:

   454

                self.PythonThreadCmdCond.wait()

   455

                cmd = self.PythonThreadCmd

   456

            self.PythonThreadCmd = None

   457

            self.PythonThreadCondLock.release()

   458

   459

            if cmd == "PreStart":

   460

                self.PreStartPLC()

   461

                # Ack once PreStart done, must be finished before StartPLC

   462

                self.PythonThreadAcknowledge(cmd)

   463

            elif cmd == "Start":

   464

                # Ack Immediately, for responsiveness

   465

                self.PythonThreadAcknowledge(cmd)

   466

                self.PythonRuntimeCall("start")

   467

                self.LogMessage("Python extensions started")

   468

                self._PostStartPLC()

   469

                self.PythonThreadLoop()

   470

                self.PythonRuntimeCall("stop", reverse_order=True)

   471

            elif cmd == "Finish":

   472

                self.PythonThreadAcknowledge(cmd)

   473

                break

   474

   475

    def PythonThreadAcknowledge(self, ack):

   476

        self.PythonThreadCondLock.acquire()

   477

        self.PythonThreadAck = ack

   478

        self.PythonThreadAckCond.notify()