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 Timer, 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.job = None

    99

   100

    def runloop(self):

   101

        """

   102

        meant to be called by worker thread (blocking)

   103

        """

   104

        self._threadID = thread.get_ident()

   105

        self.mutex.acquire()

   106

        while not self._finish:

   107

            self.todo.wait()

   108

            if self.job is not None:

   109

                self.job.do()

   110

            self.done.notify_all()

   111

        self.mutex.release()

   112

   113

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

   114

        """

   115

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

   116

        if job execution raise exception, re-raise same exception 

   117

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

   118

        blocking until job done

   119

        """

   120

   121

        _job = job(*args,**kwargs)

   122

   123

        if self._threadID == thread.get_ident():

   124

            # if caller is worker thread execute immediately

   125

            _job.do()

   126

        else:

   127

            # otherwise notify and wait for completion

   128

            self.mutex.acquire()

   129

   130

            while self.job is not None:

   131

                self.done.wait()

   132

   133

            self.job = _job

   134

            self.todo.notify()

   135

            self.done.wait()

   136

            _job = self.job

   137

            self.job = None

   138

            self.mutex.release()

   139

   140

        if _job.success:

   141

            return _job.result

   142

        else:

   143

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

   144

   145

    def quit(self):

   146

        """

   147

        unblocks main thread, and terminate execution of runloop()

   148

        """

   149

        # mark queue

   150

        self._finish = True

   151

        self.mutex.acquire()

   152

        self.job = None

   153

        self.todo.notify()

   154

        self.mutex.release()

   155

   156

   157

MainWorker = worker()

   158

   159

   160

def RunInMain(func):

   161

    def func_wrapper(*args,**kwargs):

   162

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

   163

    return func_wrapper

   164

   165

   166

class PLCObject(pyro.ObjBase):

   167

    def __init__(self, server):

   168

   169

        pyro.ObjBase.__init__(self)

   170

        self.evaluator = server.evaluator

   171

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

   172

        self.workingdir = server.workdir

   173

        self.PLCStatus = "Empty"

   174

        self.PLClibraryHandle = None

   175

        self.PLClibraryLock = Lock()

   176

        self.DummyIteratorLock = None

   177

        # Creates fake C funcs proxies

   178

        self._InitPLCStubCalls()

   179

        self.daemon = server.daemon

   180

        self.statuschange = server.statuschange

   181

        self.hmi_frame = None

   182

        self.pyruntimevars = server.pyruntimevars

   183

        self._loading_error = None

   184

        self.python_runtime_vars = None

   185

        self.TraceThread = None

   186

        self.TraceLock = Lock()

   187

        self.TraceWakeup = Event()

   188

        self.Traces = []

   189

        server.RegisterPLCObject(self)

   190

   191

    def AutoLoad(self):

   192

        # Get the last transfered PLC if connector must be restart

   193

        try:

   194

            self.CurrentPLCFilename = open(

   195

                self._GetMD5FileName(),

   196

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

   197

            if self.LoadPLC():

   198

                self.PLCStatus = "Stopped"

   199

        except Exception:

   200

            self.PLCStatus = "Empty"

   201

            self.CurrentPLCFilename = None

   202

   203

    def StatusChange(self):

   204

        if self.statuschange is not None:

   205

            for callee in self.statuschange:

   206

                callee(self.PLCStatus)

   207

   208

    def LogMessage(self, *args):

   209

        if len(args) == 2:

   210

            level, msg = args

   211

        else:

   212

            level = LogLevelsDefault

   213

            msg, = args

   214

        PLCprint(msg)

   215

        if self._LogMessage is not None:

   216

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

   217

        return None

   218

   219

    def ResetLogCount(self):

   220

        if self._ResetLogCount is not None:

   221

            self._ResetLogCount()

   222

   223

    def GetLogCount(self, level):

   224

        if self._GetLogCount is not None:

   225

            return int(self._GetLogCount(level))

   226

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

   227

            return 1

   228

   229

    def GetLogMessage(self, level, msgid):

   230

        tick = ctypes.c_uint32()

   231

        tv_sec = ctypes.c_uint32()

   232

        tv_nsec = ctypes.c_uint32()

   233

        if self._GetLogMessage is not None:

   234

            maxsz = len(self._log_read_buffer)-1

   235

            sz = self._GetLogMessage(level, msgid,

   236

                                     self._log_read_buffer, maxsz,

   237

                                     ctypes.byref(tick),

   238

                                     ctypes.byref(tv_sec),

   239

                                     ctypes.byref(tv_nsec))

   240

            if sz and sz <= maxsz:

   241

                self._log_read_buffer[sz] = '\x00'

   242

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

   243

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

   244

            return self._loading_error, 0, 0, 0

   245

        return None

   246

   247

    def _GetMD5FileName(self):

   248

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

   249

   250

    def _GetLibFileName(self):

   251

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

   252

   253

    @RunInMain

   254

    def LoadPLC(self):

   255

        """

   256

        Load PLC library

   257

        Declare all functions, arguments and return values

   258

        """

   259

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

   260

        try:

   261

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

   262

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

   263

   264

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

   265

            if len(md5) == 32:

   266

                self.PLC_ID.value = md5

   267

   268

            self._startPLC = self.PLClibraryHandle.startPLC

   269

            self._startPLC.restype = ctypes.c_int

   270

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

   271

   272

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   273

            self._stopPLC_real.restype = None

   274

   275

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

   276

            if self._PythonIterator is not None:

   277

                self._PythonIterator.restype = ctypes.c_char_p

   278

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

   279

   280

                self._stopPLC = self._stopPLC_real

   281

            else:

   282

                # If python confnode is not enabled, we reuse _PythonIterator

   283

                # as a call that block pythonthread until StopPLC

   284

                self.PlcStopping = Event()

   285

   286

                def PythonIterator(res, blkid):

   287

                    self.PlcStopping.clear()

   288

                    self.PlcStopping.wait()

   289

                    return None

   290

                self._PythonIterator = PythonIterator

   291

   292

                def __StopPLC():

   293

                    self._stopPLC_real()

   294

                    self.PlcStopping.set()

   295

                self._stopPLC = __StopPLC

   296

   297

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   298

            self._ResetDebugVariables.restype = None

   299

   300

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   301

            self._RegisterDebugVariable.restype = None

   302

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

   303

   304

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   305

            self._FreeDebugData.restype = None

   306

   307

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   308

            self._GetDebugData.restype = ctypes.c_int

   309

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

   310

   311

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   312

            self._suspendDebug.restype = ctypes.c_int

   313

            self._suspendDebug.argtypes = [ctypes.c_int]

   314

   315

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   316

            self._resumeDebug.restype = None

   317

   318

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   319

            self._ResetLogCount.restype = None

   320

   321

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   322

            self._GetLogCount.restype = ctypes.c_uint32

   323

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   324

   325

            self._LogMessage = self.PLClibraryHandle.LogMessage

   326

            self._LogMessage.restype = ctypes.c_int

   327

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

   328

   329

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

   330

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   331

            self._GetLogMessage.restype = ctypes.c_uint32

   332

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

   333

   334

            self._loading_error = None

   335

   336

            self.PythonRuntimeInit()

   337

   338

            return True

   339

        except Exception:

   340

            self._loading_error = traceback.format_exc()

   341

            PLCprint(self._loading_error)

   342

            self._FreePLC()

   343

            return False

   344

   345

    @RunInMain

   346

    def UnLoadPLC(self):

   347

        self.PythonRuntimeCleanup()

   348

        self._FreePLC()

   349

   350

    def _InitPLCStubCalls(self):

   351

        """

   352

        create dummy C func proxies

   353

        """

   354

        self._startPLC = lambda x, y: None

   355

        self._stopPLC = lambda: None

   356

        self._ResetDebugVariables = lambda: None

   357

        self._RegisterDebugVariable = lambda x, y: None

   358

        self._IterDebugData = lambda x, y: None

   359

        self._FreeDebugData = lambda: None

   360

        self._GetDebugData = lambda: -1

   361

        self._suspendDebug = lambda x: -1

   362

        self._resumeDebug = lambda: None

   363

        self._PythonIterator = lambda: ""

   364

        self._GetLogCount = None

   365

        self._LogMessage = None

   366

        self._GetLogMessage = None

   367

        self._PLClibraryHandle = None

   368

        self.PLClibraryHandle = None

   369

   370

    def _FreePLC(self):

   371

        """

   372

        Unload PLC library.

   373

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

   374

        """

   375

        self.PLClibraryLock.acquire()

   376

   377

        # Unload library explicitely

   378

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

   379

            dlclose(self._PLClibraryHandle)

   380

   381

        # Forget all refs to library

   382

        self._InitPLCStubCalls()

   383

   384

        self.PLClibraryLock.release()

   385

        return False

   386

   387

    def PythonRuntimeCall(self, methodname):

   388

        """

   389

        Calls init, start, stop or cleanup method provided by

   390

        runtime python files, loaded when new PLC uploaded

   391

        """

   392

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

   393

            _res, exp = self.evaluator(method)

   394

            if exp is not None:

   395

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

   396

   397

    def PythonRuntimeInit(self):

   398

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

   399

        self.python_runtime_vars = globals().copy()

   400

        self.python_runtime_vars.update(self.pyruntimevars)

   401

        parent = self

   402

   403

        class PLCSafeGlobals(object):

   404

            def __getattr__(self, name):

   405

                try:

   406

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

   407

                except KeyError:

   408

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

   409

                v = t()

   410

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

   411

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

   412

   413

            def __setattr__(self, name, value):

   414

                try:

   415

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

   416

                except KeyError:

   417

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

   418

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

   419

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

   420

   421

        self.python_runtime_vars.update({

   422

            "PLCGlobals":     PLCSafeGlobals(),

   423

            "WorkingDir":     self.workingdir,

   424

            "PLCObject":      self,

   425

            "PLCBinary":      self.PLClibraryHandle,

   426

            "PLCGlobalsDesc": []})

   427

   428

        for methodname in MethodNames:

   429

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

   430

   431

        try:

   432

            filenames = os.listdir(self.workingdir)

   433

            filenames.sort()

   434

            for filename in filenames:

   435

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

   436

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

   437

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

   438

                    for methodname in MethodNames:

   439

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

   440

                        if method is not None:

   441

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

   442

        except Exception:

   443

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

   444

            raise

   445

   446

        self.PythonRuntimeCall("init")

   447

   448

    def PythonRuntimeCleanup(self):

   449

        if self.python_runtime_vars is not None:

   450

            self.PythonRuntimeCall("cleanup")

   451

   452

        self.python_runtime_vars = None

   453

   454

    def PythonThreadProc(self):

   455

        self.StartSem.release()

   456

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

   457

        compile_cache = {}

   458

        while True:

   459

            # print "_PythonIterator(", res, ")",

   460

            cmd = self._PythonIterator(res, blkid)

   461

            FBID = blkid.value

   462

            # print " -> ", cmd, blkid

   463

            if cmd is None:

   464

                break

   465

            try:

   466

                self.python_runtime_vars["FBID"] = FBID

   467

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

   468

                if ccmd is None or ccmd != cmd:

   469

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

   470

                    compile_cache[FBID] = (cmd, AST)

   471

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

   472

                if exp is not None:

   473

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

   474

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

   475

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

   476

                else:

   477

                    res = str(result)

   478

                self.python_runtime_vars["FBID"] = None

   479

            except Exception, e:

   480

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

   481

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

   482