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

import platform as platform_module

    32

from time import time

    33

import hashlib

    34

from tempfile import mkstemp

    35

from functools import wraps, partial

    36

import _ctypes

    37

    38

from runtime.typemapping import TypeTranslator

    39

from runtime.loglevels import LogLevelsDefault, LogLevelsCount

    40

from runtime.Stunnel import getPSKID

    41

from runtime import PlcStatus

    42

from runtime import MainWorker

    43

from runtime import default_evaluator

    44

    45

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

    46

    dlopen = _ctypes.LoadLibrary

    47

    dlclose = _ctypes.FreeLibrary

    48

elif os.name == "posix":

    49

    dlopen = _ctypes.dlopen

    50

    dlclose = _ctypes.dlclose

    51

    52

    53

def get_last_traceback(tb):

    54

    while tb.tb_next:

    55

        tb = tb.tb_next

    56

    return tb

    57

    58

    59

lib_ext = {

    60

    "linux": ".so",

    61

    "win32":  ".dll",

    62

}.get(sys.platform, "")

    63

    64

    65

def PLCprint(message):

    66

    if sys.stdout:

    67

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

    68

        sys.stdout.flush()

    69

    70

    71

def RunInMain(func):

    72

    @wraps(func)

    73

    def func_wrapper(*args, **kwargs):

    74

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

    75

    return func_wrapper

    76

    77

    78

class PLCObject(object):

    79

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

    80

        self.workingdir = WorkingDir  # must exits already

    81

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

    82

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

    83

            shutil.rmtree(self.tmpdir)

    84

        os.mkdir(self.tmpdir)

    85

        self.argv = []

    86

        self.statuschange = statuschange

    87

        self.evaluator = evaluator

    88

        self.pyruntimevars = pyruntimevars

    89

        self.PLCStatus = PlcStatus.Empty

    90

        self.PLClibraryHandle = None

    91

        self.PLClibraryLock = Lock()

    92

        # Creates fake C funcs proxies

    93

        self._InitPLCStubCalls()

    94

        self._loading_error = None

    95

        self.python_runtime_vars = None

    96

        self.TraceThread = None

    97

        self.TraceLock = Lock()

    98

        self.Traces = []

    99

        self.DebugToken = 0

   100

   101

        # Event to signal when PLC is stopped.

   102

        self.PlcStopped = Event()

   103

        self.PlcStopped.set()

   104

   105

        self._init_blobs()

   106

   107

    # First task of worker -> no @RunInMain

   108

    def AutoLoad(self, autostart):

   109

        # Get the last transfered PLC

   110

        try:

   111

            self.CurrentPLCFilename = open(

   112

                self._GetMD5FileName(),

   113

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

   114

            self.PLCStatus = PlcStatus.Stopped

   115

            if autostart:

   116

                if self.LoadPLC():

   117

                    self.StartPLC()

   118

                else:

   119

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

   120

                return

   121

        except Exception:

   122

            self.PLCStatus = PlcStatus.Empty

   123

            self.CurrentPLCFilename = None

   124

   125

        self.StatusChange()

   126

   127

    def StatusChange(self):

   128

        if self.statuschange is not None:

   129

            for callee in self.statuschange:

   130

                callee(self.PLCStatus)

   131

   132

    def LogMessage(self, *args):

   133

        if len(args) == 2:

   134

            level, msg = args

   135

        else:

   136

            level = LogLevelsDefault

   137

            msg, = args

   138

        PLCprint(msg)

   139

        if self._LogMessage is not None:

   140

            bmsg = msg.encode()

   141

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

   142

        return None

   143

   144

    @RunInMain

   145

    def ResetLogCount(self):

   146

        if self._ResetLogCount is not None:

   147

            self._ResetLogCount()

   148

   149

    # used internaly

   150

    def GetLogCount(self, level):

   151

        if self._GetLogCount is not None:

   152

            return int(self._GetLogCount(level))

   153

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

   154

            return 1

   155

        return 0

   156

   157

    @RunInMain

   158

    def GetLogMessage(self, level, msgid):

   159

        tick = ctypes.c_uint32()

   160

        tv_sec = ctypes.c_uint32()

   161

        tv_nsec = ctypes.c_uint32()

   162

        if self._GetLogMessage is not None:

   163

            maxsz = len(self._log_read_buffer)-1

   164

            sz = self._GetLogMessage(level, msgid,

   165

                                     self._log_read_buffer, maxsz,

   166

                                     ctypes.byref(tick),

   167

                                     ctypes.byref(tv_sec),

   168

                                     ctypes.byref(tv_nsec))

   169

            if sz and sz <= maxsz:

   170

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

   171

                        tv_sec.value, tv_nsec.value)

   172

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

   173

            return self._loading_error, 0, 0, 0

   174

        return None

   175

   176

    def _GetMD5FileName(self):

   177

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

   178

   179

    def _GetLibFileName(self):

   180

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

   181

   182

    def _LoadPLC(self):

   183

        """

   184

        Load PLC library

   185

        Declare all functions, arguments and return values

   186

        """

   187

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

   188

        self.PLClibraryLock.acquire()

   189

        try:

   190

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

   191

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

   192

   193

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

   194

            if len(md5) == 32:

   195

                self.PLC_ID.value = md5.encode()

   196

   197

            self._startPLC = self.PLClibraryHandle.startPLC

   198

            self._startPLC.restype = ctypes.c_int

   199

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

   200

   201

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   202

            self._stopPLC_real.restype = None

   203

   204

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

   205

            if self._PythonIterator is not None:

   206

                self._PythonIterator.restype = ctypes.c_char_p

   207

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

   208

   209

                self._stopPLC = self._stopPLC_real

   210

            else:

   211

                # If python confnode is not enabled, we reuse _PythonIterator

   212

                # as a call that block pythonthread until StopPLC

   213

                self.PlcStopping = Event()

   214

   215

                def PythonIterator(res, blkid):

   216

                    self.PlcStopping.clear()

   217

                    self.PlcStopping.wait()

   218

                    return None

   219

                self._PythonIterator = PythonIterator

   220

   221

                def __StopPLC():

   222

                    self._stopPLC_real()

   223

                    self.PlcStopping.set()

   224

                self._stopPLC = __StopPLC

   225

   226

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   227

            self._ResetDebugVariables.restype = None

   228

   229

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   230

            self._RegisterDebugVariable.restype = ctypes.c_int

   231

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

   232

   233

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   234

            self._FreeDebugData.restype = None

   235

   236

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   237

            self._GetDebugData.restype = ctypes.c_int

   238

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

   239

   240

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   241

            self._suspendDebug.restype = ctypes.c_int

   242

            self._suspendDebug.argtypes = [ctypes.c_int]

   243

   244

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   245

            self._resumeDebug.restype = None

   246

   247

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   248

            self._ResetLogCount.restype = None

   249

   250

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   251

            self._GetLogCount.restype = ctypes.c_uint32

   252

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   253

   254

            self._LogMessage = self.PLClibraryHandle.LogMessage

   255

            self._LogMessage.restype = ctypes.c_int

   256

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

   257

   258

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

   259

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   260

            self._GetLogMessage.restype = ctypes.c_uint32

   261

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

   262

   263

            self._loading_error = None

   264

   265

        except Exception:

   266

            self._loading_error = traceback.format_exc()

   267

            PLCprint(self._loading_error)

   268

            return False

   269

        finally:

   270

            self.PLClibraryLock.release()

   271

   272

        return True

   273

   274

    @RunInMain

   275

    def LoadPLC(self):

   276

        res = self._LoadPLC()

   277

        if res:

   278

            try:

   279

                self.PythonRuntimeInit()

   280

            except Exception:

   281

                self._loading_error = traceback.format_exc()

   282

                PLCprint(self._loading_error)

   283

                return False

   284

        else:

   285

            self._FreePLC()

   286

   287

        return res

   288

   289

    @RunInMain

   290

    def UnLoadPLC(self):

   291

        self.PythonRuntimeCleanup()

   292

        self._FreePLC()

   293

   294

    def _InitPLCStubCalls(self):

   295

        """

   296

        create dummy C func proxies

   297

        """

   298

        self._startPLC = lambda x, y: None

   299

        self._stopPLC = lambda: None

   300

        self._ResetDebugVariables = lambda: None

   301

        self._RegisterDebugVariable = lambda x, y: 0

   302

        self._IterDebugData = lambda x, y: None

   303

        self._FreeDebugData = lambda: None

   304

        self._GetDebugData = lambda: -1

   305

        self._suspendDebug = lambda x: -1

   306

        self._resumeDebug = lambda: None

   307

        self._PythonIterator = lambda: ""

   308

        self._GetLogCount = None

   309

        self._LogMessage = None

   310

        self._GetLogMessage = None

   311

        self._PLClibraryHandle = None

   312

        self.PLClibraryHandle = None

   313

   314

    def _FreePLC(self):

   315

        """

   316

        Unload PLC library.

   317

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

   318

        """

   319

        self.PLClibraryLock.acquire()

   320

        try:

   321

            # Unload library explicitely

   322

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

   323

                dlclose(self._PLClibraryHandle)

   324

   325

            # Forget all refs to library

   326

            self._InitPLCStubCalls()

   327

   328

        finally:

   329

            self.PLClibraryLock.release()

   330

   331

        return False

   332

   333

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

   334

        """

   335

        Calls init, start, stop or cleanup method provided by

   336

        runtime python files, loaded when new PLC uploaded

   337

        """

   338

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

   339

        if reverse_order:

   340

            methods = reversed(methods)

   341

        for method in methods:

   342

            if use_evaluator:

   343

                _res, exp = self.evaluator(method)

   344

            else:

   345

                _res, exp = default_evaluator(method)

   346

            if exp is not None:

   347

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

   348

   349

    # used internaly

   350

    def PythonRuntimeInit(self):

   351

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

   352

        self.python_runtime_vars = globals().copy()

   353

        self.python_runtime_vars.update(self.pyruntimevars)

   354

        parent = self

   355

   356

        class PLCSafeGlobals(object):

   357

            def __getattr__(self, name):

   358

                try:

   359

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

   360

                except KeyError:

   361

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

   362

                v = t()

   363

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

   364

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

   365

   366

            def __setattr__(self, name, value):

   367

                try:

   368

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

   369

                except KeyError:

   370

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

   371

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

   372

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

   373

   374

        class OnChangeStateClass(object):

   375

            def __getattr__(self, name):

   376

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

   377

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

   378

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

   379

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

   380

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

   381

   382

   383

        self.python_runtime_vars.update({

   384

            "PLCGlobals":     PLCSafeGlobals(),

   385

            "OnChange":       OnChangeStateClass(),

   386

            "WorkingDir":     self.workingdir,

   387

            "PLCObject":      self,

   388

            "PLCBinary":      self.PLClibraryHandle,

   389

            "PLCGlobalsDesc": []})

   390

   391

        for methodname in MethodNames:

   392

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

   393

   394

        try:

   395

            filenames = os.listdir(self.workingdir)

   396

            filenames.sort()

   397

            for filename in filenames:

   398

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

   399

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

   400

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

   401

                    for methodname in MethodNames:

   402

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

   403

                        if method is not None:

   404

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

   405

        except Exception:

   406

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

   407

            raise

   408

   409

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

   410

   411

        self.PythonThreadCondLock = Lock()

   412

        self.PythonThreadCmdCond = Condition(self.PythonThreadCondLock)

   413

        self.PythonThreadAckCond = Condition(self.PythonThreadCondLock)

   414

        self.PythonThreadCmd = None

   415

        self.PythonThreadAck = None

   416

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

   417

        self.PythonThread.start()

   418

   419

    # used internaly

   420

    def PythonRuntimeCleanup(self):

   421

        if self.python_runtime_vars is not None:

   422

            self.PythonThreadCommand("Finish")

   423

            self.PythonThread.join()

   424

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

   425

   426

        self.python_runtime_vars = None

   427

   428

    def PythonThreadLoop(self):

   429

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

   430

        compile_cache = {}

   431

        while True:

   432

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

   433

            FBID = blkid.value

   434

            if cmd is None:

   435

                break

   436

            cmd = cmd.decode()

   437

            try:

   438

                self.python_runtime_vars["FBID"] = FBID

   439

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

   440

                if ccmd is None or ccmd != cmd:

   441

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

   442

                    compile_cache[FBID] = (cmd, AST)

   443

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

   444

                if exp is not None:

   445

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

   446

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

   447

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

   448

                else:

   449

                    res = str(result)

   450

                self.python_runtime_vars["FBID"] = None

   451

            except Exception as e:

   452

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

   453

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

   454

   455

    def PythonThreadProc(self):

   456

        while True:

   457

            self.PythonThreadCondLock.acquire()

   458

            cmd = self.PythonThreadCmd

   459

            while cmd is None:

   460

                self.PythonThreadCmdCond.wait()

   461

                cmd = self.PythonThreadCmd

   462

            self.PythonThreadCmd = None

   463

            self.PythonThreadCondLock.release()

   464

   465

            if cmd == "PreStart":

   466

                self.PreStartPLC()

   467

                # Ack once PreStart done, must be finished before StartPLC

   468

                self.PythonThreadAcknowledge(cmd)

   469

            elif cmd == "Start":

   470

                # Ack Immediately, for responsiveness

   471

                self.PythonThreadAcknowledge(cmd)

   472

                self.PythonRuntimeCall("start")

   473

                self.LogMessage("Python extensions started")

   474

                self._PostStartPLC()

   475

                self.PythonThreadLoop()

   476

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

   477

   478

                # Signal that python runtime has stopped