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

import six

    36

    37

from runtime.typemapping import TypeTranslator

    38

from runtime.loglevels import LogLevelsDefault, LogLevelsCount

    39

from runtime import PlcStatus

    40

    41

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

    42

    dlopen = _ctypes.LoadLibrary

    43

    dlclose = _ctypes.FreeLibrary

    44

elif os.name == "posix":

    45

    dlopen = _ctypes.dlopen

    46

    dlclose = _ctypes.dlclose

    47

    48

    49

def get_last_traceback(tb):

    50

    while tb.tb_next:

    51

        tb = tb.tb_next

    52

    return tb

    53

    54

    55

lib_ext = {

    56

    "linux2": ".so",

    57

    "win32":  ".dll",

    58

}.get(sys.platform, "")

    59

    60

    61

def PLCprint(message):

    62

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

    63

    sys.stdout.flush()

    64

    65

    66

class job(object):

    67

    """

    68

    job to be executed by a worker

    69

    """

    70

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

    71

        self.job = (call, args, kwargs)

    72

        self.result = None

    73

        self.success = False

    74

        self.exc_info = None

    75

    76

    def do(self):

    77

        """

    78

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

    79

        """

    80

        try:

    81

            call, args, kwargs = self.job

    82

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

    83

            self.success = True

    84

        except Exception:

    85

            self.success = False

    86

            self.exc_info = sys.exc_info()

    87

    88

    89

class worker(object):

    90

    """

    91

    serialize main thread load/unload of PLC shared objects

    92

    """

    93

    def __init__(self):

    94

        # Only one job at a time

    95

        self._finish = False

    96

        self._threadID = None

    97

        self.mutex = Lock()

    98

        self.todo = Condition(self.mutex)

    99

        self.done = Condition(self.mutex)

   100

        self.free = Condition(self.mutex)

   101

        self.job = None

   102

   103

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

   104

        """

   105

        meant to be called by worker thread (blocking)

   106

        """

   107

        self._threadID = thread.get_ident()

   108

        if args or kwargs:

   109

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

   110

            # result is ignored

   111

        self.mutex.acquire()

   112

        while not self._finish:

   113

            self.todo.wait()

   114

            if self.job is not None:

   115

                self.job.do()

   116

                self.done.notify()

   117

            else:

   118

                self.free.notify()

   119

        self.mutex.release()

   120

   121

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

   122

        """

   123

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

   124

        if job execution raise exception, re-raise same exception

   125

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

   126

        blocking until job done

   127

        """

   128

   129

        _job = job(*args, **kwargs)

   130

   131

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

   132

            # if caller is worker thread execute immediately

   133

            _job.do()

   134

        else:

   135

            # otherwise notify and wait for completion

   136

            self.mutex.acquire()

   137

   138

            while self.job is not None:

   139

                self.free.wait()

   140

   141

            self.job = _job

   142

            self.todo.notify()

   143

            self.done.wait()

   144

            _job = self.job

   145

            self.job = None

   146

            self.mutex.release()

   147

   148

        if _job.success:

   149

            return _job.result

   150

        else:

   151

            exc_type = _job.exc_info[0]

   152

            exc_value = _job.exc_info[1]

   153

            exc_traceback = _job.exc_info[2]

   154

            six.reraise(exc_type, exc_value, exc_traceback)

   155

   156

    def quit(self):

   157

        """

   158

        unblocks main thread, and terminate execution of runloop()

   159

        """

   160

        # mark queue

   161

        self._finish = True

   162

        self.mutex.acquire()

   163

        self.job = None

   164

        self.todo.notify()

   165

        self.mutex.release()

   166

   167

   168

MainWorker = worker()

   169

   170

   171

def RunInMain(func):

   172

    def func_wrapper(*args, **kwargs):

   173

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

   174

    return func_wrapper

   175

   176

   177

class PLCObject(pyro.ObjBase):

   178

    def __init__(self, server):

   179

        pyro.ObjBase.__init__(self)

   180

        self.evaluator = server.evaluator

   181

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

   182

        self.workingdir = server.workdir

   183

        self.PLCStatus = PlcStatus.Empty

   184

        self.PLClibraryHandle = None

   185

        self.PLClibraryLock = Lock()

   186

        self.DummyIteratorLock = None

   187

        # Creates fake C funcs proxies

   188

        self._InitPLCStubCalls()

   189

        self.daemon = server.daemon

   190

        self.statuschange = server.statuschange

   191

        self.hmi_frame = None

   192

        self.pyruntimevars = server.pyruntimevars

   193

        self._loading_error = None

   194

        self.python_runtime_vars = None

   195

        self.TraceThread = None

   196

        self.TraceLock = Lock()

   197

        self.Traces = []

   198

   199

    # First task of worker -> no @RunInMain

   200

    def AutoLoad(self):

   201

        # Get the last transfered PLC

   202

        try:

   203

            self.CurrentPLCFilename = open(

   204

                self._GetMD5FileName(),

   205

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

   206

            if self.LoadPLC():

   207

                self.PLCStatus = PlcStatus.Stopped

   208

        except Exception:

   209

            self.PLCStatus = PlcStatus.Empty

   210

            self.CurrentPLCFilename = None

   211

   212

    def StatusChange(self):

   213

        if self.statuschange is not None:

   214

            for callee in self.statuschange:

   215

                callee(self.PLCStatus)

   216

   217

    @RunInMain

   218

    def LogMessage(self, *args):

   219

        if len(args) == 2:

   220

            level, msg = args

   221

        else:

   222

            level = LogLevelsDefault

   223

            msg, = args

   224

        PLCprint(msg)

   225

        if self._LogMessage is not None:

   226

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

   227

        return None

   228

   229

    @RunInMain

   230

    def ResetLogCount(self):

   231

        if self._ResetLogCount is not None:

   232

            self._ResetLogCount()

   233

   234

    # used internaly

   235

    def GetLogCount(self, level):

   236

        if self._GetLogCount is not None:

   237

            return int(self._GetLogCount(level))

   238

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

   239

            return 1

   240

   241

    @RunInMain

   242

    def GetLogMessage(self, level, msgid):

   243

        tick = ctypes.c_uint32()

   244

        tv_sec = ctypes.c_uint32()

   245

        tv_nsec = ctypes.c_uint32()

   246

        if self._GetLogMessage is not None:

   247

            maxsz = len(self._log_read_buffer)-1

   248

            sz = self._GetLogMessage(level, msgid,

   249

                                     self._log_read_buffer, maxsz,

   250

                                     ctypes.byref(tick),

   251

                                     ctypes.byref(tv_sec),

   252

                                     ctypes.byref(tv_nsec))

   253

            if sz and sz <= maxsz:

   254

                self._log_read_buffer[sz] = '\x00'

   255

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

   256

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

   257

            return self._loading_error, 0, 0, 0

   258

        return None

   259

   260

    def _GetMD5FileName(self):

   261

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

   262

   263

    def _GetLibFileName(self):

   264

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

   265

   266

    def _LoadPLC(self):

   267

        """

   268

        Load PLC library

   269

        Declare all functions, arguments and return values

   270

        """

   271

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

   272

        self.PLClibraryLock.acquire()

   273

        try:

   274

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

   275

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

   276

   277

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

   278

            if len(md5) == 32:

   279

                self.PLC_ID.value = md5

   280

   281

            self._startPLC = self.PLClibraryHandle.startPLC

   282

            self._startPLC.restype = ctypes.c_int

   283

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

   284

   285

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   286

            self._stopPLC_real.restype = None

   287

   288

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

   289

            if self._PythonIterator is not None:

   290

                self._PythonIterator.restype = ctypes.c_char_p

   291

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

   292

   293

                self._stopPLC = self._stopPLC_real

   294

            else:

   295

                # If python confnode is not enabled, we reuse _PythonIterator

   296

                # as a call that block pythonthread until StopPLC

   297

                self.PlcStopping = Event()

   298

   299

                def PythonIterator(res, blkid):

   300

                    self.PlcStopping.clear()

   301

                    self.PlcStopping.wait()

   302

                    return None

   303

                self._PythonIterator = PythonIterator

   304

   305

                def __StopPLC():

   306

                    self._stopPLC_real()

   307

                    self.PlcStopping.set()

   308

                self._stopPLC = __StopPLC

   309

   310

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   311

            self._ResetDebugVariables.restype = None

   312

   313

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   314

            self._RegisterDebugVariable.restype = None

   315

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

   316

   317

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   318

            self._FreeDebugData.restype = None

   319

   320

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   321

            self._GetDebugData.restype = ctypes.c_int

   322

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

   323

   324

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   325

            self._suspendDebug.restype = ctypes.c_int

   326

            self._suspendDebug.argtypes = [ctypes.c_int]

   327

   328

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   329

            self._resumeDebug.restype = None

   330

   331

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   332

            self._ResetLogCount.restype = None

   333

   334

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   335

            self._GetLogCount.restype = ctypes.c_uint32

   336

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   337

   338

            self._LogMessage = self.PLClibraryHandle.LogMessage

   339

            self._LogMessage.restype = ctypes.c_int

   340

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

   341

   342

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

   343

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   344

            self._GetLogMessage.restype = ctypes.c_uint32

   345

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

   346

   347

            self._loading_error = None

   348

   349

        except Exception:

   350

            self._loading_error = traceback.format_exc()

   351

            PLCprint(self._loading_error)

   352

            return False

   353

        finally:

   354

            self.PLClibraryLock.release()

   355

   356

        return True

   357

   358

    @RunInMain

   359

    def LoadPLC(self):

   360

        res = self._LoadPLC()

   361

        if res:

   362

            self.PythonRuntimeInit()

   363

        else:

   364

            self._FreePLC()

   365

   366

        return res

   367

   368

    @RunInMain

   369

    def UnLoadPLC(self):

   370

        self.PythonRuntimeCleanup()

   371

        self._FreePLC()

   372

   373

    def _InitPLCStubCalls(self):

   374

        """

   375

        create dummy C func proxies

   376

        """

   377

        self._startPLC = lambda x, y: None

   378

        self._stopPLC = lambda: None

   379

        self._ResetDebugVariables = lambda: None

   380

        self._RegisterDebugVariable = lambda x, y: None

   381

        self._IterDebugData = lambda x, y: None

   382

        self._FreeDebugData = lambda: None

   383

        self._GetDebugData = lambda: -1

   384

        self._suspendDebug = lambda x: -1

   385

        self._resumeDebug = lambda: None

   386

        self._PythonIterator = lambda: ""

   387

        self._GetLogCount = None

   388

        self._LogMessage = None

   389

        self._GetLogMessage = None

   390

        self._PLClibraryHandle = None

   391

        self.PLClibraryHandle = None

   392

   393

    def _FreePLC(self):

   394

        """

   395

        Unload PLC library.

   396

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

   397

        """

   398

        self.PLClibraryLock.acquire()

   399

        try:

   400

            # Unload library explicitely

   401

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

   402

                dlclose(self._PLClibraryHandle)

   403

   404

            # Forget all refs to library

   405

            self._InitPLCStubCalls()

   406

   407

        finally:

   408

            self.PLClibraryLock.release()

   409

   410

        return False

   411

   412

    def PythonRuntimeCall(self, methodname):

   413

        """

   414

        Calls init, start, stop or cleanup method provided by

   415

        runtime python files, loaded when new PLC uploaded

   416

        """

   417

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

   418

            _res, exp = self.evaluator(method)

   419

            if exp is not None:

   420

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

   421

   422

    # used internaly

   423

    def PythonRuntimeInit(self):

   424

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

   425

        self.python_runtime_vars = globals().copy()

   426

        self.python_runtime_vars.update(self.pyruntimevars)

   427

        parent = self

   428

   429

        class PLCSafeGlobals(object):

   430

            def __getattr__(self, name):

   431

                try:

   432

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

   433

                except KeyError:

   434

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

   435

                v = t()

   436

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

   437

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

   438

   439

            def __setattr__(self, name, value):

   440

                try:

   441

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

   442

                except KeyError:

   443

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

   444

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

   445

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

   446

   447

        self.python_runtime_vars.update({

   448

            "PLCGlobals":     PLCSafeGlobals(),

   449

            "WorkingDir":     self.workingdir,

   450

            "PLCObject":      self,

   451

            "PLCBinary":      self.PLClibraryHandle,

   452

            "PLCGlobalsDesc": []})

   453

   454

        for methodname in MethodNames:

   455

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

   456

   457

        try:

   458

            filenames = os.listdir(self.workingdir)

   459

            filenames.sort()

   460

            for filename in filenames:

   461

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

   462

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

   463

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

   464

                    for methodname in MethodNames:

   465

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

   466

                        if method is not None:

   467

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

   468

        except Exception:

   469

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

   470

            raise

   471

   472

        self.PythonRuntimeCall("init")

   473

   474

    # used internaly

   475

    def PythonRuntimeCleanup(self):

   476

        if self.python_runtime_vars is not None:

   477

            self.PythonRuntimeCall("cleanup")

   478

   479

        self.python_runtime_vars = None

   480