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

   373

        self.python_runtime_vars.update({

   374

            "PLCGlobals":     PLCSafeGlobals(),

   376

            "WorkingDir":     self.workingdir,

   377

            "PLCObject":      self,

   378

            "PLCBinary":      self.PLClibraryHandle,

   379

            "PLCGlobalsDesc": []})

   380

   381

        for methodname in MethodNames:

   382

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

   383

   384

        try:

   385

            filenames = os.listdir(self.workingdir)

   386

            filenames.sort()

   387

            for filename in filenames:

   388

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

   389

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

   390

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

   391

                    for methodname in MethodNames:

   392

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

   393

                        if method is not None:

   394

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

   395

        except Exception:

   396

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

   397

            raise

   398

   399

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

   400

   401

        self.PythonThreadCondLock = Lock()

   402

        self.PythonThreadCond = Condition(self.PythonThreadCondLock)

   403

        self.PythonThreadCmd = "Wait"

   404

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

   405

        self.PythonThread.start()

   406

   407

    # used internaly

   408

    def PythonRuntimeCleanup(self):

   409

        if self.python_runtime_vars is not None:

   410

            self.PythonThreadCommand("Finish")

   411

            self.PythonThread.join()

   412

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

   413

   414

        self.python_runtime_vars = None

   415

   416

    def PythonThreadLoop(self):

   417

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

   418

        compile_cache = {}

   419

        while True:

   420

            cmd = self._PythonIterator(res, blkid)

   421

            FBID = blkid.value

   422

            if cmd is None:

   423

                break

   424

            try:

   425

                self.python_runtime_vars["FBID"] = FBID

   426

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

   427

                if ccmd is None or ccmd != cmd:

   428

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

   429

                    compile_cache[FBID] = (cmd, AST)

   430

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

   431

                if exp is not None:

   432

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

   433

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

   434

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

   435

                else:

   436

                    res = str(result)

   437

                self.python_runtime_vars["FBID"] = None

   438

            except Exception as e:

   439

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

   440

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

   441

   442

    def PythonThreadProc(self):

   443

        while True:

   444

            self.PythonThreadCondLock.acquire()

   445

            cmd = self.PythonThreadCmd

   446

            while cmd == "Wait":

   447

                self.PythonThreadCond.wait()

   448

                cmd = self.PythonThreadCmd

   449

                self.PythonThreadCmd = "Wait"

   450

            self.PythonThreadCondLock.release()

   451

   452

            if cmd == "Activate":

   453

                self.PythonRuntimeCall("start")

   454

                self.PreStartPLC()

   455

                self.PythonThreadLoop()

   456

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

   457

            else:  # "Finish"

   458

                break

   459

   460

    def PythonThreadCommand(self, cmd):

   461

        self.PythonThreadCondLock.acquire()

   462

        self.PythonThreadCmd = cmd

   463

        self.PythonThreadCond.notify()

   464

        self.PythonThreadCondLock.release()

   465

   466

    def _fail(self, msg):

   467

        self.LogMessage(0, msg)

   468

        self.PLCStatus = PlcStatus.Broken

   469

        self.StatusChange()

   470

   471

    def PreStartPLC(self):

   472

        """ 

   473

        Here goes actions to be taken just before PLC starts, 

   474

        with all libraries and python object already created.

   475

        For example : restore saved proprietary parameters

   476

        """

   477

        pass

   478

   479

    @RunInMain