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

                else:

   117

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

   118

                return

   119

        except Exception:

   120

            self.PLCStatus = PlcStatus.Empty

   121

            self.CurrentPLCFilename = None

   122

   123

        self.StatusChange()

   124

   125

    def StatusChange(self):

   126

        if self.statuschange is not None:

   127

            for callee in self.statuschange:

   128

                callee(self.PLCStatus)

   129

   130

    def LogMessage(self, *args):

   131

        if len(args) == 2:

   132

            level, msg = args

   133

        else:

   134

            level = LogLevelsDefault

   135

            msg, = args

   136

        PLCprint(msg)

   137

        if self._LogMessage is not None:

   138

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

   139

        return None

   140

   141

    @RunInMain

   142

    def ResetLogCount(self):

   143

        if self._ResetLogCount is not None:

   144

            self._ResetLogCount()

   145

   146

    # used internaly

   147

    def GetLogCount(self, level):

   148

        if self._GetLogCount is not None:

   149

            return int(self._GetLogCount(level))

   150

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

   151

            return 1

   152

   153

    @RunInMain

   154

    def GetLogMessage(self, level, msgid):

   155

        tick = ctypes.c_uint32()

   156

        tv_sec = ctypes.c_uint32()

   157

        tv_nsec = ctypes.c_uint32()

   158

        if self._GetLogMessage is not None:

   159

            maxsz = len(self._log_read_buffer)-1

   160

            sz = self._GetLogMessage(level, msgid,

   161

                                     self._log_read_buffer, maxsz,

   162

                                     ctypes.byref(tick),

   163

                                     ctypes.byref(tv_sec),

   164

                                     ctypes.byref(tv_nsec))

   165

            if sz and sz <= maxsz:

   166

                self._log_read_buffer[sz] = '\x00'

   167

                return self._log_read_buffer.value, tick.value, tv_sec.value, tv_nsec.value

   168

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

   169

            return self._loading_error, 0, 0, 0

   170

        return None

   171

   172

    def _GetMD5FileName(self):

   173

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

   174

   175

    def _GetLibFileName(self):

   176

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

   177

   178

    def _LoadPLC(self):

   179

        """

   180

        Load PLC library

   181

        Declare all functions, arguments and return values

   182

        """

   183

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

   184

        self.PLClibraryLock.acquire()

   185

        try:

   186

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

   187

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

   188

   189

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

   190

            if len(md5) == 32:

   191

                self.PLC_ID.value = md5

   192

   193

            self._startPLC = self.PLClibraryHandle.startPLC

   194

            self._startPLC.restype = ctypes.c_int

   195

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

   196

   197

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   198

            self._stopPLC_real.restype = None

   199

   200

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

   201

            if self._PythonIterator is not None:

   202

                self._PythonIterator.restype = ctypes.c_char_p

   203

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

   204

   205

                self._stopPLC = self._stopPLC_real

   206

            else:

   207

                # If python confnode is not enabled, we reuse _PythonIterator

   208

                # as a call that block pythonthread until StopPLC

   209

                self.PlcStopping = Event()

   210

   211

                def PythonIterator(res, blkid):

   212

                    self.PlcStopping.clear()

   213

                    self.PlcStopping.wait()

   214

                    return None

   215

                self._PythonIterator = PythonIterator

   216

   217

                def __StopPLC():

   218

                    self._stopPLC_real()

   219

                    self.PlcStopping.set()

   220

                self._stopPLC = __StopPLC

   221

   222

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   223

            self._ResetDebugVariables.restype = None

   224

   225

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   226

            self._RegisterDebugVariable.restype = ctypes.c_int

   227

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

   228

   229

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   230

            self._FreeDebugData.restype = None

   231

   232

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   233

            self._GetDebugData.restype = ctypes.c_int

   234

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

   235

   236

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   237

            self._suspendDebug.restype = ctypes.c_int

   238

            self._suspendDebug.argtypes = [ctypes.c_int]

   239

   240

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   241

            self._resumeDebug.restype = None

   242

   243

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   244

            self._ResetLogCount.restype = None

   245

   246

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   247

            self._GetLogCount.restype = ctypes.c_uint32

   248

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   249

   250

            self._LogMessage = self.PLClibraryHandle.LogMessage

   251

            self._LogMessage.restype = ctypes.c_int

   252

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

   253

   254

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

   255

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   256

            self._GetLogMessage.restype = ctypes.c_uint32

   257

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

   258

   259

            self._loading_error = None

   260

   261

        except Exception:

   262

            self._loading_error = traceback.format_exc()

   263

            PLCprint(self._loading_error)

   264

            return False

   265

        finally:

   266

            self.PLClibraryLock.release()

   267

   268

        return True

   269

   270

    @RunInMain

   271

    def LoadPLC(self):

   272

        res = self._LoadPLC()

   273

        if res:

   274

            try:

   275

                self.PythonRuntimeInit()

   276

            except Exception:

   277

                self._loading_error = traceback.format_exc()

   278

                PLCprint(self._loading_error)

   279

                return False

   280

        else:

   281

            self._FreePLC()

   282

   283

        return res

   284

   285

    @RunInMain

   286

    def UnLoadPLC(self):

   287

        self.PythonRuntimeCleanup()

   288

        self._FreePLC()

   289

   290

    def _InitPLCStubCalls(self):

   291

        """

   292

        create dummy C func proxies

   293

        """

   294

        self._startPLC = lambda x, y: None

   295

        self._stopPLC = lambda: None

   296

        self._ResetDebugVariables = lambda: None

   297

        self._RegisterDebugVariable = lambda x, y: 0

   298

        self._IterDebugData = lambda x, y: None

   299

        self._FreeDebugData = lambda: None

   300

        self._GetDebugData = lambda: -1

   301

        self._suspendDebug = lambda x: -1

   302

        self._resumeDebug = lambda: None

   303

        self._PythonIterator = lambda: ""

   304

        self._GetLogCount = None

   305

        self._LogMessage = None

   306

        self._GetLogMessage = None

   307

        self._PLClibraryHandle = None

   308

        self.PLClibraryHandle = None

   309

   310

    def _FreePLC(self):

   311

        """

   312

        Unload PLC library.

   313

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

   314

        """

   315

        self.PLClibraryLock.acquire()

   316

        try:

   317

            # Unload library explicitely

   318

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

   319

                dlclose(self._PLClibraryHandle)

   320

   321

            # Forget all refs to library

   322

            self._InitPLCStubCalls()

   323

   324

        finally:

   325

            self.PLClibraryLock.release()

   326

   327

        return False

   328

   329

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

   330

        """

   331

        Calls init, start, stop or cleanup method provided by

   332

        runtime python files, loaded when new PLC uploaded

   333

        """

   334

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

   335

        if reverse_order:

   336

            methods = reversed(methods)

   337

        for method in methods:

   338

            if use_evaluator:

   339

                _res, exp = self.evaluator(method)

   340

            else:

   341

                _res, exp = default_evaluator(method)

   342

            if exp is not None:

   343

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

   344

   345

    # used internaly

   346

    def PythonRuntimeInit(self):

   347

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

   348

        self.python_runtime_vars = globals().copy()

   349

        self.python_runtime_vars.update(self.pyruntimevars)

   350

        parent = self

   351

   352

        class PLCSafeGlobals(object):

   353

            def __getattr__(self, name):

   354

                try:

   355

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

   356

                except KeyError:

   357

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

   358

                v = t()

   359

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

   360

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

   361

   362

            def __setattr__(self, name, value):

   363

                try:

   364

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

   365

                except KeyError:

   366

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

   367

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

   368

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

   369

   370

        class OnChangeStateClass(object):

   371

            def __getattr__(self, name):

   372

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

   373

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

   374

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

   375

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

   376

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

   377

   378

   379

        self.python_runtime_vars.update({

   380

            "PLCGlobals":     PLCSafeGlobals(),

   381

            "OnChange":       OnChangeStateClass(),

   382

            "WorkingDir":     self.workingdir,

   383

            "PLCObject":      self,

   384

            "PLCBinary":      self.PLClibraryHandle,

   385

            "PLCGlobalsDesc": []})

   386

   387

        for methodname in MethodNames:

   388

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

   389

   390

        try:

   391

            filenames = os.listdir(self.workingdir)

   392

            filenames.sort()

   393

            for filename in filenames:

   394

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

   395

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

   396

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

   397

                    for methodname in MethodNames:

   398

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

   399

                        if method is not None:

   400

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

   401

        except Exception:

   402

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

   403

            raise

   404

   405

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

   406

   407

        self.PythonThreadCondLock = Lock()

   408

        self.PythonThreadCmdCond = Condition(self.PythonThreadCondLock)

   409

        self.PythonThreadAckCond = Condition(self.PythonThreadCondLock)

   410

        self.PythonThreadCmd = None

   411

        self.PythonThreadAck = None

   412

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

   413

        self.PythonThread.start()

   414

   415

    # used internaly

   416

    def PythonRuntimeCleanup(self):

   417

        if self.python_runtime_vars is not None:

   418

            self.PythonThreadCommand("Finish")

   419

            self.PythonThread.join()

   420

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

   421

   422

        self.python_runtime_vars = None

   423

   424

    def PythonThreadLoop(self):

   425

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

   426

        compile_cache = {}

   427

        while True:

   428

            cmd = self._PythonIterator(res, blkid)

   429

            FBID = blkid.value

   430

            if cmd is None:

   431

                break

   432

            try:

   433

                self.python_runtime_vars["FBID"] = FBID

   434

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

   435

                if ccmd is None or ccmd != cmd:

   436

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

   437

                    compile_cache[FBID] = (cmd, AST)

   438

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

   439

                if exp is not None:

   440

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

   441

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

   442

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

   443

                else:

   444

                    res = str(result)

   445

                self.python_runtime_vars["FBID"] = None

   446

            except Exception as e:

   447

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

   448

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

   449

   450

    def PythonThreadProc(self):

   451

        while True:

   452

            self.PythonThreadCondLock.acquire()

   453

            cmd = self.PythonThreadCmd

   454

            while cmd is None:

   455

                self.PythonThreadCmdCond.wait()

   456

                cmd = self.PythonThreadCmd

   457

            self.PythonThreadCmd = None

   458

            self.PythonThreadCondLock.release()

   459

   460

            if cmd == "PreStart":

   461

                self.PreStartPLC()

   462

                # Ack once PreStart done, must be finished before StartPLC

   463

                self.PythonThreadAcknowledge(cmd)

   464

            elif cmd == "Start":

   465

                # Ack Immediately, for responsiveness

   466

                self.PythonThreadAcknowledge(cmd)

   467

                self.PythonRuntimeCall("start")

   468

                self.LogMessage("Python extensions started")

   469

                self._PostStartPLC()

   470

                self.PythonThreadLoop()

   471

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

   472

            elif cmd == "Finish":

   473

                self.PythonThreadAcknowledge(cmd)

   474

                break

   475

   476

    def PythonThreadAcknowledge(self, ack):

   477

        self.PythonThreadCondLock.acquire()

   478

        self.PythonThreadAck = ack