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

    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

    """

    70

        self.result = None

    71

        self.success = False

    72

        self.exc_info = None

    73

    74

    def do(self):

    75

        """

    79

            call, args, kwargs = self.job

    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.free = Condition(self.mutex)

    99

        self.job = None

   100

   102

        """

   103

        meant to be called by worker thread (blocking)

   104

        """

   105

        self._threadID = thread.get_ident()

   106

        if args or kwargs:

   108

            # result is ignored

   109

        self.mutex.acquire()

   110

        while not self._finish:

   111

            self.todo.wait()

   112

            if self.job is not None:

   113

                self.job.do()

   114

                self.done.notify()

   115

            else:

   116

                self.free.notify()

   117

        self.mutex.release()

   119

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

   120

        """

   121

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

   123

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

   124

        blocking until job done

   125

        """

   126

   128

   129

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

   130

            # if caller is worker thread execute immediately

   131

            _job.do()

   132

        else:

   133

            # otherwise notify and wait for completion

   134

            self.mutex.acquire()

   135

   136

            while self.job is not None:

   137

                self.free.wait()

   138

   139

            self.job = _job

   140

            self.todo.notify()

   141

            self.done.wait()

   142

            _job = self.job

   143

            self.job = None

   144

            self.mutex.release()

   145

   146

        if _job.success:

   147

            return _job.result

   148

        else:

   149

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

   151

    def quit(self):

   152

        """

   153

        unblocks main thread, and terminate execution of runloop()

   154

        """

   155

        # mark queue

   156

        self._finish = True

   157

        self.mutex.acquire()

   158

        self.job = None

   159

        self.todo.notify()

   160

        self.mutex.release()

   161

   162

   163

MainWorker = worker()

   164

   165

   166

def RunInMain(func):

   168

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

   169

    return func_wrapper

   171

   172

class PLCObject(pyro.ObjBase):

   173

    def __init__(self, server):

   174

        pyro.ObjBase.__init__(self)

   175

        self.evaluator = server.evaluator

   176

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

   177

        self.workingdir = server.workdir

   178

        self.PLCStatus = "Empty"

   179

        self.PLClibraryHandle = None

   180

        self.PLClibraryLock = Lock()

   181

        self.DummyIteratorLock = None

   182

        # Creates fake C funcs proxies

   183

        self._InitPLCStubCalls()

   184

        self.daemon = server.daemon

   185

        self.statuschange = server.statuschange

   186

        self.hmi_frame = None

   187

        self.pyruntimevars = server.pyruntimevars

   188

        self._loading_error = None

   189

        self.python_runtime_vars = None

   190

        self.TraceThread = None

   191

        self.TraceLock = Lock()

   192

        self.Traces = []

   193

   194

    # First task of worker -> no @RunInMain

   195

    def AutoLoad(self):

   197

        try:

   198

            self.CurrentPLCFilename = open(

   199

                self._GetMD5FileName(),

   200

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

   201

            if self.LoadPLC():

   202

                self.PLCStatus = "Stopped"

   203

        except Exception:

   204

            self.PLCStatus = "Empty"

   205

            self.CurrentPLCFilename = None

   206

   207

    def StatusChange(self):

   208

        if self.statuschange is not None:

   209

            for callee in self.statuschange:

   210

                callee(self.PLCStatus)

   211

   212

    @RunInMain

   213

    def LogMessage(self, *args):

   214

        if len(args) == 2:

   215

            level, msg = args

   216

        else:

   217

            level = LogLevelsDefault

   218

            msg, = args

   219

        PLCprint(msg)

   220

        if self._LogMessage is not None:

   221

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

   222

        return None

   223

   224

    @RunInMain

   225

    def ResetLogCount(self):

   226

        if self._ResetLogCount is not None:

   227

            self._ResetLogCount()

   228

   230

    def GetLogCount(self, level):

   231

        if self._GetLogCount is not None:

   232

            return int(self._GetLogCount(level))

   233

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

   234

            return 1

   235

   236

    @RunInMain

   237

    def GetLogMessage(self, level, msgid):

   238

        tick = ctypes.c_uint32()

   239

        tv_sec = ctypes.c_uint32()

   240

        tv_nsec = ctypes.c_uint32()

   241

        if self._GetLogMessage is not None:

   242

            maxsz = len(self._log_read_buffer)-1

   243

            sz = self._GetLogMessage(level, msgid,

   244

                                     self._log_read_buffer, maxsz,

   245

                                     ctypes.byref(tick),

   246

                                     ctypes.byref(tv_sec),

   247

                                     ctypes.byref(tv_nsec))

   248

            if sz and sz <= maxsz:

   249

                self._log_read_buffer[sz] = '\x00'

   250

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

   251

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

   252

            return self._loading_error, 0, 0, 0

   253

        return None

   254

   255

    def _GetMD5FileName(self):

   256

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

   257

   258

    def _GetLibFileName(self):

   259

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

   260

   261

    def _LoadPLC(self):

   262

        """

   263

        Load PLC library

   264

        Declare all functions, arguments and return values

   265

        """

   266

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

   267

        self.PLClibraryLock.acquire()

   268

        try:

   269

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

   270

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

   271

   272

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

   273

            if len(md5) == 32:

   274

                self.PLC_ID.value = md5

   275

   276

            self._startPLC = self.PLClibraryHandle.startPLC

   277

            self._startPLC.restype = ctypes.c_int

   278

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

   279

   280

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   281

            self._stopPLC_real.restype = None

   282

   283

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

   284

            if self._PythonIterator is not None:

   285

                self._PythonIterator.restype = ctypes.c_char_p

   286

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

   287

   288

                self._stopPLC = self._stopPLC_real

   289

            else:

   290

                # If python confnode is not enabled, we reuse _PythonIterator

   291

                # as a call that block pythonthread until StopPLC

   292

                self.PlcStopping = Event()

   293

   294

                def PythonIterator(res, blkid):

   295

                    self.PlcStopping.clear()

   296

                    self.PlcStopping.wait()

   297

                    return None

   298

                self._PythonIterator = PythonIterator

   299

   300

                def __StopPLC():

   301

                    self._stopPLC_real()

   302

                    self.PlcStopping.set()

   303

                self._stopPLC = __StopPLC

   304

   305

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   306

            self._ResetDebugVariables.restype = None

   307

   308

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   309

            self._RegisterDebugVariable.restype = None

   310

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

   311

   312

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   313

            self._FreeDebugData.restype = None

   314

   315

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   316

            self._GetDebugData.restype = ctypes.c_int

   317

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

   318

   319

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   320

            self._suspendDebug.restype = ctypes.c_int

   321

            self._suspendDebug.argtypes = [ctypes.c_int]

   322

   323

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   324

            self._resumeDebug.restype = None

   325

   326

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   327

            self._ResetLogCount.restype = None

   328

   329

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   330

            self._GetLogCount.restype = ctypes.c_uint32

   331

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   332

   333

            self._LogMessage = self.PLClibraryHandle.LogMessage

   334

            self._LogMessage.restype = ctypes.c_int

   335

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

   336

   337

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

   338

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   339

            self._GetLogMessage.restype = ctypes.c_uint32

   340

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

   341

   342

            self._loading_error = None

   343

   344

        except Exception:

   345

            self._loading_error = traceback.format_exc()

   346

            PLCprint(self._loading_error)

   347

            return False

   348

        finally:

   349

            self.PLClibraryLock.release()

   350

   351

        return True

   352

   353

    @RunInMain

   354

    def LoadPLC(self):

   355

        res = self._LoadPLC()

   356

        if res:

   357

            self.PythonRuntimeInit()

   358

        else:

   359

            self._FreePLC()

   360

   361

        return res

   362

   363

    @RunInMain

   364

    def UnLoadPLC(self):

   365

        self.PythonRuntimeCleanup()

   366

        self._FreePLC()

   367

   368

    def _InitPLCStubCalls(self):

   369

        """

   370

        create dummy C func proxies

   371

        """

   372

        self._startPLC = lambda x, y: None

   373

        self._stopPLC = lambda: None

   374

        self._ResetDebugVariables = lambda: None

   375

        self._RegisterDebugVariable = lambda x, y: None

   376

        self._IterDebugData = lambda x, y: None

   377

        self._FreeDebugData = lambda: None

   378

        self._GetDebugData = lambda: -1

   379

        self._suspendDebug = lambda x: -1

   380

        self._resumeDebug = lambda: None

   381

        self._PythonIterator = lambda: ""

   382

        self._GetLogCount = None

   383

        self._LogMessage = None

   384

        self._GetLogMessage = None

   385

        self._PLClibraryHandle = None

   386

        self.PLClibraryHandle = None

   387

   388

    def _FreePLC(self):

   389

        """

   390

        Unload PLC library.

   391

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

   392

        """

   393

        self.PLClibraryLock.acquire()

   394

        try:

   395

            # Unload library explicitely

   396

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

   397

                dlclose(self._PLClibraryHandle)

   398

   399

            # Forget all refs to library

   400

            self._InitPLCStubCalls()

   401

   402

        finally:

   403

            self.PLClibraryLock.release()

   404

   405

        return False

   406

   407

    def PythonRuntimeCall(self, methodname):

   408

        """

   409

        Calls init, start, stop or cleanup method provided by

   410

        runtime python files, loaded when new PLC uploaded

   411

        """

   412

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

   413

            _res, exp = self.evaluator(method)

   414

            if exp is not None:

   415

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

   416

   418

    def PythonRuntimeInit(self):

   419

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

   420

        self.python_runtime_vars = globals().copy()

   421

        self.python_runtime_vars.update(self.pyruntimevars)

   422

        parent = self

   423

   424

        class PLCSafeGlobals(object):

   425

            def __getattr__(self, name):

   426

                try:

   427

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

   428

                except KeyError:

   429

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

   430

                v = t()

   431

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

   432

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

   433

   434

            def __setattr__(self, name, value):

   435

                try:

   436

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

   437

                except KeyError:

   438

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

   439

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

   440

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

   441

   442

        self.python_runtime_vars.update({

   443

            "PLCGlobals":     PLCSafeGlobals(),

   444

            "WorkingDir":     self.workingdir,

   445

            "PLCObject":      self,

   446

            "PLCBinary":      self.PLClibraryHandle,

   447

            "PLCGlobalsDesc": []})

   448

   449

        for methodname in MethodNames:

   450

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

   451

   452

        try:

   453

            filenames = os.listdir(self.workingdir)

   454

            filenames.sort()

   455

            for filename in filenames:

   456

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

   457

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

   458

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

   459

                    for methodname in MethodNames:

   460

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

   461

                        if method is not None:

   462

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

   463

        except Exception:

   464

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

   465

            raise

   466

   467

        self.PythonRuntimeCall("init")

   468

   470

    def PythonRuntimeCleanup(self):

   471

        if self.python_runtime_vars is not None:

   472

            self.PythonRuntimeCall("cleanup")

   473

   474

        self.python_runtime_vars = None

   475

   476

    def PythonThreadProc(self):

   477

        self.StartSem.release()

   478

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

   479

        compile_cache = {}

   480

        while True: