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

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

    66

    sys.stdout.flush()

    67

    68

    69

def RunInMain(func):

    70

    @wraps(func)

    71

    def func_wrapper(*args, **kwargs):

    72

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

    73

    return func_wrapper

    74

    75

    76

class PLCObject(object):

    77

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

    78

        self.workingdir = WorkingDir  # must exits already

    79

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

    80

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

    81

            shutil.rmtree(self.tmpdir)

    82

        os.mkdir(self.tmpdir)

    83

        self.argv = []

    84

        self.statuschange = statuschange

    85

        self.evaluator = evaluator

    86

        self.pyruntimevars = pyruntimevars

    87

        self.PLCStatus = PlcStatus.Empty

    88

        self.PLClibraryHandle = None

    89

        self.PLClibraryLock = Lock()

    90

        # Creates fake C funcs proxies

    91

        self._InitPLCStubCalls()

    92

        self._loading_error = None

    93

        self.python_runtime_vars = None

    94

        self.TraceThread = None

    95

        self.TraceLock = Lock()

    96

        self.Traces = []

    97

        self.DebugToken = 0

    98

    99

        self._init_blobs()

   100

   101

    # First task of worker -> no @RunInMain

   102

    def AutoLoad(self, autostart):

   103

        # Get the last transfered PLC

   104

        try:

   105

            self.CurrentPLCFilename = open(

   106

                self._GetMD5FileName(),

   107

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

   108

            self.PLCStatus = PlcStatus.Stopped

   109

            if autostart:

   110

                if self.LoadPLC():

   111

                    self.StartPLC()

   112

                else:

   113

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

   114

                return

   115

        except Exception:

   116

            self.PLCStatus = PlcStatus.Empty

   117

            self.CurrentPLCFilename = None

   118

   119

        self.StatusChange()

   120

   121

    def StatusChange(self):

   122

        if self.statuschange is not None:

   123

            for callee in self.statuschange:

   124

                callee(self.PLCStatus)

   125

   126

    def LogMessage(self, *args):

   127

        if len(args) == 2:

   128

            level, msg = args

   129

        else:

   130

            level = LogLevelsDefault

   131

            msg, = args

   132

        PLCprint(msg)

   133

        if self._LogMessage is not None:

   134

            return self._LogMessage(level, msg.encode(), len(msg))

   135

        return None

   136

   137

    @RunInMain

   138

    def ResetLogCount(self):

   139

        if self._ResetLogCount is not None:

   140

            self._ResetLogCount()

   141

   142

    # used internaly

   143

    def GetLogCount(self, level):

   144

        if self._GetLogCount is not None:

   145

            return int(self._GetLogCount(level))

   146

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

   147

            return 1

   148

   149

    @RunInMain

   150

    def GetLogMessage(self, level, msgid):

   151

        tick = ctypes.c_uint32()

   152

        tv_sec = ctypes.c_uint32()

   153

        tv_nsec = ctypes.c_uint32()

   154

        if self._GetLogMessage is not None:

   155

            maxsz = len(self._log_read_buffer)-1

   156

            sz = self._GetLogMessage(level, msgid,

   157

                                     self._log_read_buffer, maxsz,

   158

                                     ctypes.byref(tick),

   159

                                     ctypes.byref(tv_sec),

   160

                                     ctypes.byref(tv_nsec))

   161

            if sz and sz <= maxsz:

   162

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

   163

                        tv_sec.value, tv_nsec.value)

   164

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

   165

            return self._loading_error, 0, 0, 0

   166

        return None

   167

   168

    def _GetMD5FileName(self):

   169

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

   170

   171

    def _GetLibFileName(self):

   172

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

   173

   174

    def _LoadPLC(self):

   175

        """

   176

        Load PLC library

   177

        Declare all functions, arguments and return values

   178

        """

   179

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

   180

        self.PLClibraryLock.acquire()

   181

        try:

   182

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

   183

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

   184

   185

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

   186

            if len(md5) == 32:

   187

                self.PLC_ID.value = md5.encode()

   188

   189

            self._startPLC = self.PLClibraryHandle.startPLC

   190

            self._startPLC.restype = ctypes.c_int

   191

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

   192

   193

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   194

            self._stopPLC_real.restype = None

   195

   196

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

   197

            if self._PythonIterator is not None:

   198

                self._PythonIterator.restype = ctypes.c_char_p

   199

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

   200

   201

                self._stopPLC = self._stopPLC_real

   202

            else:

   203

                # If python confnode is not enabled, we reuse _PythonIterator

   204

                # as a call that block pythonthread until StopPLC

   205

                self.PlcStopping = Event()

   206

   207

                def PythonIterator(res, blkid):

   208

                    self.PlcStopping.clear()

   209

                    self.PlcStopping.wait()

   210

                    return None

   211

                self._PythonIterator = PythonIterator

   212

   213

                def __StopPLC():

   214

                    self._stopPLC_real()

   215

                    self.PlcStopping.set()

   216

                self._stopPLC = __StopPLC

   217

   218

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   219

            self._ResetDebugVariables.restype = None

   220

   221

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   222

            self._RegisterDebugVariable.restype = ctypes.c_int

   223

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

   224

   225

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   226

            self._FreeDebugData.restype = None

   227

   228

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   229

            self._GetDebugData.restype = ctypes.c_int

   230

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

   231

   232

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   233

            self._suspendDebug.restype = ctypes.c_int

   234

            self._suspendDebug.argtypes = [ctypes.c_int]

   235

   236

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   237

            self._resumeDebug.restype = None

   238

   239

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   240

            self._ResetLogCount.restype = None

   241

   242

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   243

            self._GetLogCount.restype = ctypes.c_uint32

   244

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   245

   246

            self._LogMessage = self.PLClibraryHandle.LogMessage

   247

            self._LogMessage.restype = ctypes.c_int

   248

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

   249

   250

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

   251

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   252

            self._GetLogMessage.restype = ctypes.c_uint32

   253

            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)]

   254

   255

            self._loading_error = None

   256

   257

        except Exception:

   258

            self._loading_error = traceback.format_exc()

   259

            PLCprint(self._loading_error)

   260

            return False

   261

        finally:

   262

            self.PLClibraryLock.release()

   263

   264

        return True

   265

   266

    @RunInMain

   267

    def LoadPLC(self):

   268

        res = self._LoadPLC()

   269

        if res:

   270

            try:

   271

                self.PythonRuntimeInit()

   272

            except Exception:

   273

                self._loading_error = traceback.format_exc()

   274

                PLCprint(self._loading_error)

   275

                return False

   276

        else:

   277

            self._FreePLC()

   278

   279

        return res

   280

   281

    @RunInMain

   282

    def UnLoadPLC(self):

   283

        self.PythonRuntimeCleanup()

   284

        self._FreePLC()

   285

   286

    def _InitPLCStubCalls(self):

   287

        """

   288

        create dummy C func proxies

   289

        """

   290

        self._startPLC = lambda x, y: None

   291

        self._stopPLC = lambda: None

   292

        self._ResetDebugVariables = lambda: None

   293

        self._RegisterDebugVariable = lambda x, y: 0

   294

        self._IterDebugData = lambda x, y: None

   295

        self._FreeDebugData = lambda: None

   296

        self._GetDebugData = lambda: -1

   297

        self._suspendDebug = lambda x: -1

   298

        self._resumeDebug = lambda: None

   299

        self._PythonIterator = lambda: ""

   300

        self._GetLogCount = None

   301

        self._LogMessage = None

   302

        self._GetLogMessage = None

   303

        self._PLClibraryHandle = None

   304

        self.PLClibraryHandle = None

   305

   306

    def _FreePLC(self):

   307

        """

   308

        Unload PLC library.

   309

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

   310

        """

   311

        self.PLClibraryLock.acquire()

   312

        try:

   313

            # Unload library explicitely

   314

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

   315

                dlclose(self._PLClibraryHandle)

   316

   317

            # Forget all refs to library

   318

            self._InitPLCStubCalls()

   319

   320

        finally:

   321

            self.PLClibraryLock.release()

   322

   323

        return False

   324

   325

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

   326

        """

   327

        Calls init, start, stop or cleanup method provided by

   328

        runtime python files, loaded when new PLC uploaded

   329

        """

   330

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

   331

        if reverse_order:

   332

            methods = reversed(methods)

   333

        for method in methods:

   334

            if use_evaluator:

   335

                _res, exp = self.evaluator(method)

   336

            else:

   337

                _res, exp = default_evaluator(method)

   338

            if exp is not None:

   339

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

   340

   341

    # used internaly

   342

    def PythonRuntimeInit(self):

   343

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

   344

        self.python_runtime_vars = globals().copy()

   345

        self.python_runtime_vars.update(self.pyruntimevars)

   346

        parent = self

   347

   348

        class PLCSafeGlobals(object):

   349

            def __getattr__(self, name):

   350

                try:

   351

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

   352

                except KeyError:

   353

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

   354

                v = t()

   355

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

   356

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

   357

   358

            def __setattr__(self, name, value):

   359

                try:

   360

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

   361

                except KeyError:

   362

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

   363

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

   364

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

   365

   366

        class OnChangeStateClass(object):

   367

            def __getattr__(self, name):

   368

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

   369

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

   370

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

   371

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

   372

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

   373

   374

   375

        self.python_runtime_vars.update({

   376

            "PLCGlobals":     PLCSafeGlobals(),

   377

            "OnChange":       OnChangeStateClass(),

   378

            "WorkingDir":     self.workingdir,

   379

            "PLCObject":      self,

   380

            "PLCBinary":      self.PLClibraryHandle,

   381

            "PLCGlobalsDesc": []})

   382

   383

        for methodname in MethodNames:

   384

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

   385

   386

        try:

   387

            filenames = os.listdir(self.workingdir)

   388

            filenames.sort()

   389

            for filename in filenames:

   390

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

   391

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

   392

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

   393

                    for methodname in MethodNames:

   394

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

   395

                        if method is not None:

   396

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

   397

        except Exception:

   398

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

   399

            raise

   400

   401

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

   402

   403

        self.PythonThreadCondLock = Lock()

   404

        self.PythonThreadCmdCond = Condition(self.PythonThreadCondLock)

   405

        self.PythonThreadAckCond = Condition(self.PythonThreadCondLock)

   406

        self.PythonThreadCmd = None

   407

        self.PythonThreadAck = None

   408

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

   409

        self.PythonThread.start()

   410

   411

    # used internaly

   412

    def PythonRuntimeCleanup(self):

   413

        if self.python_runtime_vars is not None:

   414

            self.PythonThreadCommand("Finish")

   415

            self.PythonThread.join()

   416

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

   417

   418

        self.python_runtime_vars = None

   419

   420

    def PythonThreadLoop(self):

   421

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

   422

        compile_cache = {}

   423

        while True:

   424

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

   425

            FBID = blkid.value

   426

            if cmd is None:

   427

                break

   428

            cmd = cmd.decode()

   429

            try:

   430

                self.python_runtime_vars["FBID"] = FBID

   431

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

   432

                if ccmd is None or ccmd != cmd:

   433

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

   434

                    compile_cache[FBID] = (cmd, AST)

   435

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

   436

                if exp is not None:

   437

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

   438

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

   439

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

   440

                else:

   441

                    res = str(result)

   442

                self.python_runtime_vars["FBID"] = None

   443

            except Exception as e:

   444

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

   445

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

   446

   447

    def PythonThreadProc(self):

   448

        while True:

   449

            self.PythonThreadCondLock.acquire()

   450

            cmd = self.PythonThreadCmd

   451

            while cmd is None:

   452

                self.PythonThreadCmdCond.wait()

   453

                cmd = self.PythonThreadCmd

   454

            self.PythonThreadCmd = None

   455

            self.PythonThreadCondLock.release()

   456

   457

            if cmd == "PreStart":

   458

                self.PreStartPLC()

   459

                # Ack once PreStart done, must be finished before StartPLC

   460

                self.PythonThreadAcknowledge(cmd)

   461

            elif cmd == "Start":

   462

                # Ack Immediately, for responsiveness

   463

                self.PythonThreadAcknowledge(cmd)

   464

                self.PythonRuntimeCall("start")

   465

                self.LogMessage("Python extensions started")

   466

                self._PostStartPLC()

   467

                self.PythonThreadLoop()

   468

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

   469

            elif cmd == "Finish":

   470

                self.PythonThreadAcknowledge(cmd)

   471

                break

   472

   473

    def PythonThreadAcknowledge(self, ack):

   474

        self.PythonThreadCondLock.acquire()

   475

        self.PythonThreadAck = ack

   476

        self.PythonThreadAckCond.notify()

   477

        self.PythonThreadCondLock.release()

   478