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, Semaphore, Event

    27

import ctypes

    28

import os

    29

import sys

    30

import traceback

    31

from time import time

    32

import _ctypes  # pylint: disable=wrong-import-order

    33

from past.builtins import execfile

    34

import Pyro.core as pyro

    35

import six

    36

from six.moves import _thread, xrange

    37

import md5

    38

from tempfile import mkstemp

    39

import shutil

    40

from functools import wraps

    41

    42

from runtime.typemapping import TypeTranslator

    43

from runtime.loglevels import LogLevelsDefault, LogLevelsCount

    44

from runtime.Stunnel import getPSKID

    45

from runtime import PlcStatus

    46

from runtime import MainWorker

    47

    48

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

    49

    dlopen = _ctypes.LoadLibrary

    50

    dlclose = _ctypes.FreeLibrary

    51

elif os.name == "posix":

    52

    dlopen = _ctypes.dlopen

    53

    dlclose = _ctypes.dlclose

    54

    55

    56

def get_last_traceback(tb):

    57

    while tb.tb_next:

    58

        tb = tb.tb_next

    59

    return tb

    60

    61

    62

lib_ext = {

    63

    "linux2": ".so",

    64

    "win32":  ".dll",

    65

}.get(sys.platform, "")

    66

    67

    68

def PLCprint(message):

    69

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

    70

    sys.stdout.flush()

    71

    72

    73

def RunInMain(func):

    74

    @wraps(func)

    75

    def func_wrapper(*args, **kwargs):

    76

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

    77

    return func_wrapper

    78

    79

    80

class PLCObject(object):

    81

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

    82

        self.workingdir = WorkingDir # must exits already

    83

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

    84

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

    85

            shutil.rmtree(self.tmpdir)

    86

        os.mkdir(self.tmpdir)

    87

        # FIXME : is argv of any use nowadays ?

    88

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

    89

        self.statuschange = statuschange

    90

        self.evaluator = evaluator

    91

        self.pyruntimevars = pyruntimevars

    92

        self.PLCStatus = PlcStatus.Empty

    93

        self.PLClibraryHandle = None

    94

        self.PLClibraryLock = Lock()

    95

        # Creates fake C funcs proxies

    96

        self._InitPLCStubCalls()

    97

        self._loading_error = None

    98

        self.python_runtime_vars = None

    99

        self.TraceThread = None

   100

        self.TraceLock = Lock()

   101

        self.Traces = []

   102

        self.DebugToken = 0

   103

   104

        self._init_blobs()

   105

   106

    # First task of worker -> no @RunInMain

   107

    def AutoLoad(self, autostart):

   108

        # Get the last transfered PLC

   109

        try:

   110

            self.CurrentPLCFilename = open(

   111

                self._GetMD5FileName(),

   112

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

   113

            if self.LoadPLC():

   114

                self.PLCStatus = PlcStatus.Stopped

   115

                if autostart:

   116

                    self.StartPLC()

   117

                    return

   118

        except Exception:

   119

            self.PLCStatus = PlcStatus.Empty

   120

            self.CurrentPLCFilename = None

   121

   122

        self.StatusChange()

   123

   124

    def StatusChange(self):

   125

        if self.statuschange is not None:

   126

            for callee in self.statuschange:

   127

                callee(self.PLCStatus)

   128

   129

    @RunInMain

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

   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

            self.PythonRuntimeInit()

   275

        else:

   276

            self._FreePLC()

   277

   278

        return res

   279

   280

    @RunInMain

   281

    def UnLoadPLC(self):

   282

        self.PythonRuntimeCleanup()

   283

        self._FreePLC()

   284

   285

    def _InitPLCStubCalls(self):

   286

        """

   287

        create dummy C func proxies

   288

        """

   289

        self._startPLC = lambda x, y: None

   290

        self._stopPLC = lambda: None

   291

        self._ResetDebugVariables = lambda: None

   292

        self._RegisterDebugVariable = lambda x, y: None

   293

        self._IterDebugData = lambda x, y: None

   294

        self._FreeDebugData = lambda: None

   295

        self._GetDebugData = lambda: -1

   296

        self._suspendDebug = lambda x: -1

   297

        self._resumeDebug = lambda: None

   298

        self._PythonIterator = lambda: ""

   299

        self._GetLogCount = None

   300

        self._LogMessage = None

   301

        self._GetLogMessage = None

   302

        self._PLClibraryHandle = None

   303

        self.PLClibraryHandle = None

   304

   305

    def _FreePLC(self):

   306

        """

   307

        Unload PLC library.

   308

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

   309

        """

   310

        self.PLClibraryLock.acquire()

   311

        try:

   312

            # Unload library explicitely

   313

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

   314

                dlclose(self._PLClibraryHandle)

   315

   316

            # Forget all refs to library

   317

            self._InitPLCStubCalls()

   318

   319

        finally:

   320

            self.PLClibraryLock.release()

   321

   322

        return False

   323

   324

    def PythonRuntimeCall(self, methodname):

   325

        """

   326

        Calls init, start, stop or cleanup method provided by

   327

        runtime python files, loaded when new PLC uploaded

   328

        """

   329

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

   330

            _res, exp = self.evaluator(method)

   331

            if exp is not None:

   332

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

   333

   334

    # used internaly

   335

    def PythonRuntimeInit(self):

   336

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

   337

        self.python_runtime_vars = globals().copy()

   338

        self.python_runtime_vars.update(self.pyruntimevars)

   339

        parent = self

   340

   341

        class PLCSafeGlobals(object):

   342

            def __getattr__(self, name):

   343

                try:

   344

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

   345

                except KeyError:

   346

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

   347

                v = t()

   348

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

   349

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

   350

   351

            def __setattr__(self, name, value):

   352

                try:

   353

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

   354

                except KeyError:

   355

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

   356

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

   357

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

   358

   359

        self.python_runtime_vars.update({

   360

            "PLCGlobals":     PLCSafeGlobals(),

   361

            "WorkingDir":     self.workingdir,

   362

            "PLCObject":      self,

   363

            "PLCBinary":      self.PLClibraryHandle,

   364

            "PLCGlobalsDesc": []})

   365

   366

        for methodname in MethodNames:

   367

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

   368

   369

        try:

   370

            filenames = os.listdir(self.workingdir)

   371

            filenames.sort()

   372

            for filename in filenames:

   373

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

   374

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

   375

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

   376

                    for methodname in MethodNames:

   377

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

   378

                        if method is not None:

   379

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

   380

        except Exception:

   381

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

   382

            raise

   383

   384

        self.PythonRuntimeCall("init")

   385

   386

    # used internaly

   387

    def PythonRuntimeCleanup(self):

   388

        if self.python_runtime_vars is not None:

   389

            self.PythonRuntimeCall("cleanup")

   390

   391

        self.python_runtime_vars = None

   392

   393

    def PythonThreadProc(self):

   394

        self.StartSem.release()

   395

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

   396

        compile_cache = {}

   397

        while True:

   398

            cmd = self._PythonIterator(res, blkid)

   399

            FBID = blkid.value

   400

            if cmd is None:

   401

                break

   402

            try:

   403

                self.python_runtime_vars["FBID"] = FBID

   404

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

   405

                if ccmd is None or ccmd != cmd:

   406

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

   407

                    compile_cache[FBID] = (cmd, AST)

   408

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

   409

                if exp is not None:

   410

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

   411

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

   412

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

   413

                else:

   414

                    res = str(result)

   415

                self.python_runtime_vars["FBID"] = None

   416

            except Exception as e:

   417

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

   418

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

   419

   420

    @RunInMain

   421

    def StartPLC(self):

   422

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

   423

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

   424

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

   425

            if res == 0:

   426

                self.PLCStatus = PlcStatus.Started

   427

                self.StatusChange()

   428

                self.PythonRuntimeCall("start")

   429

                self.StartSem = Semaphore(0)

   430

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

   431

                self.PythonThread.start()

   432

                self.StartSem.acquire()

   433

                self.LogMessage("PLC started")

   434

            else:

   435

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

   436

                self.PLCStatus = PlcStatus.Broken

   437

                self.StatusChange()

   438

   439

    @RunInMain

   440

    def StopPLC(self):

   441

        if self.PLCStatus == PlcStatus.Started:

   442

            self.LogMessage("PLC stopped")

   443

            self._stopPLC()

   444

            self.PythonThread.join()

   445

            self.PLCStatus = PlcStatus.Stopped

   446

            self.StatusChange()

   447

            self.PythonRuntimeCall("stop")

   448

            if self.TraceThread is not None:

   449

                self.TraceThread.join()

   450

                self.TraceThread = None

   451

            return True

   452

        return False

   453

   454

    @RunInMain

   455

    def GetPLCstatus(self):

   456

        return self.PLCStatus, map(self.GetLogCount, xrange(LogLevelsCount))

   457

   458

    @RunInMain

   459

    def GetPLCID(self):

   460

        return getPSKID()

   461

   462

    def _init_blobs(self):

   463

        self.blobs = {}

   464

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

   465

            shutil.rmtree(self.tmpdir)

   466

        os.mkdir(self.tmpdir)

   467

   468

    @RunInMain

   469

    def SeedBlob(self, seed):

   470

        blob = (mkstemp(dir=self.tmpdir) + (md5.new(),))

   471

        fobj, path, md5sum = blob

   472

        md5sum.update(seed)

   473

        newBlobID = md5sum.digest()

   474

        self.blobs[newBlobID] = blob

   475

        return newBlobID

   476

   477

    @RunInMain

   478

    def AppendChunkToBlob(self, data, blobID):