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

            bmsg = msg.encode()

   135

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

   136

        return None

   137

   138

    @RunInMain

   139

    def ResetLogCount(self):

   140

        if self._ResetLogCount is not None:

   141

            self._ResetLogCount()

   142

   143

    # used internaly

   144

    def GetLogCount(self, level):

   145

        if self._GetLogCount is not None:

   146

            return int(self._GetLogCount(level))

   147

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

   148

            return 1

   149

   150

    @RunInMain

   151

    def GetLogMessage(self, level, msgid):

   152

        tick = ctypes.c_uint32()

   153

        tv_sec = ctypes.c_uint32()

   154

        tv_nsec = ctypes.c_uint32()

   155

        if self._GetLogMessage is not None:

   156

            maxsz = len(self._log_read_buffer)-1

   157

            sz = self._GetLogMessage(level, msgid,

   158

                                     self._log_read_buffer, maxsz,

   159

                                     ctypes.byref(tick),

   160

                                     ctypes.byref(tv_sec),

   161

                                     ctypes.byref(tv_nsec))

   162

            if sz and sz <= maxsz:

   163

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

   164

                        tv_sec.value, tv_nsec.value)

   165

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

   166

            return self._loading_error, 0, 0, 0

   167

        return None

   168

   169

    def _GetMD5FileName(self):

   170

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

   171

   172

    def _GetLibFileName(self):

   173

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

   174

   175

    def _LoadPLC(self):

   176

        """

   177

        Load PLC library

   178

        Declare all functions, arguments and return values

   179

        """

   180

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

   181

        self.PLClibraryLock.acquire()

   182

        try:

   183

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

   184

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

   185

   186

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

   187

            if len(md5) == 32:

   188

                self.PLC_ID.value = md5.encode()

   189

   190

            self._startPLC = self.PLClibraryHandle.startPLC

   191

            self._startPLC.restype = ctypes.c_int

   192

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

   193

   194

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   195

            self._stopPLC_real.restype = None

   196

   197

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

   198

            if self._PythonIterator is not None:

   199

                self._PythonIterator.restype = ctypes.c_char_p

   200

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

   201

   202

                self._stopPLC = self._stopPLC_real

   203

            else:

   204

                # If python confnode is not enabled, we reuse _PythonIterator

   205

                # as a call that block pythonthread until StopPLC

   206

                self.PlcStopping = Event()

   207

   208

                def PythonIterator(res, blkid):

   209

                    self.PlcStopping.clear()

   210

                    self.PlcStopping.wait()

   211

                    return None

   212

                self._PythonIterator = PythonIterator

   213

   214

                def __StopPLC():

   215

                    self._stopPLC_real()

   216

                    self.PlcStopping.set()

   217

                self._stopPLC = __StopPLC

   218

   219

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   220

            self._ResetDebugVariables.restype = None

   221

   222

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   223

            self._RegisterDebugVariable.restype = ctypes.c_int

   224

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

   225

   226

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   227

            self._FreeDebugData.restype = None

   228

   229

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   230

            self._GetDebugData.restype = ctypes.c_int

   231

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

   232

   233

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   234

            self._suspendDebug.restype = ctypes.c_int

   235

            self._suspendDebug.argtypes = [ctypes.c_int]

   236

   237

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   238

            self._resumeDebug.restype = None

   239

   240

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   241

            self._ResetLogCount.restype = None

   242

   243

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   244

            self._GetLogCount.restype = ctypes.c_uint32

   245

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   246

   247

            self._LogMessage = self.PLClibraryHandle.LogMessage

   248

            self._LogMessage.restype = ctypes.c_int

   249

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

   250

   251

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

   252

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   253

            self._GetLogMessage.restype = ctypes.c_uint32

   254

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

   255

   256

            self._loading_error = None

   257

   258

        except Exception:

   259

            self._loading_error = traceback.format_exc()

   260

            PLCprint(self._loading_error)

   261

            return False

   262

        finally:

   263

            self.PLClibraryLock.release()

   264

   265

        return True

   266

   267

    @RunInMain

   268

    def LoadPLC(self):

   269

        res = self._LoadPLC()

   270

        if res:

   271

            try:

   272

                self.PythonRuntimeInit()

   273

            except Exception:

   274

                self._loading_error = traceback.format_exc()

   275

                PLCprint(self._loading_error)

   276

                return False

   277

        else:

   278

            self._FreePLC()

   279

   280

        return res

   281

   282

    @RunInMain

   283

    def UnLoadPLC(self):

   284

        self.PythonRuntimeCleanup()

   285

        self._FreePLC()

   286

   287

    def _InitPLCStubCalls(self):

   288

        """

   289

        create dummy C func proxies

   290

        """

   291

        self._startPLC = lambda x, y: None

   292

        self._stopPLC = lambda: None

   293

        self._ResetDebugVariables = lambda: None

   294

        self._RegisterDebugVariable = lambda x, y: 0

   295

        self._IterDebugData = lambda x, y: None

   296

        self._FreeDebugData = lambda: None

   297

        self._GetDebugData = lambda: -1

   298

        self._suspendDebug = lambda x: -1

   299

        self._resumeDebug = lambda: None

   300

        self._PythonIterator = lambda: ""

   301

        self._GetLogCount = None

   302

        self._LogMessage = None

   303

        self._GetLogMessage = None

   304

        self._PLClibraryHandle = None

   305

        self.PLClibraryHandle = None

   306

   307

    def _FreePLC(self):

   308

        """

   309

        Unload PLC library.

   310

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

   311

        """

   312

        self.PLClibraryLock.acquire()

   313

        try:

   314

            # Unload library explicitely

   315

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

   316

                dlclose(self._PLClibraryHandle)

   317

   318

            # Forget all refs to library

   319

            self._InitPLCStubCalls()

   320

   321

        finally:

   322

            self.PLClibraryLock.release()

   323

   324

        return False

   325

   326

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

   327

        """

   328

        Calls init, start, stop or cleanup method provided by

   329

        runtime python files, loaded when new PLC uploaded

   330

        """

   331

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

   332

        if reverse_order:

   333

            methods = reversed(methods)

   334

        for method in methods:

   335

            if use_evaluator:

   336

                _res, exp = self.evaluator(method)

   337

            else:

   338

                _res, exp = default_evaluator(method)

   339

            if exp is not None:

   340

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

   341

   342

    # used internaly

   343

    def PythonRuntimeInit(self):

   344

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

   345

        self.python_runtime_vars = globals().copy()

   346

        self.python_runtime_vars.update(self.pyruntimevars)

   347

        parent = self

   348

   349

        class PLCSafeGlobals(object):

   350

            def __getattr__(self, name):

   351

                try:

   352

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

   353

                except KeyError:

   354

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

   355

                v = t()

   356

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

   357

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

   358

   359

            def __setattr__(self, name, value):

   360

                try:

   361

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

   362

                except KeyError:

   363

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

   364

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

   365

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

   366

   367

        class OnChangeStateClass(object):

   368

            def __getattr__(self, name):

   369

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

   370

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

   371

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

   372

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

   373

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

   374

   375

   376

        self.python_runtime_vars.update({

   377

            "PLCGlobals":     PLCSafeGlobals(),

   378

            "OnChange":       OnChangeStateClass(),

   379

            "WorkingDir":     self.workingdir,

   380

            "PLCObject":      self,

   381

            "PLCBinary":      self.PLClibraryHandle,

   382

            "PLCGlobalsDesc": []})

   383

   384

        for methodname in MethodNames:

   385

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

   386

   387

        try:

   388

            filenames = os.listdir(self.workingdir)

   389

            filenames.sort()

   390

            for filename in filenames:

   391

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

   392

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

   393

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

   394

                    for methodname in MethodNames:

   395

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

   396

                        if method is not None:

   397

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

   398

        except Exception:

   399

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

   400

            raise

   401

   402

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

   403

   404

        self.PythonThreadCondLock = Lock()

   405

        self.PythonThreadCmdCond = Condition(self.PythonThreadCondLock)

   406

        self.PythonThreadAckCond = Condition(self.PythonThreadCondLock)

   407

        self.PythonThreadCmd = None

   408

        self.PythonThreadAck = None

   409

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

   410

        self.PythonThread.start()

   411

   412

    # used internaly

   413

    def PythonRuntimeCleanup(self):

   414

        if self.python_runtime_vars is not None:

   415

            self.PythonThreadCommand("Finish")

   416

            self.PythonThread.join()

   417

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

   418

   419

        self.python_runtime_vars = None

   420

   421

    def PythonThreadLoop(self):

   422

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

   423

        compile_cache = {}

   424

        while True:

   425

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

   426

            FBID = blkid.value

   427

            if cmd is None:

   428

                break

   429

            cmd = cmd.decode()

   430

            try:

   431

                self.python_runtime_vars["FBID"] = FBID

   432

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

   433

                if ccmd is None or ccmd != cmd:

   434

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

   435

                    compile_cache[FBID] = (cmd, AST)

   436

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

   437

                if exp is not None:

   438

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

   439

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

   440

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

   441

                else:

   442

                    res = str(result)

   443

                self.python_runtime_vars["FBID"] = None

   444

            except Exception as e:

   445

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

   446

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

   447

   448

    def PythonThreadProc(self):

   449

        while True:

   450

            self.PythonThreadCondLock.acquire()

   451

            cmd = self.PythonThreadCmd

   452

            while cmd is None:

   453

                self.PythonThreadCmdCond.wait()

   454

                cmd = self.PythonThreadCmd

   455

            self.PythonThreadCmd = None

   456

            self.PythonThreadCondLock.release()

   457

   458

            if cmd == "PreStart":

   459

                self.PreStartPLC()

   460

                # Ack once PreStart done, must be finished before StartPLC

   461

                self.PythonThreadAcknowledge(cmd)

   462

            elif cmd == "Start":

   463

                # Ack Immediately, for responsiveness

   464

                self.PythonThreadAcknowledge(cmd)

   465

                self.PythonRuntimeCall("start")

   466

                self.LogMessage("Python extensions started")

   467

                self._PostStartPLC()

   468

                self.PythonThreadLoop()

   469

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

   470

            elif cmd == "Finish":

   471

                self.PythonThreadAcknowledge(cmd)

   472

                break

   473

   474

    def PythonThreadAcknowledge(self, ack):

   475

        self.PythonThreadCondLock.acquire()

   476

        self.PythonThreadAck = ack

   477

        self.PythonThreadAckCond.notify()

   478

        self.PythonThreadCondLock.release()