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 __future__ import absolute_import

    26

from threading import Thread, Lock, Event, Condition

    27

import ctypes

    28

import os

    29

import sys

    30

import traceback

    31

import shutil

    32

from time import time

    33

import hashlib

    34

from tempfile import mkstemp

    35

from functools import wraps, partial

    36

from six.moves import xrange

    37

from past.builtins import execfile

    38

import _ctypes

    39

    40

from runtime.typemapping import TypeTranslator

    41

from runtime.loglevels import LogLevelsDefault, LogLevelsCount

    42

from runtime.Stunnel import getPSKID

    43

from runtime import PlcStatus

    44

from runtime import MainWorker

    45

from runtime import default_evaluator

    46

    47

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

    48

    dlopen = _ctypes.LoadLibrary

    49

    dlclose = _ctypes.FreeLibrary

    50

elif os.name == "posix":

    51

    dlopen = _ctypes.dlopen

    52

    dlclose = _ctypes.dlclose

    53

    54

    55

def get_last_traceback(tb):

    56

    while tb.tb_next:

    57

        tb = tb.tb_next

    58

    return tb

    59

    60

    61

lib_ext = {

    62

    "linux2": ".so",

    63

    "win32":  ".dll",

    64

}.get(sys.platform, "")

    65

    66

    67

def PLCprint(message):

    68

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

    69

    sys.stdout.flush()

    70

    71

    72

def RunInMain(func):

    73

    @wraps(func)

    74

    def func_wrapper(*args, **kwargs):

    75

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

    76

    return func_wrapper

    77

    78

    79

class PLCObject(object):

    80

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

    81

        self.workingdir = WorkingDir  # must exits already

    82

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

    83

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

    84

            shutil.rmtree(self.tmpdir)

    85

        os.mkdir(self.tmpdir)

    86

        # FIXME : is argv of any use nowadays ?

    87

        self.argv = [WorkingDir] + argv  # force argv[0] to be "path" to exec...

    88

        self.statuschange = statuschange

    89

        self.evaluator = evaluator

    90

        self.pyruntimevars = pyruntimevars

    91

        self.PLCStatus = PlcStatus.Empty

    92

        self.PLClibraryHandle = None

    93

        self.PLClibraryLock = Lock()

    94

        # Creates fake C funcs proxies

    95

        self._InitPLCStubCalls()

    96

        self._loading_error = None

    97

        self.python_runtime_vars = None

    98

        self.TraceThread = None

    99

        self.TraceLock = Lock()

   100

        self.Traces = []

   101

        self.DebugToken = 0

   102

   103

        self._init_blobs()

   104

   105

    # First task of worker -> no @RunInMain

   106

    def AutoLoad(self, autostart):

   107

        # Get the last transfered PLC

   108

        try:

   109

            self.CurrentPLCFilename = open(

   110

                self._GetMD5FileName(),

   111

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

   112

            self.PLCStatus = PlcStatus.Stopped

   113

            if autostart:

   114

                if self.LoadPLC():

   115

                    self.StartPLC()

   116

                    return

   117

        except Exception:

   118

            self.PLCStatus = PlcStatus.Empty

   119

            self.CurrentPLCFilename = None

   120

   121

        self.StatusChange()

   122

   123

    def StatusChange(self):

   124

        if self.statuschange is not None:

   125

            for callee in self.statuschange:

   126

                callee(self.PLCStatus)

   127

   128

    def LogMessage(self, *args):

   129

        if len(args) == 2:

   130

            level, msg = args

   131

        else:

   132

            level = LogLevelsDefault

   133

            msg, = args

   134

        PLCprint(msg)

   135

        if self._LogMessage is not None:

   136

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

   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

                self._log_read_buffer[sz] = '\x00'

   165

                return self._log_read_buffer.value, tick.value, 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

   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 = None

   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

            self.PythonRuntimeInit()

   273

        else:

   274

            self._FreePLC()

   275

   276

        return res

   277

   278

    @RunInMain

   279

    def UnLoadPLC(self):

   280

        self.PythonRuntimeCleanup()

   281

        self._FreePLC()

   282

   283

    def _InitPLCStubCalls(self):

   284

        """

   285

        create dummy C func proxies

   286

        """

   287

        self._startPLC = lambda x, y: None

   288

        self._stopPLC = lambda: None

   289

        self._ResetDebugVariables = lambda: None

   290

        self._RegisterDebugVariable = lambda x, y: None

   291

        self._IterDebugData = lambda x, y: None

   292

        self._FreeDebugData = lambda: None

   293

        self._GetDebugData = lambda: -1

   294

        self._suspendDebug = lambda x: -1

   295

        self._resumeDebug = lambda: None

   296

        self._PythonIterator = lambda: ""

   297

        self._GetLogCount = None

   298

        self._LogMessage = None

   299

        self._GetLogMessage = None

   300

        self._PLClibraryHandle = None

   301

        self.PLClibraryHandle = None

   302

   303

    def _FreePLC(self):

   304

        """

   305

        Unload PLC library.

   306

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

   307

        """

   308

        self.PLClibraryLock.acquire()

   309

        try:

   310

            # Unload library explicitely

   311

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

   312

                dlclose(self._PLClibraryHandle)

   313

   314

            # Forget all refs to library

   315

            self._InitPLCStubCalls()

   316

   317

        finally:

   318

            self.PLClibraryLock.release()

   319

   320

        return False

   321

   322

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

   323

        """

   324

        Calls init, start, stop or cleanup method provided by

   325

        runtime python files, loaded when new PLC uploaded

   326

        """

   327

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

   328

        if reverse_order:

   329

            methods = reversed(methods)

   330

        for method in methods:

   331

            if use_evaluator:

   332

                _res, exp = self.evaluator(method)

   333

            else:

   334

                _res, exp = default_evaluator(method)

   335

            if exp is not None:

   336

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

   337

   338

    # used internaly

   339

    def PythonRuntimeInit(self):

   340

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

   341

        self.python_runtime_vars = globals().copy()

   342

        self.python_runtime_vars.update(self.pyruntimevars)

   343

        parent = self

   344

   345

        class PLCSafeGlobals(object):

   346

            def __getattr__(self, name):

   347

                try:

   348

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

   349

                except KeyError:

   350

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

   351

                v = t()

   352

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

   353

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

   354

   355

            def __setattr__(self, name, value):

   356

                try:

   357

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

   358

                except KeyError:

   359

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

   360

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

   361

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

   362

   363

        class OnChangeStateClass(object):

   364

            def __getattr__(self, name):

   365

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

   366

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

   367

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

   368

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

   369

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

   370

   371

   372

        self.python_runtime_vars.update({

   373

            "PLCGlobals":     PLCSafeGlobals(),

   374

            "OnChange":       OnChangeStateClass(),

   375

            "WorkingDir":     self.workingdir,

   376

            "PLCObject":      self,

   377

            "PLCBinary":      self.PLClibraryHandle,

   378

            "PLCGlobalsDesc": []})

   379

   380

        for methodname in MethodNames:

   381

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

   382

   383

        try:

   384

            filenames = os.listdir(self.workingdir)

   385

            filenames.sort()

   386

            for filename in filenames:

   387

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

   388

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

   389

                    execfile(os.path.join(self.workingdir, filename), self.python_runtime_vars)

   390

                    for methodname in MethodNames:

   391

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

   392

                        if method is not None:

   393

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

   394

        except Exception:

   395

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

   396

            raise

   397

   398

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

   399

   400

        self.PythonThreadCondLock = Lock()

   401

        self.PythonThreadCmdCond = Condition(self.PythonThreadCondLock)

   402

        self.PythonThreadAckCond = Condition(self.PythonThreadCondLock)

   403

        self.PythonThreadCmd = None

   404

        self.PythonThreadAck = None

   405

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

   406

        self.PythonThread.start()

   407

   408

    # used internaly

   409

    def PythonRuntimeCleanup(self):

   410

        if self.python_runtime_vars is not None:

   411

            self.PythonThreadCommand("Finish")

   412

            self.PythonThread.join()

   413

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

   414

   415

        self.python_runtime_vars = None

   416

   417

    def PythonThreadLoop(self):

   418

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

   419

        compile_cache = {}

   420

        while True:

   421

            cmd = self._PythonIterator(res, blkid)

   422

            FBID = blkid.value

   423

            if cmd is None:

   424

                break

   425

            try:

   426

                self.python_runtime_vars["FBID"] = FBID

   427

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

   428

                if ccmd is None or ccmd != cmd:

   429

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

   430

                    compile_cache[FBID] = (cmd, AST)

   431

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

   432

                if exp is not None:

   433

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

   434

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

   435

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

   436

                else:

   437

                    res = str(result)

   438

                self.python_runtime_vars["FBID"] = None

   439

            except Exception as e:

   440

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

   441

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

   442

   443

    def PythonThreadProc(self):

   444

        while True:

   445

            self.PythonThreadCondLock.acquire()

   446

            cmd = self.PythonThreadCmd

   447

            while cmd is None:

   448

                self.PythonThreadCmdCond.wait()

   449

                cmd = self.PythonThreadCmd

   450

            self.PythonThreadCmd = None

   451

            self.PythonThreadCondLock.release()

   452

   453

            if cmd == "PreStart":

   454

                self.PreStartPLC()

   455

                # Ack once PreStart done, must be finished before StartPLC

   456

                self.PythonThreadAcknowledge(cmd)

   457

            elif cmd == "Start":

   458

                # Ack Immediately, for responsiveness

   459

                self.PythonThreadAcknowledge(cmd)

   460

                self.PythonRuntimeCall("start")

   461

                self.LogMessage("Python extensions started")

   462

                self.PostStartPLC()

   463

                self.PythonThreadLoop()

   464

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

   465

            elif cmd == "Finish":

   466

                self.PythonThreadAcknowledge(cmd)

   467

                break

   468

   469

    def PythonThreadAcknowledge(self, ack):

   470

        self.PythonThreadCondLock.acquire()

   471

        self.PythonThreadAck = ack

   472

        self.PythonThreadAckCond.notify()

   473

        self.PythonThreadCondLock.release()

   474

   475

    def PythonThreadCommand(self, cmd):

   476

        self.PythonThreadCondLock.acquire()

   477

        self.PythonThreadCmd = cmd

   478

        self.PythonThreadCmdCond.notify()

   479