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

            if self.LoadPLC():

   113

                self.PLCStatus = PlcStatus.Stopped

   114

                if autostart:

   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

    @RunInMain

   129

    def LogMessage(self, *args):

   130

        if len(args) == 2:

   131

            level, msg = args

   132

        else:

   133

            level = LogLevelsDefault

   134

            msg, = args

   135

        PLCprint(msg)

   136

        if self._LogMessage is not None:

   137

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

   138

        return None

   139

   140

    @RunInMain

   141

    def ResetLogCount(self):

   142

        if self._ResetLogCount is not None:

   143

            self._ResetLogCount()

   144

   145

    # used internaly

   146

    def GetLogCount(self, level):

   147

        if self._GetLogCount is not None:

   148

            return int(self._GetLogCount(level))

   149

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

   150

            return 1

   151

   152

    @RunInMain

   153

    def GetLogMessage(self, level, msgid):

   154

        tick = ctypes.c_uint32()

   155

        tv_sec = ctypes.c_uint32()

   156

        tv_nsec = ctypes.c_uint32()

   157

        if self._GetLogMessage is not None:

   158

            maxsz = len(self._log_read_buffer)-1

   159

            sz = self._GetLogMessage(level, msgid,

   160

                                     self._log_read_buffer, maxsz,

   161

                                     ctypes.byref(tick),

   162

                                     ctypes.byref(tv_sec),

   163

                                     ctypes.byref(tv_nsec))

   164

            if sz and sz <= maxsz:

   165

                self._log_read_buffer[sz] = '\x00'

   166

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

   167

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

   168

            return self._loading_error, 0, 0, 0

   169

        return None

   170

   171

    def _GetMD5FileName(self):

   172

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

   173

   174

    def _GetLibFileName(self):

   175

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

   176

   177

    def _LoadPLC(self):

   178

        """

   179

        Load PLC library

   180

        Declare all functions, arguments and return values

   181

        """

   182

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

   183

        self.PLClibraryLock.acquire()

   184

        try:

   185

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

   186

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

   187

   188

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

   189

            if len(md5) == 32:

   190

                self.PLC_ID.value = md5

   191

   192

            self._startPLC = self.PLClibraryHandle.startPLC

   193

            self._startPLC.restype = ctypes.c_int

   194

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

   195

   196

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   197

            self._stopPLC_real.restype = None

   198

   199

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

   200

            if self._PythonIterator is not None:

   201

                self._PythonIterator.restype = ctypes.c_char_p

   202

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

   203

   204

                self._stopPLC = self._stopPLC_real

   205

            else:

   206

                # If python confnode is not enabled, we reuse _PythonIterator

   207

                # as a call that block pythonthread until StopPLC

   208

                self.PlcStopping = Event()

   209

   210

                def PythonIterator(res, blkid):

   211

                    self.PlcStopping.clear()

   212

                    self.PlcStopping.wait()

   213

                    return None

   214

                self._PythonIterator = PythonIterator

   215

   216

                def __StopPLC():

   217

                    self._stopPLC_real()

   218

                    self.PlcStopping.set()

   219

                self._stopPLC = __StopPLC

   220

   221

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   222

            self._ResetDebugVariables.restype = None

   223

   224

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   225

            self._RegisterDebugVariable.restype = None

   226

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

   227

   228

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   229

            self._FreeDebugData.restype = None

   230

   231

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   232

            self._GetDebugData.restype = ctypes.c_int

   233

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

   234

   235

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   236

            self._suspendDebug.restype = ctypes.c_int

   237

            self._suspendDebug.argtypes = [ctypes.c_int]

   238

   239

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   240

            self._resumeDebug.restype = None

   241

   242

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   243

            self._ResetLogCount.restype = None

   244

   245

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   246

            self._GetLogCount.restype = ctypes.c_uint32

   247

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   248

   249

            self._LogMessage = self.PLClibraryHandle.LogMessage

   250

            self._LogMessage.restype = ctypes.c_int

   251

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

   252

   253

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

   254

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   255

            self._GetLogMessage.restype = ctypes.c_uint32

   256

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

   257

   258

            self._loading_error = None

   259

   260

        except Exception:

   261

            self._loading_error = traceback.format_exc()

   262

            PLCprint(self._loading_error)

   263

            return False

   264

        finally:

   265

            self.PLClibraryLock.release()

   266

   267

        return True

   268

   269

    @RunInMain

   270

    def LoadPLC(self):

   271

        res = self._LoadPLC()

   272

        if res:

   273

            self.PythonRuntimeInit()

   274

        else:

   275

            self._FreePLC()

   276

   277

        return res

   278

   279

    @RunInMain

   280

    def UnLoadPLC(self):

   281

        self.PythonRuntimeCleanup()

   282

        self._FreePLC()

   283

   284

    def _InitPLCStubCalls(self):

   285

        """

   286

        create dummy C func proxies

   287

        """

   288

        self._startPLC = lambda x, y: None

   289

        self._stopPLC = lambda: None

   290

        self._ResetDebugVariables = lambda: None

   291

        self._RegisterDebugVariable = lambda x, y: None

   292

        self._IterDebugData = lambda x, y: None

   293

        self._FreeDebugData = lambda: None

   294

        self._GetDebugData = lambda: -1

   295

        self._suspendDebug = lambda x: -1

   296

        self._resumeDebug = lambda: None

   297

        self._PythonIterator = lambda: ""

   298

        self._GetLogCount = None

   299

        self._LogMessage = None

   300

        self._GetLogMessage = None

   301

        self._PLClibraryHandle = None

   302

        self.PLClibraryHandle = None

   303

   304

    def _FreePLC(self):

   305

        """

   306

        Unload PLC library.

   307

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

   308

        """

   309

        self.PLClibraryLock.acquire()

   310

        try:

   311

            # Unload library explicitely

   312

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

   313

                dlclose(self._PLClibraryHandle)

   314

   315

            # Forget all refs to library

   316

            self._InitPLCStubCalls()

   317

   318

        finally:

   319

            self.PLClibraryLock.release()

   320

   321

        return False

   322

   323

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

   324

        """

   325

        Calls init, start, stop or cleanup method provided by

   326

        runtime python files, loaded when new PLC uploaded

   327

        """

   328

        for method in self.python_runtime_vars.get("_runtime_%s" % methodname, []):

   329

            if use_evaluator:

   330

                _res, exp = self.evaluator(method)

   331

            else:

   332

                _res, exp = default_evaluator(method)

   333

            if exp is not None:

   334

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

   335

   336

    # used internaly

   337

    def PythonRuntimeInit(self):

   338

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

   339

        self.python_runtime_vars = globals().copy()

   340

        self.python_runtime_vars.update(self.pyruntimevars)

   341

        parent = self

   342

   343

        class PLCSafeGlobals(object):

   344

            def __getattr__(self, name):

   345

                try:

   346

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

   347

                except KeyError:

   348

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

   349

                v = t()

   350

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

   351

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

   352

   353

            def __setattr__(self, name, value):

   354

                try:

   355

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

   356

                except KeyError:

   357

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

   358

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

   359

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

   360

   361

        self.python_runtime_vars.update({

   362

            "PLCGlobals":     PLCSafeGlobals(),

   363

            "WorkingDir":     self.workingdir,

   364

            "PLCObject":      self,

   365

            "PLCBinary":      self.PLClibraryHandle,

   366

            "PLCGlobalsDesc": []})

   367

   368

        for methodname in MethodNames:

   369

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

   370

   371

        try:

   372

            filenames = os.listdir(self.workingdir)

   373

            filenames.sort()

   374

            for filename in filenames:

   375

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

   376

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

   377

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

   378

                    for methodname in MethodNames:

   379

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

   380

                        if method is not None:

   381

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

   382

        except Exception:

   383

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

   384

            raise

   385

   386

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

   387

   388

        self.PythonThreadCondLock = Lock()

   389

        self.PythonThreadCond = Condition(self.PythonThreadCondLock)

   390

        self.PythonThreadCmd = "Wait"

   391

        self.PythonThread = Thread(target=self.PythonThreadProc)

   392

        self.PythonThread.start()

   393

   394

    # used internaly

   395

    def PythonRuntimeCleanup(self):

   396

        if self.python_runtime_vars is not None:

   397

            self.PythonThreadCommand("Finish")

   398

            self.PythonThread.join()

   399

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

   400

   401

        self.python_runtime_vars = None

   402

   403

    def PythonThreadLoop(self):

   404

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

   405

        compile_cache = {}

   406

        while True:

   407

            cmd = self._PythonIterator(res, blkid)

   408

            FBID = blkid.value

   409

            if cmd is None:

   410

                break

   411

            try:

   412

                self.python_runtime_vars["FBID"] = FBID

   413

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

   414

                if ccmd is None or ccmd != cmd:

   415

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

   416

                    compile_cache[FBID] = (cmd, AST)

   417

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

   418

                if exp is not None:

   419

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

   420

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

   421

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

   422

                else:

   423

                    res = str(result)

   424

                self.python_runtime_vars["FBID"] = None

   425

            except Exception as e:

   426

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

   427

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

   428

   429

    def PythonThreadProc(self):

   430

        while True:

   431

            self.PythonThreadCondLock.acquire()

   432

            cmd = self.PythonThreadCmd

   433

            while cmd == "Wait":

   434

                self.PythonThreadCond.wait()

   435

                cmd = self.PythonThreadCmd

   436

                self.PythonThreadCmd = "Wait"

   437

            self.PythonThreadCondLock.release()

   438

   439

            if cmd == "Activate":

   440

                self.PythonRuntimeCall("start")

   441

                self.PythonThreadLoop()

   442

                self.PythonRuntimeCall("stop")

   443

            else:  # "Finish"

   444

                break

   445

   446

    def PythonThreadCommand(self, cmd):

   447

        self.PythonThreadCondLock.acquire()

   448

        self.PythonThreadCmd = cmd

   449

        self.PythonThreadCond.notify()

   450

        self.PythonThreadCondLock.release()

   451

   452

    @RunInMain

   453

    def StartPLC(self):

   454

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

   455

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

   456

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

   457

            if res == 0:

   458

                self.PLCStatus = PlcStatus.Started

   459

                self.StatusChange()

   460

                self.PythonThreadCommand("Activate")

   461

                self.LogMessage("PLC started")

   462

            else:

   463

                self.LogMessage(0, _("Problem starting PLC : error %d" % res))

   464

                self.PLCStatus = PlcStatus.Broken

   465

                self.StatusChange()

   466

   467

    @RunInMain

   468

    def StopPLC(self):

   469

        if self.PLCStatus == PlcStatus.Started:

   470

            self.LogMessage("PLC stopped")

   471

            self._stopPLC()

   472

            self.PLCStatus = PlcStatus.Stopped

   473

            self.StatusChange()

   474

            if self.TraceThread is not None:

   475

                self.TraceThread.join()

   476

                self.TraceThread = None

   477

            return True

   478

        return False