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

import thread

    27

from threading import Thread, Lock, Semaphore, Event, Condition

    28

import ctypes

    29

import os

    30

import sys

    31

import traceback

    32

from time import time

    33

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

    34

import Pyro.core as pyro

    35

    36

from runtime.typemapping import TypeTranslator

    37

from runtime.loglevels import LogLevelsDefault, LogLevelsCount

    38

    39

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

    40

    dlopen = _ctypes.LoadLibrary

    41

    dlclose = _ctypes.FreeLibrary

    42

elif os.name == "posix":

    43

    dlopen = _ctypes.dlopen

    44

    dlclose = _ctypes.dlclose

    45

    46

    47

def get_last_traceback(tb):

    48

    while tb.tb_next:

    49

        tb = tb.tb_next

    50

    return tb

    51

    52

    53

lib_ext = {

    54

    "linux2": ".so",

    55

    "win32":  ".dll",

    56

}.get(sys.platform, "")

    57

    58

    59

def PLCprint(message):

    60

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

    61

    sys.stdout.flush()

    62

    63

    64

class job(object):

    65

    """

    66

    job to be executed by a worker

    67

    """

    68

    def __init__(self, call, *args, **kwargs):

    69

        self.job = (call, args, kwargs)

    70

        self.result = None

    71

        self.success = False

    72

        self.exc_info = None

    73

    74

    def do(self):

    75

        """

    76

        do the job by executing the call, and deal with exceptions

    77

        """

    78

        try:

    79

            call, args, kwargs = self.job

    80

            self.result = call(*args, **kwargs)

    81

            self.success = True

    82

        except Exception:

    83

            self.success = False

    84

            self.exc_info = sys.exc_info()

    85

    86

    87

class worker(object):

    88

    """

    89

    serialize main thread load/unload of PLC shared objects

    90

    """

    91

    def __init__(self):

    92

        # Only one job at a time

    93

        self._finish = False

    94

        self._threadID = None

    95

        self.mutex = Lock()

    96

        self.todo = Condition(self.mutex)

    97

        self.done = Condition(self.mutex)

    98

        self.free = Condition(self.mutex)

    99

        self.job = None

   100

   101

    def runloop(self, *args, **kwargs):

   102

        """

   103

        meant to be called by worker thread (blocking)

   104

        """

   105

        self._threadID = thread.get_ident()

   106

        if args or kwargs:

   107

            job(*args, **kwargs).do()

   108

            # result is ignored

   109

        self.mutex.acquire()

   110

        while not self._finish:

   111

            self.todo.wait()

   112

            if self.job is not None:

   113

                self.job.do()

   114

                self.done.notify()

   115

            else:

   116

                self.free.notify()

   117

        self.mutex.release()

   118

   119

    def call(self, *args, **kwargs):

   120

        """

   121

        creates a job, execute it in worker thread, and deliver result.

   122

        if job execution raise exception, re-raise same exception

   123

        meant to be called by non-worker threads, but this is accepted.

   124

        blocking until job done

   125

        """

   126

   127

        _job = job(*args, **kwargs)

   128

   129

        if self._threadID == thread.get_ident() or self._threadID is None:

   130

            # if caller is worker thread execute immediately

   131

            _job.do()

   132

        else:

   133

            # otherwise notify and wait for completion

   134

            self.mutex.acquire()

   135

   136

            while self.job is not None:

   137

                self.free.wait()

   138

   139

            self.job = _job

   140

            self.todo.notify()

   141

            self.done.wait()

   142

            _job = self.job

   143

            self.job = None

   144

            self.mutex.release()

   145

   146

        if _job.success:

   147

            return _job.result

   148

        else:

   149

            raise _job.exc_info[0], _job.exc_info[1], _job.exc_info[2]

   150

   151

    def quit(self):

   152

        """

   153

        unblocks main thread, and terminate execution of runloop()

   154

        """

   155

        # mark queue

   156

        self._finish = True

   157

        self.mutex.acquire()

   158

        self.job = None

   159

        self.todo.notify()

   160

        self.mutex.release()

   161

   162

   163

MainWorker = worker()

   164

   165

   166

def RunInMain(func):

   167

    def func_wrapper(*args, **kwargs):

   168

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

   169

    return func_wrapper

   170

   171

   172

class PLCObject(pyro.ObjBase):

   173

    def __init__(self, server):

   174

        pyro.ObjBase.__init__(self)

   175

        self.evaluator = server.evaluator

   176

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

   177

        self.workingdir = server.workdir

   178

        self.PLCStatus = "Empty"

   179

        self.PLClibraryHandle = None

   180

        self.PLClibraryLock = Lock()

   181

        self.DummyIteratorLock = None

   182

        # Creates fake C funcs proxies

   183

        self._InitPLCStubCalls()

   184

        self.daemon = server.daemon

   185

        self.statuschange = server.statuschange

   186

        self.hmi_frame = None

   187

        self.pyruntimevars = server.pyruntimevars

   188

        self._loading_error = None

   189

        self.python_runtime_vars = None

   190

        self.TraceThread = None

   191

        self.TraceLock = Lock()

   192

        self.Traces = []

   193

   194

    # First task of worker -> no @RunInMain

   195

    def AutoLoad(self):

   196

        # Get the last transfered PLC

   197

        try:

   198

            self.CurrentPLCFilename = open(

   199

                self._GetMD5FileName(),

   200

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

   201

            if self.LoadPLC():

   202

                self.PLCStatus = "Stopped"

   203

        except Exception:

   204

            self.PLCStatus = "Empty"

   205

            self.CurrentPLCFilename = None

   206

   207

    def StatusChange(self):

   208

        if self.statuschange is not None:

   209

            for callee in self.statuschange:

   210

                callee(self.PLCStatus)

   211

   212

    @RunInMain

   213

    def LogMessage(self, *args):

   214

        if len(args) == 2:

   215

            level, msg = args

   216

        else:

   217

            level = LogLevelsDefault

   218

            msg, = args

   219

        PLCprint(msg)

   220

        if self._LogMessage is not None:

   221

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

   222

        return None

   223

   224

    @RunInMain

   225

    def ResetLogCount(self):

   226

        if self._ResetLogCount is not None:

   227

            self._ResetLogCount()

   228

   229

    # used internaly

   230

    def GetLogCount(self, level):

   231

        if self._GetLogCount is not None:

   232

            return int(self._GetLogCount(level))

   233

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

   234

            return 1

   235

   236

    @RunInMain

   237

    def GetLogMessage(self, level, msgid):

   238

        tick = ctypes.c_uint32()

   239

        tv_sec = ctypes.c_uint32()

   240

        tv_nsec = ctypes.c_uint32()

   241

        if self._GetLogMessage is not None:

   242

            maxsz = len(self._log_read_buffer)-1

   243

            sz = self._GetLogMessage(level, msgid,

   244

                                     self._log_read_buffer, maxsz,

   245

                                     ctypes.byref(tick),

   246

                                     ctypes.byref(tv_sec),

   247

                                     ctypes.byref(tv_nsec))

   248

            if sz and sz <= maxsz:

   249

                self._log_read_buffer[sz] = '\x00'

   250

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

   251

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

   252

            return self._loading_error, 0, 0, 0

   253

        return None

   254

   255

    def _GetMD5FileName(self):

   256

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

   257

   258

    def _GetLibFileName(self):

   259

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

   260

   261

    def _LoadPLC(self):

   262

        """

   263

        Load PLC library

   264

        Declare all functions, arguments and return values

   265

        """

   266

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

   267

        self.PLClibraryLock.acquire()

   268

        try:

   269

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

   270

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

   271

   272

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

   273

            if len(md5) == 32:

   274

                self.PLC_ID.value = md5

   275

   276

            self._startPLC = self.PLClibraryHandle.startPLC

   277

            self._startPLC.restype = ctypes.c_int

   278

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

   279

   280

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   281

            self._stopPLC_real.restype = None

   282

   283

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

   284

            if self._PythonIterator is not None:

   285

                self._PythonIterator.restype = ctypes.c_char_p

   286

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

   287

   288

                self._stopPLC = self._stopPLC_real

   289

            else:

   290

                # If python confnode is not enabled, we reuse _PythonIterator

   291

                # as a call that block pythonthread until StopPLC

   292

                self.PlcStopping = Event()

   293

   294

                def PythonIterator(res, blkid):

   295

                    self.PlcStopping.clear()

   296

                    self.PlcStopping.wait()

   297

                    return None

   298

                self._PythonIterator = PythonIterator

   299

   300

                def __StopPLC():

   301

                    self._stopPLC_real()

   302

                    self.PlcStopping.set()

   303

                self._stopPLC = __StopPLC

   304

   305

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   306

            self._ResetDebugVariables.restype = None

   307

   308

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   309

            self._RegisterDebugVariable.restype = None

   310

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

   311

   312

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   313

            self._FreeDebugData.restype = None

   314

   315

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   316

            self._GetDebugData.restype = ctypes.c_int

   317

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

   318

   319

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   320

            self._suspendDebug.restype = ctypes.c_int

   321

            self._suspendDebug.argtypes = [ctypes.c_int]

   322

   323

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   324

            self._resumeDebug.restype = None

   325

   326

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   327

            self._ResetLogCount.restype = None

   328

   329

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   330

            self._GetLogCount.restype = ctypes.c_uint32

   331

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   332

   333

            self._LogMessage = self.PLClibraryHandle.LogMessage

   334

            self._LogMessage.restype = ctypes.c_int

   335

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

   336

   337

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

   338

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   339

            self._GetLogMessage.restype = ctypes.c_uint32

   340

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

   341

   342

            self._loading_error = None

   343

   344

        except Exception:

   345

            self._loading_error = traceback.format_exc()

   346

            PLCprint(self._loading_error)

   347

            return False

   348

        finally:

   349

            self.PLClibraryLock.release()

   350

   351

        return True

   352

   353

    @RunInMain

   354

    def LoadPLC(self):

   355

        res = self._LoadPLC()

   356

        if res:

   357

            self.PythonRuntimeInit()

   358

        else:

   359

            self._FreePLC()

   360

   361

        return res

   362

   363

    @RunInMain

   364

    def UnLoadPLC(self):

   365

        self.PythonRuntimeCleanup()

   366

        self._FreePLC()

   367

   368

    def _InitPLCStubCalls(self):

   369

        """

   370

        create dummy C func proxies

   371

        """

   372

        self._startPLC = lambda x, y: None

   373

        self._stopPLC = lambda: None

   374

        self._ResetDebugVariables = lambda: None

   375

        self._RegisterDebugVariable = lambda x, y: None

   376

        self._IterDebugData = lambda x, y: None

   377

        self._FreeDebugData = lambda: None

   378

        self._GetDebugData = lambda: -1

   379

        self._suspendDebug = lambda x: -1

   380

        self._resumeDebug = lambda: None

   381

        self._PythonIterator = lambda: ""

   382

        self._GetLogCount = None

   383

        self._LogMessage = None

   384

        self._GetLogMessage = None

   385

        self._PLClibraryHandle = None

   386

        self.PLClibraryHandle = None

   387

   388

    def _FreePLC(self):

   389

        """

   390

        Unload PLC library.

   391

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

   392

        """

   393

        self.PLClibraryLock.acquire()

   394

        try:

   395

            # Unload library explicitely

   396

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

   397

                dlclose(self._PLClibraryHandle)

   398

   399

            # Forget all refs to library

   400

            self._InitPLCStubCalls()

   401

   402

        finally:

   403

            self.PLClibraryLock.release()

   404

   405

        return False

   406

   407

    def PythonRuntimeCall(self, methodname):

   408

        """

   409

        Calls init, start, stop or cleanup method provided by

   410

        runtime python files, loaded when new PLC uploaded

   411

        """

   412

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

   413

            _res, exp = self.evaluator(method)

   414

            if exp is not None:

   415

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

   416

   417

    # used internaly

   418

    def PythonRuntimeInit(self):

   419

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

   420

        self.python_runtime_vars = globals().copy()

   421

        self.python_runtime_vars.update(self.pyruntimevars)

   422

        parent = self

   423

   424

        class PLCSafeGlobals(object):

   425

            def __getattr__(self, name):

   426

                try:

   427

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

   428

                except KeyError:

   429

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

   430

                v = t()

   431

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

   432

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

   433

   434

            def __setattr__(self, name, value):

   435

                try:

   436

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

   437

                except KeyError:

   438

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

   439

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

   440

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

   441

   442

        self.python_runtime_vars.update({

   443

            "PLCGlobals":     PLCSafeGlobals(),

   444

            "WorkingDir":     self.workingdir,

   445

            "PLCObject":      self,

   446

            "PLCBinary":      self.PLClibraryHandle,

   447

            "PLCGlobalsDesc": []})

   448

   449

        for methodname in MethodNames:

   450

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

   451

   452

        try:

   453

            filenames = os.listdir(self.workingdir)

   454

            filenames.sort()

   455

            for filename in filenames:

   456

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

   457

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

   458

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

   459

                    for methodname in MethodNames:

   460

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

   461

                        if method is not None:

   462

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

   463

        except Exception:

   464

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

   465

            raise

   466

   467

        self.PythonRuntimeCall("init")

   468

   469

    # used internaly

   470

    def PythonRuntimeCleanup(self):

   471

        if self.python_runtime_vars is not None:

   472

            self.PythonRuntimeCall("cleanup")

   473

   474

        self.python_runtime_vars = None

   475

   476

    def PythonThreadProc(self):

   477

        self.StartSem.release()

   478

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

   479

        compile_cache = {}

   480

        while True: