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,*args,**kwargs):

   101

        """

   102

        meant to be called by worker thread (blocking)

   103

        """

   104

        self._threadID = thread.get_ident()

   105

        if args or kwargs:

   106

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

   107

            # result is ignored

   108

        self.mutex.acquire()

   109

        while not self._finish:

   110

            self.todo.wait()

   111

            if self.job is not None:

   112

                self.job.do()

   113

            self.done.notify_all()

   114

        self.mutex.release()

   115

   116

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

   117

        """

   118

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

   119

        if job execution raise exception, re-raise same exception 

   120

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

   121

        blocking until job done

   122

        """

   123

   124

        _job = job(*args,**kwargs)

   125

   126

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

   127

            # if caller is worker thread execute immediately

   128

            _job.do()

   129

        else:

   130

            # otherwise notify and wait for completion

   131

            self.mutex.acquire()

   132

   133

            while self.job is not None:

   134

                self.done.wait()

   135

   136

            self.job = _job

   137

            self.todo.notify()

   138

            self.done.wait()

   139

            _job = self.job

   140

            self.job = None

   141

            self.mutex.release()

   142

   143

        if _job.success:

   144

            return _job.result

   145

        else:

   146

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

   147

   148

    def quit(self):

   149

        """

   150

        unblocks main thread, and terminate execution of runloop()

   151

        """

   152

        # mark queue

   153

        self._finish = True

   154

        self.mutex.acquire()

   155

        self.job = None

   156

        self.todo.notify()

   157

        self.mutex.release()

   158

   159

   160

MainWorker = worker()

   161

   162

   163

def RunInMain(func):

   164

    def func_wrapper(*args,**kwargs):

   165

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

   166

    return func_wrapper

   167

   168

   169

class PLCObject(pyro.ObjBase):

   170

    def __init__(self, server):

   171

   172

        pyro.ObjBase.__init__(self)

   173

        self.evaluator = server.evaluator

   174

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

   175

        self.workingdir = server.workdir

   176

        self.PLCStatus = "Empty"

   177

        self.PLClibraryHandle = None

   178

        self.PLClibraryLock = Lock()

   179

        self.DummyIteratorLock = None

   180

        # Creates fake C funcs proxies

   181

        self._InitPLCStubCalls()

   182

        self.daemon = server.daemon

   183

        self.statuschange = server.statuschange

   184

        self.hmi_frame = None

   185

        self.pyruntimevars = server.pyruntimevars

   186

        self._loading_error = None

   187

        self.python_runtime_vars = None

   188

        self.TraceThread = None

   189

        self.TraceLock = Lock()

   190

        self.TraceWakeup = Event()

   191

        self.Traces = []

   192

   193

    def AutoLoad(self):

   194

        # Get the last transfered PLC if connector must be restart

   195

        try:

   196

            self.CurrentPLCFilename = open(

   197

                self._GetMD5FileName(),

   198

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

   199

            if self.LoadPLC():

   200

                self.PLCStatus = "Stopped"

   201

        except Exception:

   202

            self.PLCStatus = "Empty"

   203

            self.CurrentPLCFilename = None

   204

   205

    def StatusChange(self):

   206

        if self.statuschange is not None:

   207

            for callee in self.statuschange:

   208

                callee(self.PLCStatus)

   209

   210

    def LogMessage(self, *args):

   211

        if len(args) == 2:

   212

            level, msg = args

   213

        else:

   214

            level = LogLevelsDefault

   215

            msg, = args

   216

        PLCprint(msg)

   217

        if self._LogMessage is not None:

   218

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

   219

        return None

   220

   221

    def ResetLogCount(self):

   222

        if self._ResetLogCount is not None:

   223

            self._ResetLogCount()

   224

   225

    def GetLogCount(self, level):

   226

        if self._GetLogCount is not None:

   227

            return int(self._GetLogCount(level))

   228

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

   229

            return 1

   230

   231

    def GetLogMessage(self, level, msgid):

   232

        tick = ctypes.c_uint32()

   233

        tv_sec = ctypes.c_uint32()

   234

        tv_nsec = ctypes.c_uint32()

   235

        if self._GetLogMessage is not None:

   236

            maxsz = len(self._log_read_buffer)-1

   237

            sz = self._GetLogMessage(level, msgid,

   238

                                     self._log_read_buffer, maxsz,

   239

                                     ctypes.byref(tick),

   240

                                     ctypes.byref(tv_sec),

   241

                                     ctypes.byref(tv_nsec))

   242

            if sz and sz <= maxsz:

   243

                self._log_read_buffer[sz] = '\x00'

   244

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

   245

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

   246

            return self._loading_error, 0, 0, 0

   247

        return None

   248

   249

    def _GetMD5FileName(self):

   250

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

   251

   252

    def _GetLibFileName(self):

   253

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

   254

   255

    @RunInMain

   256

    def LoadPLC(self):

   257

        """

   258

        Load PLC library

   259

        Declare all functions, arguments and return values

   260

        """

   261

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

   262

        try:

   263

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

   264

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

   265

   266

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

   267

            if len(md5) == 32:

   268

                self.PLC_ID.value = md5

   269

   270

            self._startPLC = self.PLClibraryHandle.startPLC

   271

            self._startPLC.restype = ctypes.c_int

   272

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

   273

   274

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   275

            self._stopPLC_real.restype = None

   276

   277

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

   278

            print(self._PythonIterator)

   279

            if self._PythonIterator is not None:

   280

                self._PythonIterator.restype = ctypes.c_char_p

   281

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

   282

   283

                self._stopPLC = self._stopPLC_real

   284

            else:

   285

                # If python confnode is not enabled, we reuse _PythonIterator

   286

                # as a call that block pythonthread until StopPLC

   287

                self.PlcStopping = Event()

   288

   289

                def PythonIterator(res, blkid):

   290

                    self.PlcStopping.clear()

   291

                    self.PlcStopping.wait()

   292

                    return None

   293

                self._PythonIterator = PythonIterator

   294

   295

                def __StopPLC():

   296

                    self._stopPLC_real()

   297

                    self.PlcStopping.set()

   298

                self._stopPLC = __StopPLC

   299

   300

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   301

            self._ResetDebugVariables.restype = None

   302

   303

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   304

            self._RegisterDebugVariable.restype = None

   305

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

   306

   307

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   308

            self._FreeDebugData.restype = None

   309

   310

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   311

            self._GetDebugData.restype = ctypes.c_int

   312

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

   313

   314

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   315

            self._suspendDebug.restype = ctypes.c_int

   316

            self._suspendDebug.argtypes = [ctypes.c_int]

   317

   318

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   319

            self._resumeDebug.restype = None

   320

   321

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   322

            self._ResetLogCount.restype = None

   323

   324

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   325

            self._GetLogCount.restype = ctypes.c_uint32

   326

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   327

   328

            self._LogMessage = self.PLClibraryHandle.LogMessage

   329

            self._LogMessage.restype = ctypes.c_int

   330

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

   331

   332

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

   333

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   334

            self._GetLogMessage.restype = ctypes.c_uint32

   335

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

   336

   337

            self._loading_error = None

   338

   339

            self.PythonRuntimeInit()

   340

   341

            return True

   342

        except Exception:

   343

            self._loading_error = traceback.format_exc()

   344

            PLCprint(self._loading_error)

   345

            self._FreePLC()

   346

            return False

   347

   348

    @RunInMain

   349

    def UnLoadPLC(self):

   350

        self.PythonRuntimeCleanup()

   351

        self._FreePLC()

   352

   353

    def _InitPLCStubCalls(self):

   354

        """

   355

        create dummy C func proxies

   356

        """

   357

        self._startPLC = lambda x, y: None

   358

        self._stopPLC = lambda: None

   359

        self._ResetDebugVariables = lambda: None

   360

        self._RegisterDebugVariable = lambda x, y: None

   361

        self._IterDebugData = lambda x, y: None

   362

        self._FreeDebugData = lambda: None

   363

        self._GetDebugData = lambda: -1

   364

        self._suspendDebug = lambda x: -1

   365

        self._resumeDebug = lambda: None

   366

        self._PythonIterator = lambda: ""

   367

        self._GetLogCount = None

   368

        self._LogMessage = None

   369

        self._GetLogMessage = None

   370

        self._PLClibraryHandle = None

   371

        self.PLClibraryHandle = None

   372

   373

    def _FreePLC(self):

   374

        """

   375

        Unload PLC library.

   376

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

   377

        """

   378

        self.PLClibraryLock.acquire()

   379

   380

        # Unload library explicitely

   381

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

   382

            dlclose(self._PLClibraryHandle)

   383

   384

        # Forget all refs to library

   385

        self._InitPLCStubCalls()

   386

   387

        self.PLClibraryLock.release()

   388

        return False

   389

   390

    def PythonRuntimeCall(self, methodname):

   391

        """

   392

        Calls init, start, stop or cleanup method provided by

   393

        runtime python files, loaded when new PLC uploaded

   394

        """

   395

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

   396

            _res, exp = self.evaluator(method)

   397

            if exp is not None:

   398

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

   399

   400

    def PythonRuntimeInit(self):

   401

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

   402

        self.python_runtime_vars = globals().copy()

   403

        self.python_runtime_vars.update(self.pyruntimevars)

   404

        parent = self

   405

   406

        class PLCSafeGlobals(object):

   407

            def __getattr__(self, name):

   408

                try:

   409

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

   410

                except KeyError:

   411

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

   412

                v = t()

   413

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

   414

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

   415

   416

            def __setattr__(self, name, value):

   417

                try:

   418

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

   419

                except KeyError:

   420

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

   421

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

   422

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

   423

   424

        self.python_runtime_vars.update({

   425

            "PLCGlobals":     PLCSafeGlobals(),

   426

            "WorkingDir":     self.workingdir,

   427

            "PLCObject":      self,

   428

            "PLCBinary":      self.PLClibraryHandle,

   429

            "PLCGlobalsDesc": []})

   430

   431

        for methodname in MethodNames:

   432

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

   433

   434

        try:

   435

            filenames = os.listdir(self.workingdir)

   436

            filenames.sort()

   437

            for filename in filenames:

   438

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

   439

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

   440

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

   441

                    for methodname in MethodNames:

   442

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

   443

                        if method is not None:

   444

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

   445

        except Exception:

   446

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

   447

            raise

   448

   449

        self.PythonRuntimeCall("init")

   450

   451

    def PythonRuntimeCleanup(self):

   452

        if self.python_runtime_vars is not None:

   453

            self.PythonRuntimeCall("cleanup")

   454

   455

        self.python_runtime_vars = None

   456

   457

    def PythonThreadProc(self):

   458

        self.StartSem.release()

   459

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

   460

        compile_cache = {}

   461

        while True:

   462

            cmd = self._PythonIterator(res, blkid)

   463

            FBID = blkid.value

   464

            if cmd is None:

   465

                break

   466

            try:

   467

                self.python_runtime_vars["FBID"] = FBID

   468

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

   469

                if ccmd is None or ccmd != cmd:

   470

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

   471

                    compile_cache[FBID] = (cmd, AST)

   472

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

   473

                if exp is not None:

   474

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

   475

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

   476

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

   477

                else:

   478

                    res = str(result)

   479

                self.python_runtime_vars["FBID"] = None

   480

            except Exception, e:

   481

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