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

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

    27

import ctypes

    28

import os

    29

import sys

    30

import traceback

    31

from time import time

    32

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

    34

import Pyro.core as pyro

    35

import six

    36

from six.moves import _thread, xrange

    37

    38

from runtime.typemapping import TypeTranslator

    39

from runtime.loglevels import LogLevelsDefault, LogLevelsCount

    40

from runtime import PlcStatus

    41

    42

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

    43

    dlopen = _ctypes.LoadLibrary

    44

    dlclose = _ctypes.FreeLibrary

    45

elif os.name == "posix":

    46

    dlopen = _ctypes.dlopen

    47

    dlclose = _ctypes.dlclose

    48

    49

    50

def get_last_traceback(tb):

    51

    while tb.tb_next:

    52

        tb = tb.tb_next

    53

    return tb

    54

    55

    56

lib_ext = {

    57

    "linux2": ".so",

    58

    "win32":  ".dll",

    59

}.get(sys.platform, "")

    60

    61

    62

def PLCprint(message):

    63

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

    64

    sys.stdout.flush()

    65

    66

    67

class job(object):

    68

    """

    69

    job to be executed by a worker

    70

    """

    71

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

    72

        self.job = (call, args, kwargs)

    73

        self.result = None

    74

        self.success = False

    75

        self.exc_info = None

    76

    77

    def do(self):

    78

        """

    79

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

    80

        """

    81

        try:

    82

            call, args, kwargs = self.job

    83

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

    84

            self.success = True

    85

        except Exception:

    86

            self.success = False

    87

            self.exc_info = sys.exc_info()

    88

    89

    90

class worker(object):

    91

    """

    92

    serialize main thread load/unload of PLC shared objects

    93

    """

    94

    def __init__(self):

    95

        # Only one job at a time

    96

        self._finish = False

    97

        self._threadID = None

    98

        self.mutex = Lock()

    99

        self.todo = Condition(self.mutex)

   100

        self.done = Condition(self.mutex)

   101

        self.free = Condition(self.mutex)

   102

        self.job = None

   103

   104

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

   105

        """

   106

        meant to be called by worker thread (blocking)

   107

        """

   108

        self._threadID = _thread.get_ident()

   109

        if args or kwargs:

   110

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

   111

            # result is ignored

   112

        self.mutex.acquire()

   113

        while not self._finish:

   114

            self.todo.wait()

   115

            if self.job is not None:

   116

                self.job.do()

   117

                self.done.notify()

   118

            else:

   119

                self.free.notify()

   120

        self.mutex.release()

   121

   122

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

   123

        """

   124

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

   125

        if job execution raise exception, re-raise same exception

   126

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

   127

        blocking until job done

   128

        """

   129

   130

        _job = job(*args, **kwargs)

   131

   132

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

   133

            # if caller is worker thread execute immediately

   134

            _job.do()

   135

        else:

   136

            # otherwise notify and wait for completion

   137

            self.mutex.acquire()

   138

   139

            while self.job is not None:

   140

                self.free.wait()

   141

   142

            self.job = _job

   143

            self.todo.notify()

   144

            self.done.wait()

   145

            _job = self.job

   146

            self.job = None

   147

            self.mutex.release()

   148

   149

        if _job.success:

   150

            return _job.result

   151

        else:

   152

            exc_type = _job.exc_info[0]

   153

            exc_value = _job.exc_info[1]

   154

            exc_traceback = _job.exc_info[2]

   155

            six.reraise(exc_type, exc_value, exc_traceback)

   156

   157

    def quit(self):

   158

        """

   159

        unblocks main thread, and terminate execution of runloop()

   160

        """

   161

        # mark queue

   162

        self._finish = True

   163

        self.mutex.acquire()

   164

        self.job = None

   165

        self.todo.notify()

   166

        self.mutex.release()

   167

   168

   169

MainWorker = worker()

   170

   171

   172

def RunInMain(func):

   173

    def func_wrapper(*args, **kwargs):

   174

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

   175

    return func_wrapper

   176

   177

   178

class PLCObject(pyro.ObjBase):

   179

    def __init__(self, server):

   180

        pyro.ObjBase.__init__(self)

   181

        self.evaluator = server.evaluator

   182

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

   183

        self.workingdir = server.workdir

   184

        self.PLCStatus = PlcStatus.Empty

   185

        self.PLClibraryHandle = None

   186

        self.PLClibraryLock = Lock()

   187

        self.DummyIteratorLock = None

   188

        # Creates fake C funcs proxies

   189

        self._InitPLCStubCalls()

   190

        self.daemon = server.daemon

   191

        self.statuschange = server.statuschange

   192

        self.hmi_frame = None

   193

        self.pyruntimevars = server.pyruntimevars

   194

        self._loading_error = None

   195

        self.python_runtime_vars = None

   196

        self.TraceThread = None

   197

        self.TraceLock = Lock()

   198

        self.Traces = []

   199

   200

    # First task of worker -> no @RunInMain

   201

    def AutoLoad(self):

   202

        # Get the last transfered PLC

   203

        try:

   204

            self.CurrentPLCFilename = open(

   205

                self._GetMD5FileName(),

   206

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

   207

            if self.LoadPLC():

   208

                self.PLCStatus = PlcStatus.Stopped

   209

        except Exception:

   210

            self.PLCStatus = PlcStatus.Empty

   211

            self.CurrentPLCFilename = None

   212

   213

    def StatusChange(self):

   214

        if self.statuschange is not None:

   215

            for callee in self.statuschange:

   216

                callee(self.PLCStatus)

   217

   218

    @RunInMain

   219

    def LogMessage(self, *args):

   220

        if len(args) == 2:

   221

            level, msg = args

   222

        else:

   223

            level = LogLevelsDefault

   224

            msg, = args

   225

        PLCprint(msg)

   226

        if self._LogMessage is not None:

   227

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

   228

        return None

   229

   230

    @RunInMain

   231

    def ResetLogCount(self):

   232

        if self._ResetLogCount is not None:

   233

            self._ResetLogCount()

   234

   235

    # used internaly

   236

    def GetLogCount(self, level):

   237

        if self._GetLogCount is not None:

   238

            return int(self._GetLogCount(level))

   239

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

   240

            return 1

   241

   242

    @RunInMain

   243

    def GetLogMessage(self, level, msgid):

   244

        tick = ctypes.c_uint32()

   245

        tv_sec = ctypes.c_uint32()

   246

        tv_nsec = ctypes.c_uint32()

   247

        if self._GetLogMessage is not None:

   248

            maxsz = len(self._log_read_buffer)-1

   249

            sz = self._GetLogMessage(level, msgid,

   250

                                     self._log_read_buffer, maxsz,

   251

                                     ctypes.byref(tick),

   252

                                     ctypes.byref(tv_sec),

   253

                                     ctypes.byref(tv_nsec))

   254

            if sz and sz <= maxsz:

   255

                self._log_read_buffer[sz] = '\x00'

   256

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

   257

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

   258

            return self._loading_error, 0, 0, 0

   259

        return None

   260

   261

    def _GetMD5FileName(self):

   262

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

   263

   264

    def _GetLibFileName(self):

   265

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

   266

   267

    def _LoadPLC(self):

   268

        """

   269

        Load PLC library

   270

        Declare all functions, arguments and return values

   271

        """

   272

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

   273

        self.PLClibraryLock.acquire()

   274

        try:

   275

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

   276

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

   277

   278

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

   279

            if len(md5) == 32:

   280

                self.PLC_ID.value = md5

   281

   282

            self._startPLC = self.PLClibraryHandle.startPLC

   283

            self._startPLC.restype = ctypes.c_int

   284

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

   285

   286

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   287

            self._stopPLC_real.restype = None

   288

   289

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

   290

            if self._PythonIterator is not None:

   291

                self._PythonIterator.restype = ctypes.c_char_p

   292

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

   293

   294

                self._stopPLC = self._stopPLC_real

   295

            else:

   296

                # If python confnode is not enabled, we reuse _PythonIterator

   297

                # as a call that block pythonthread until StopPLC

   298

                self.PlcStopping = Event()

   299

   300

                def PythonIterator(res, blkid):

   301

                    self.PlcStopping.clear()

   302

                    self.PlcStopping.wait()

   303

                    return None

   304

                self._PythonIterator = PythonIterator

   305

   306

                def __StopPLC():

   307

                    self._stopPLC_real()

   308

                    self.PlcStopping.set()

   309

                self._stopPLC = __StopPLC

   310

   311

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   312

            self._ResetDebugVariables.restype = None

   313

   314

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   315

            self._RegisterDebugVariable.restype = None

   316

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

   317

   318

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   319

            self._FreeDebugData.restype = None

   320

   321

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   322

            self._GetDebugData.restype = ctypes.c_int

   323

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

   324

   325

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   326

            self._suspendDebug.restype = ctypes.c_int

   327

            self._suspendDebug.argtypes = [ctypes.c_int]

   328

   329

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   330

            self._resumeDebug.restype = None

   331

   332

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   333

            self._ResetLogCount.restype = None

   334

   335

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   336

            self._GetLogCount.restype = ctypes.c_uint32

   337

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   338

   339

            self._LogMessage = self.PLClibraryHandle.LogMessage

   340

            self._LogMessage.restype = ctypes.c_int

   341

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

   342

   343

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

   344

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   345

            self._GetLogMessage.restype = ctypes.c_uint32

   346

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

   347

   348

            self._loading_error = None

   349

   350

        except Exception:

   351

            self._loading_error = traceback.format_exc()

   352

            PLCprint(self._loading_error)

   353

            return False

   354

        finally:

   355

            self.PLClibraryLock.release()

   356

   357

        return True

   358

   359

    @RunInMain

   360

    def LoadPLC(self):

   361

        res = self._LoadPLC()

   362

        if res:

   363

            self.PythonRuntimeInit()

   364

        else:

   365

            self._FreePLC()

   366

   367

        return res

   368

   369

    @RunInMain

   370

    def UnLoadPLC(self):

   371

        self.PythonRuntimeCleanup()

   372

        self._FreePLC()

   373

   374

    def _InitPLCStubCalls(self):

   375

        """

   376

        create dummy C func proxies

   377

        """

   378

        self._startPLC = lambda x, y: None

   379

        self._stopPLC = lambda: None

   380

        self._ResetDebugVariables = lambda: None

   381

        self._RegisterDebugVariable = lambda x, y: None

   382

        self._IterDebugData = lambda x, y: None

   383

        self._FreeDebugData = lambda: None

   384

        self._GetDebugData = lambda: -1

   385

        self._suspendDebug = lambda x: -1

   386

        self._resumeDebug = lambda: None

   387

        self._PythonIterator = lambda: ""

   388

        self._GetLogCount = None

   389

        self._LogMessage = None

   390

        self._GetLogMessage = None

   391

        self._PLClibraryHandle = None

   392

        self.PLClibraryHandle = None

   393

   394

    def _FreePLC(self):

   395

        """

   396

        Unload PLC library.

   397

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

   398

        """

   399

        self.PLClibraryLock.acquire()

   400

        try:

   401

            # Unload library explicitely

   402

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

   403

                dlclose(self._PLClibraryHandle)

   404

   405

            # Forget all refs to library

   406

            self._InitPLCStubCalls()

   407

   408

        finally:

   409

            self.PLClibraryLock.release()

   410

   411

        return False

   412

   413

    def PythonRuntimeCall(self, methodname):

   414

        """

   415

        Calls init, start, stop or cleanup method provided by

   416

        runtime python files, loaded when new PLC uploaded

   417

        """

   418

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

   419

            _res, exp = self.evaluator(method)

   420

            if exp is not None:

   421

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

   422

   423

    # used internaly

   424

    def PythonRuntimeInit(self):

   425

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

   426

        self.python_runtime_vars = globals().copy()

   427

        self.python_runtime_vars.update(self.pyruntimevars)

   428

        parent = self

   429

   430

        class PLCSafeGlobals(object):

   431

            def __getattr__(self, name):

   432

                try:

   433

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

   434

                except KeyError:

   435

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

   436

                v = t()

   437

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

   438

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

   439

   440

            def __setattr__(self, name, value):

   441

                try:

   442

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

   443

                except KeyError:

   444

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

   445

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

   446

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

   447

   448

        self.python_runtime_vars.update({

   449

            "PLCGlobals":     PLCSafeGlobals(),

   450

            "WorkingDir":     self.workingdir,

   451

            "PLCObject":      self,

   452

            "PLCBinary":      self.PLClibraryHandle,

   453

            "PLCGlobalsDesc": []})

   454

   455

        for methodname in MethodNames:

   456

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

   457

   458

        try:

   459

            filenames = os.listdir(self.workingdir)

   460

            filenames.sort()

   461

            for filename in filenames:

   462

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

   463

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

   464

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

   465

                    for methodname in MethodNames:

   466

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

   467

                        if method is not None:

   468

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

   469

        except Exception:

   470

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

   471

            raise

   472

   473

        self.PythonRuntimeCall("init")

   474

   475

    # used internaly

   476

    def PythonRuntimeCleanup(self):

   477

        if self.python_runtime_vars is not None:

   478

            self.PythonRuntimeCall("cleanup")

   479

   480

        self.python_runtime_vars = None