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

        self.python_runtime_vars.update({

   364

            "PLCGlobals":     PLCSafeGlobals(),

   365

            "WorkingDir":     self.workingdir,

   366

            "PLCObject":      self,

   367

            "PLCBinary":      self.PLClibraryHandle,

   368

            "PLCGlobalsDesc": []})

   369

   370

        for methodname in MethodNames:

   371

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

   372

   373

        try:

   374

            filenames = os.listdir(self.workingdir)

   375

            filenames.sort()

   376

            for filename in filenames:

   377

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

   378

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

   379

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

   380

                    for methodname in MethodNames:

   381

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

   382

                        if method is not None:

   383

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

   384

        except Exception:

   385

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

   386

            raise

   387

   388

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

   389

   390

        self.PythonThreadCondLock = Lock()

   391

        self.PythonThreadCond = Condition(self.PythonThreadCondLock)

   392

        self.PythonThreadCmd = "Wait"

   393

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

   394

        self.PythonThread.start()

   395

   396

    # used internaly

   397

    def PythonRuntimeCleanup(self):

   398

        if self.python_runtime_vars is not None:

   399

            self.PythonThreadCommand("Finish")

   400

            self.PythonThread.join()

   401

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

   402

   403

        self.python_runtime_vars = None

   404

   405

    def PythonThreadLoop(self):

   406

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

   407

        compile_cache = {}

   408

        while True:

   409

            cmd = self._PythonIterator(res, blkid)

   410

            FBID = blkid.value

   411

            if cmd is None:

   412

                break

   413

            try:

   414

                self.python_runtime_vars["FBID"] = FBID

   415

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

   416

                if ccmd is None or ccmd != cmd:

   417

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

   418

                    compile_cache[FBID] = (cmd, AST)

   419

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

   420

                if exp is not None:

   421

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

   422

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

   423

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

   424

                else:

   425

                    res = str(result)

   426

                self.python_runtime_vars["FBID"] = None

   427

            except Exception as e:

   428

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

   429

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

   430

   431

    def PythonThreadProc(self):

   432

        while True:

   433

            self.PythonThreadCondLock.acquire()

   434

            cmd = self.PythonThreadCmd

   435

            while cmd == "Wait":

   436

                self.PythonThreadCond.wait()

   437

                cmd = self.PythonThreadCmd

   438

                self.PythonThreadCmd = "Wait"

   439

            self.PythonThreadCondLock.release()

   440

   441

            if cmd == "Activate":

   442

                self.PythonRuntimeCall("start")

   443

                self.PythonThreadLoop()

   444

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

   445

            else:  # "Finish"

   446

                break

   447

   448

    def PythonThreadCommand(self, cmd):

   449

        self.PythonThreadCondLock.acquire()

   450

        self.PythonThreadCmd = cmd

   451

        self.PythonThreadCond.notify()

   452

        self.PythonThreadCondLock.release()

   453

   454

    @RunInMain

   455

    def StartPLC(self):

   456

   457

        def fail(msg):

   458

            self.LogMessage(0, msg)

   459

            self.PLCStatus = PlcStatus.Broken

   460

            self.StatusChange()

   461

   462

        if self.PLClibraryHandle is None:

   463

            if not self.LoadPLC():

   464

                fail(_("Problem starting PLC : can't load PLC"))

   465

   466

        if self.CurrentPLCFilename is not None and self.PLCStatus == PlcStatus.Stopped:

   467

            c_argv = ctypes.c_char_p * len(self.argv)

   468

            res = self._startPLC(len(self.argv), c_argv(*self.argv))

   469

            if res == 0:

   470

                self.PLCStatus = PlcStatus.Started

   471

                self.StatusChange()

   472

                self.PythonThreadCommand("Activate")

   473

                self.LogMessage("PLC started")

   474

            else:

   475

                fail(_("Problem starting PLC : error %d" % res))

   476

   477

    @RunInMain

   478

    def StopPLC(self):