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

    39

    40

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

    41

    dlopen = _ctypes.LoadLibrary

    42

    dlclose = _ctypes.FreeLibrary

    43

elif os.name == "posix":

    44

    dlopen = _ctypes.dlopen

    45

    dlclose = _ctypes.dlclose

    46

    47

    48

def get_last_traceback(tb):

    49

    while tb.tb_next:

    50

        tb = tb.tb_next

    51

    return tb

    52

    53

    54

lib_ext = {

    55

    "linux2": ".so",

    56

    "win32":  ".dll",

    57

}.get(sys.platform, "")

    58

    59

    60

def PLCprint(message):

    61

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

    62

    sys.stdout.flush()

    63

    64

    65

class job(object):

    66

    """

    67

    job to be executed by a worker

    68

    """

    69

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

    70

        self.job = (call, args, kwargs)

    71

        self.result = None

    72

        self.success = False

    73

        self.exc_info = None

    74

    75

    def do(self):

    76

        """

    77

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

    78

        """

    79

        try:

    80

            call, args, kwargs = self.job

    81

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

    82

            self.success = True

    83

        except Exception:

    84

            self.success = False

    85

            self.exc_info = sys.exc_info()

    86

    87

    88

class worker(object):

    89

    """

    90

    serialize main thread load/unload of PLC shared objects

    91

    """

    92

    def __init__(self):

    93

        # Only one job at a time

    94

        self._finish = False

    95

        self._threadID = None

    96

        self.mutex = Lock()

    97

        self.todo = Condition(self.mutex)

    98

        self.done = Condition(self.mutex)

    99

        self.free = Condition(self.mutex)

   100

        self.job = None

   101

   102

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

   103

        """

   104

        meant to be called by worker thread (blocking)

   105

        """

   106

        self._threadID = thread.get_ident()

   107

        if args or kwargs:

   108

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

   109

            # result is ignored

   110

        self.mutex.acquire()

   111

        while not self._finish:

   112

            self.todo.wait()

   113

            if self.job is not None:

   114

                self.job.do()

   115

                self.done.notify()

   116

            else:

   117

                self.free.notify()

   118

        self.mutex.release()

   119

   120

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

   121

        """

   122

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

   123

        if job execution raise exception, re-raise same exception

   124

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

   125

        blocking until job done

   126

        """

   127

   128

        _job = job(*args, **kwargs)

   129

   130

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

   131

            # if caller is worker thread execute immediately

   132

            _job.do()

   133

        else:

   134

            # otherwise notify and wait for completion

   135

            self.mutex.acquire()

   136

   137

            while self.job is not None:

   138

                self.free.wait()

   139

   140

            self.job = _job

   141

            self.todo.notify()

   142

            self.done.wait()

   143

            _job = self.job

   144

            self.job = None

   145

            self.mutex.release()

   146

   147

        if _job.success:

   148

            return _job.result

   149

        else:

   150

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

   151

   152

    def quit(self):

   153

        """

   154

        unblocks main thread, and terminate execution of runloop()

   155

        """

   156

        # mark queue

   157

        self._finish = True

   158

        self.mutex.acquire()

   159

        self.job = None

   160

        self.todo.notify()

   161

        self.mutex.release()

   162

   163

   164

MainWorker = worker()

   165

   166

   167

def RunInMain(func):

   168

    def func_wrapper(*args, **kwargs):

   169

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

   170

    return func_wrapper

   171

   172

   173

class PLCObject(pyro.ObjBase):

   174

    def __init__(self, server):

   175

        pyro.ObjBase.__init__(self)

   176

        self.evaluator = server.evaluator

   177

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

   178

        self.workingdir = server.workdir

   180

        self.PLClibraryHandle = None

   181

        self.PLClibraryLock = Lock()

   182

        self.DummyIteratorLock = None

   183

        # Creates fake C funcs proxies

   184

        self._InitPLCStubCalls()

   185

        self.daemon = server.daemon

   186

        self.statuschange = server.statuschange

   187

        self.hmi_frame = None

   188

        self.pyruntimevars = server.pyruntimevars

   189

        self._loading_error = None

   190

        self.python_runtime_vars = None

   191

        self.TraceThread = None

   192

        self.TraceLock = Lock()

   193

        self.Traces = []

   194

   195

    # First task of worker -> no @RunInMain

   196

    def AutoLoad(self):

   197

        # Get the last transfered PLC

   198

        try:

   199

            self.CurrentPLCFilename = open(

   200

                self._GetMD5FileName(),

   201

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

   202

            if self.LoadPLC():

   204

        except Exception:

   206

            self.CurrentPLCFilename = None

   207

   208

    def StatusChange(self):

   209

        if self.statuschange is not None:

   210

            for callee in self.statuschange:

   211

                callee(self.PLCStatus)

   212

   213

    @RunInMain

   214

    def LogMessage(self, *args):

   215

        if len(args) == 2:

   216

            level, msg = args

   217

        else:

   218

            level = LogLevelsDefault

   219

            msg, = args

   220

        PLCprint(msg)

   221

        if self._LogMessage is not None:

   222

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

   223

        return None

   224

   225

    @RunInMain

   226

    def ResetLogCount(self):

   227

        if self._ResetLogCount is not None:

   228

            self._ResetLogCount()

   229

   230

    # used internaly

   231

    def GetLogCount(self, level):

   232

        if self._GetLogCount is not None:

   233

            return int(self._GetLogCount(level))

   234

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

   235

            return 1

   236

   237

    @RunInMain

   238

    def GetLogMessage(self, level, msgid):

   239

        tick = ctypes.c_uint32()

   240

        tv_sec = ctypes.c_uint32()

   241

        tv_nsec = ctypes.c_uint32()

   242

        if self._GetLogMessage is not None:

   243

            maxsz = len(self._log_read_buffer)-1

   244

            sz = self._GetLogMessage(level, msgid,

   245

                                     self._log_read_buffer, maxsz,

   246

                                     ctypes.byref(tick),

   247

                                     ctypes.byref(tv_sec),

   248

                                     ctypes.byref(tv_nsec))

   249

            if sz and sz <= maxsz:

   250

                self._log_read_buffer[sz] = '\x00'

   251

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

   252

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

   253

            return self._loading_error, 0, 0, 0

   254

        return None

   255

   256

    def _GetMD5FileName(self):

   257

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

   258

   259

    def _GetLibFileName(self):

   260

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

   261

   262

    def _LoadPLC(self):

   263

        """

   264

        Load PLC library

   265

        Declare all functions, arguments and return values

   266

        """

   267

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

   268

        self.PLClibraryLock.acquire()

   269

        try:

   270

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

   271

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

   272

   273

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

   274

            if len(md5) == 32:

   275

                self.PLC_ID.value = md5

   276

   277

            self._startPLC = self.PLClibraryHandle.startPLC

   278

            self._startPLC.restype = ctypes.c_int

   279

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

   280

   281

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   282

            self._stopPLC_real.restype = None

   283

   284

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

   285

            if self._PythonIterator is not None:

   286

                self._PythonIterator.restype = ctypes.c_char_p

   287

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

   288

   289

                self._stopPLC = self._stopPLC_real

   290

            else:

   291

                # If python confnode is not enabled, we reuse _PythonIterator

   292

                # as a call that block pythonthread until StopPLC

   293

                self.PlcStopping = Event()

   294

   295

                def PythonIterator(res, blkid):

   296

                    self.PlcStopping.clear()

   297

                    self.PlcStopping.wait()

   298

                    return None

   299

                self._PythonIterator = PythonIterator

   300

   301

                def __StopPLC():

   302

                    self._stopPLC_real()

   303

                    self.PlcStopping.set()

   304

                self._stopPLC = __StopPLC

   305

   306

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   307

            self._ResetDebugVariables.restype = None

   308

   309

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   310

            self._RegisterDebugVariable.restype = None

   311

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

   312

   313

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   314

            self._FreeDebugData.restype = None

   315

   316

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   317

            self._GetDebugData.restype = ctypes.c_int

   318

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

   319

   320

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   321

            self._suspendDebug.restype = ctypes.c_int

   322

            self._suspendDebug.argtypes = [ctypes.c_int]

   323

   324

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   325

            self._resumeDebug.restype = None

   326

   327

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   328

            self._ResetLogCount.restype = None

   329

   330

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   331

            self._GetLogCount.restype = ctypes.c_uint32

   332

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   333

   334

            self._LogMessage = self.PLClibraryHandle.LogMessage

   335

            self._LogMessage.restype = ctypes.c_int

   336

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

   337

   338

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

   339

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   340

            self._GetLogMessage.restype = ctypes.c_uint32

   341

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

   342

   343

            self._loading_error = None

   344

   345

        except Exception:

   346

            self._loading_error = traceback.format_exc()

   347

            PLCprint(self._loading_error)

   348

            return False

   349

        finally:

   350

            self.PLClibraryLock.release()

   351

   352

        return True

   353

   354

    @RunInMain

   355

    def LoadPLC(self):

   356

        res = self._LoadPLC()

   357

        if res:

   358

            self.PythonRuntimeInit()

   359

        else:

   360

            self._FreePLC()

   361

   362

        return res

   363

   364

    @RunInMain

   365

    def UnLoadPLC(self):

   366

        self.PythonRuntimeCleanup()

   367

        self._FreePLC()

   368

   369

    def _InitPLCStubCalls(self):

   370

        """

   371

        create dummy C func proxies

   372

        """

   373

        self._startPLC = lambda x, y: None

   374

        self._stopPLC = lambda: None

   375

        self._ResetDebugVariables = lambda: None

   376

        self._RegisterDebugVariable = lambda x, y: None

   377

        self._IterDebugData = lambda x, y: None

   378

        self._FreeDebugData = lambda: None

   379

        self._GetDebugData = lambda: -1

   380

        self._suspendDebug = lambda x: -1

   381

        self._resumeDebug = lambda: None

   382

        self._PythonIterator = lambda: ""

   383

        self._GetLogCount = None

   384

        self._LogMessage = None

   385

        self._GetLogMessage = None

   386

        self._PLClibraryHandle = None

   387

        self.PLClibraryHandle = None

   388

   389

    def _FreePLC(self):

   390

        """

   391

        Unload PLC library.

   392

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

   393

        """

   394

        self.PLClibraryLock.acquire()

   395

        try:

   396

            # Unload library explicitely

   397

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

   398

                dlclose(self._PLClibraryHandle)

   399

   400

            # Forget all refs to library

   401

            self._InitPLCStubCalls()

   402

   403

        finally:

   404

            self.PLClibraryLock.release()

   405

   406

        return False

   407

   408

    def PythonRuntimeCall(self, methodname):

   409

        """

   410

        Calls init, start, stop or cleanup method provided by

   411

        runtime python files, loaded when new PLC uploaded

   412

        """

   413

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

   414

            _res, exp = self.evaluator(method)

   415

            if exp is not None:

   416

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

   417

   418

    # used internaly

   419

    def PythonRuntimeInit(self):

   420

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

   421

        self.python_runtime_vars = globals().copy()

   422

        self.python_runtime_vars.update(self.pyruntimevars)

   423

        parent = self

   424

   425

        class PLCSafeGlobals(object):

   426

            def __getattr__(self, name):

   427

                try:

   428

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

   429

                except KeyError:

   430

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

   431

                v = t()

   432

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

   433

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

   434

   435

            def __setattr__(self, name, value):

   436

                try:

   437

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

   438

                except KeyError:

   439

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

   440

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

   441

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

   442

   443

        self.python_runtime_vars.update({

   444

            "PLCGlobals":     PLCSafeGlobals(),

   445

            "WorkingDir":     self.workingdir,

   446

            "PLCObject":      self,

   447

            "PLCBinary":      self.PLClibraryHandle,

   448

            "PLCGlobalsDesc": []})

   449

   450

        for methodname in MethodNames:

   451

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

   452

   453

        try:

   454

            filenames = os.listdir(self.workingdir)

   455

            filenames.sort()

   456

            for filename in filenames:

   457

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

   458

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

   459

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

   460

                    for methodname in MethodNames:

   461

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

   462

                        if method is not None:

   463

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

   464

        except Exception:

   465

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

   466

            raise

   467

   468

        self.PythonRuntimeCall("init")

   469

   470

    # used internaly

   471

    def PythonRuntimeCleanup(self):

   472

        if self.python_runtime_vars is not None:

   473

            self.PythonRuntimeCall("cleanup")

   474

   475

        self.python_runtime_vars = None

   476

   477

    def PythonThreadProc(self):

   478

        self.StartSem.release()

   479

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

   480

        compile_cache = {}