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

        # initialize extended calls with GetVersions call, ignoring arguments

   108

        self.extended_calls = {"GetVersions":lambda *_args:self.GetVersions().encode()}

   109

   110

    # First task of worker -> no @RunInMain

   111

    def AutoLoad(self, autostart):

   112

        # Get the last transfered PLC

   113

        try:

   114

            self.CurrentPLCFilename = open(

   115

                self._GetMD5FileName(),

   116

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

   117

            self.PLCStatus = PlcStatus.Stopped

   118

            if autostart:

   119

                if self.LoadPLC():

   120

                    self.StartPLC()

   121

                else:

   122

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

   123

                return

   124

        except Exception:

   125

            self.PLCStatus = PlcStatus.Empty

   126

            self.CurrentPLCFilename = None

   127

   128

        self.StatusChange()

   129

   130

    def StatusChange(self):

   131

        if self.statuschange is not None:

   132

            for callee in self.statuschange:

   133

                callee(self.PLCStatus)

   134

   135

    def LogMessage(self, *args):

   136

        if len(args) == 2:

   137

            level, msg = args

   138

        else:

   139

            level = LogLevelsDefault

   140

            msg, = args

   141

        PLCprint(msg)

   142

        if self._LogMessage is not None:

   143

            bmsg = msg.encode()

   144

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

   145

        return None

   146

   147

    @RunInMain

   148

    def ResetLogCount(self):

   149

        if self._ResetLogCount is not None:

   150

            self._ResetLogCount()

   151

   152

    # used internaly

   153

    def GetLogCount(self, level):

   154

        if self._GetLogCount is not None:

   155

            return int(self._GetLogCount(level))

   156

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

   157

            return 1

   158

        return 0

   159

   160

    @RunInMain

   161

    def GetLogMessage(self, level, msgid):

   162

        tick = ctypes.c_uint32()

   163

        tv_sec = ctypes.c_uint32()

   164

        tv_nsec = ctypes.c_uint32()

   165

        if self._GetLogMessage is not None:

   166

            maxsz = len(self._log_read_buffer)-1

   167

            sz = self._GetLogMessage(level, msgid,

   168

                                     self._log_read_buffer, maxsz,

   169

                                     ctypes.byref(tick),

   170

                                     ctypes.byref(tv_sec),

   171

                                     ctypes.byref(tv_nsec))

   172

            if sz and sz <= maxsz:

   173

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

   174

                        tv_sec.value, tv_nsec.value)

   175

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

   176

            return self._loading_error, 0, 0, 0

   177

        return None

   178

   179

    def _GetMD5FileName(self):

   180

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

   181

   182

    def _GetLibFileName(self):

   183

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

   184

   185

    def _LoadPLC(self):

   186

        """

   187

        Load PLC library

   188

        Declare all functions, arguments and return values

   189

        """

   190

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

   191

        self.PLClibraryLock.acquire()

   192

        try:

   193

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

   194

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

   195

   196

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

   197

            if len(md5) == 32:

   198

                self.PLC_ID.value = md5.encode()

   199

   200

            self._startPLC = self.PLClibraryHandle.startPLC

   201

            self._startPLC.restype = ctypes.c_int

   202

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

   203

   204

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   205

            self._stopPLC_real.restype = None

   206

   207

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

   208

            if self._PythonIterator is not None:

   209

                self._PythonIterator.restype = ctypes.c_char_p

   210

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

   211

   212

                self._stopPLC = self._stopPLC_real

   213

            else:

   214

                # If python confnode is not enabled, we reuse _PythonIterator

   215

                # as a call that block pythonthread until StopPLC

   216

                self.PlcStopping = Event()

   217

   218

                def PythonIterator(res, blkid):

   219

                    self.PlcStopping.clear()

   220

                    self.PlcStopping.wait()

   221

                    return None

   222

                self._PythonIterator = PythonIterator

   223

   224

                def __StopPLC():

   225

                    self._stopPLC_real()

   226

                    self.PlcStopping.set()

   227

                self._stopPLC = __StopPLC

   228

   229

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   230

            self._ResetDebugVariables.restype = None

   231

   232

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   233

            self._RegisterDebugVariable.restype = ctypes.c_int

   234

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

   235

   236

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   237

            self._FreeDebugData.restype = None

   238

   239

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   240

            self._GetDebugData.restype = ctypes.c_int

   241

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

   242

   243

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   244

            self._suspendDebug.restype = ctypes.c_int

   245

            self._suspendDebug.argtypes = [ctypes.c_int]

   246

   247

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   248

            self._resumeDebug.restype = None

   249

   250

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   251

            self._ResetLogCount.restype = None

   252

   253

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   254

            self._GetLogCount.restype = ctypes.c_uint32

   255

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   256

   257

            self._LogMessage = self.PLClibraryHandle.LogMessage

   258

            self._LogMessage.restype = ctypes.c_int

   259

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

   260

   261

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

   262

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   263

            self._GetLogMessage.restype = ctypes.c_uint32

   264

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

   265

   266

            self._loading_error = None

   267

   268

        except Exception:

   269

            self._loading_error = traceback.format_exc()

   270

            PLCprint(self._loading_error)

   271

            return False

   272

        finally:

   273

            self.PLClibraryLock.release()

   274

   275

        return True

   276

   277

    @RunInMain

   278

    def LoadPLC(self):

   279

        res = self._LoadPLC()

   280

        if res:

   281

            try:

   282

                self.PythonRuntimeInit()

   283

            except Exception:

   284

                self._loading_error = traceback.format_exc()

   285

                PLCprint(self._loading_error)

   286

                return False

   287

        else:

   288

            self._FreePLC()

   289

   290

        return res

   291

   292

    @RunInMain

   293

    def UnLoadPLC(self):

   294

        self.PythonRuntimeCleanup()

   295

        self._FreePLC()

   296

   297

    def _InitPLCStubCalls(self):

   298

        """

   299

        create dummy C func proxies

   300

        """

   301

        self._startPLC = lambda x, y: None

   302

        self._stopPLC = lambda: None

   303

        self._ResetDebugVariables = lambda: None

   304

        self._RegisterDebugVariable = lambda x, y: 0

   305

        self._IterDebugData = lambda x, y: None

   306

        self._FreeDebugData = lambda: None

   307

        self._GetDebugData = lambda: -1

   308

        self._suspendDebug = lambda x: -1

   309

        self._resumeDebug = lambda: None

   310

        self._PythonIterator = lambda: ""

   311

        self._GetLogCount = None

   312

        self._LogMessage = None

   313

        self._GetLogMessage = None

   314

        self._PLClibraryHandle = None

   315

        self.PLClibraryHandle = None

   316

   317

    def _FreePLC(self):

   318

        """

   319

        Unload PLC library.

   320

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

   321

        """

   322

        self.PLClibraryLock.acquire()

   323

        try:

   324

            # Unload library explicitely

   325

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

   326

                dlclose(self._PLClibraryHandle)

   327

   328

            # Forget all refs to library

   329

            self._InitPLCStubCalls()

   330

   331

        finally:

   332

            self.PLClibraryLock.release()

   333

   334

        return False

   335

   336

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

   337

        """

   338

        Calls init, start, stop or cleanup method provided by

   339

        runtime python files, loaded when new PLC uploaded

   340

        """

   341

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

   342

        if reverse_order:

   343

            methods = reversed(methods)

   344

        for method in methods:

   345

            if use_evaluator:

   346

                _res, exp = self.evaluator(method)

   347

            else:

   348

                _res, exp = default_evaluator(method)

   349

            if exp is not None:

   350

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

   351

   352

    # used internaly

   353

    def PythonRuntimeInit(self):

   354

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

   355

        self.python_runtime_vars = globals().copy()

   356

        self.python_runtime_vars.update(self.pyruntimevars)

   357

        parent = self

   358

   359

        class PLCSafeGlobals(object):

   360

            def __getattr__(self, name):

   361

                try:

   362

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

   363

                except KeyError:

   364

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

   365

                v = t()

   366

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

   367

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

   368

   369

            def __setattr__(self, name, value):

   370

                try:

   371

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

   372

                except KeyError:

   373

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

   374

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

   375

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

   376

   377

        class OnChangeStateClass(object):

   378

            def __getattr__(self, name):

   379

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

   380

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

   381

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

   382

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

   383

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

   384

   385

   386

        self.python_runtime_vars.update({

   387

            "PLCGlobals":     PLCSafeGlobals(),

   388

            "OnChange":       OnChangeStateClass(),

   389

            "WorkingDir":     self.workingdir,

   390

            "PLCObject":      self,

   391

            "PLCBinary":      self.PLClibraryHandle,

   392

            "PLCGlobalsDesc": []})

   393

   394

        for methodname in MethodNames:

   395

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

   396

   397

        try:

   398

            filenames = os.listdir(self.workingdir)

   399

            filenames.sort()

   400

            for filename in filenames:

   401

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

   402

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

   403

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

   404

                    for methodname in MethodNames:

   405

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

   406

                        if method is not None:

   407

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

   408

        except Exception:

   409

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

   410

            raise

   411

   412

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

   413

   414

        self.PythonThreadCondLock = Lock()

   415

        self.PythonThreadCmdCond = Condition(self.PythonThreadCondLock)

   416

        self.PythonThreadAckCond = Condition(self.PythonThreadCondLock)

   417

        self.PythonThreadCmd = None

   418

        self.PythonThreadAck = None

   419

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

   420

        self.PythonThread.start()

   421

   422

    # used internaly

   423

    def PythonRuntimeCleanup(self):

   424

        if self.python_runtime_vars is not None:

   425

            self.PythonThreadCommand("Finish")

   426

            self.PythonThread.join()

   427

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

   428

   429

        self.python_runtime_vars = None

   430

   431

    def PythonThreadLoop(self):

   432

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

   433

        compile_cache = {}

   434

        while True:

   435

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

   436

            FBID = blkid.value

   437

            if cmd is None:

   438

                break

   439

            cmd = cmd.decode()

   440

            try:

   441

                self.python_runtime_vars["FBID"] = FBID

   442

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

   443

                if ccmd is None or ccmd != cmd:

   444

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

   445

                    compile_cache[FBID] = (cmd, AST)

   446

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

   447

                if exp is not None:

   448

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

   449

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

   450

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

   451

                else:

   452

                    res = str(result)

   453

                self.python_runtime_vars["FBID"] = None

   454

            except Exception as e:

   455

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

   456

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

   457

   458

    def PythonThreadProc(self):

   459

        while True:

   460

            self.PythonThreadCondLock.acquire()

   461

            cmd = self.PythonThreadCmd

   462

            while cmd is None:

   463

                self.PythonThreadCmdCond.wait()

   464

                cmd = self.PythonThreadCmd

   465

            self.PythonThreadCmd = None

   466

            self.PythonThreadCondLock.release()

   467

   468

            if cmd == "PreStart":

   469

                self.PreStartPLC()

   470

                # Ack once PreStart done, must be finished before StartPLC

   471

                self.PythonThreadAcknowledge(cmd)

   472

            elif cmd == "Start":

   473

                # Ack Immediately, for responsiveness

   474

                self.PythonThreadAcknowledge(cmd)

   475

                self.PythonRuntimeCall("start")

   476

                self.LogMessage("Python extensions started")

   477

                self._PostStartPLC()

   478

                self.PythonThreadLoop()