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

    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

    33

from past.builtins import execfile

    34

import Pyro.core as pyro

    35

import six

    36

from six.moves import _thread, xrange

    37

import md5

    38

from tempfile import mkstemp

    39

import shutil

    41

    42

from runtime.typemapping import TypeTranslator

    43

from runtime.loglevels import LogLevelsDefault, LogLevelsCount

    44

from runtime.Stunnel import getPSKID

    45

from runtime import PlcStatus

    46

from runtime import MainWorker

    47

    48

empty_md5_digest = md5.new().digest()

    49

    50

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

    51

    dlopen = _ctypes.LoadLibrary

    52

    dlclose = _ctypes.FreeLibrary

    53

elif os.name == "posix":

    54

    dlopen = _ctypes.dlopen

    55

    dlclose = _ctypes.dlclose

    56

    57

    58

def get_last_traceback(tb):

    59

    while tb.tb_next:

    60

        tb = tb.tb_next

    61

    return tb

    62

    63

    64

lib_ext = {

    65

    "linux2": ".so",

    66

    "win32":  ".dll",

    67

}.get(sys.platform, "")

    68

    69

    70

def PLCprint(message):

    71

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

    72

    sys.stdout.flush()

    73

    74

    75

def RunInMain(func):

    77

    def func_wrapper(*args, **kwargs):

    78

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

    79

    return func_wrapper

    80

    81

    82

class PLCObject(object):

    83

    def __init__(self, WorkingDir, argv, statuschange, evaluator, pyruntimevars):

    84

        self.workingdir = WorkingDir # must exits already

    85

        self.tmpdir = os.path.join(WorkingDir, 'tmp')

    86

        if os.path.exists(self.tmpdir):

    87

            shutil.rmtree(self.tmpdir)

    88

        os.mkdir(self.tmpdir)

    89

        # FIXME : is argv of any use nowadays ?

    90

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

    91

        self.statuschange = statuschange

    92

        self.evaluator = evaluator

    93

        self.pyruntimevars = pyruntimevars

    94

        self.PLCStatus = PlcStatus.Empty

    95

        self.PLClibraryHandle = None

    96

        self.PLClibraryLock = Lock()

    97

        # Creates fake C funcs proxies

    98

        self._InitPLCStubCalls()

    99

        self._loading_error = None

   100

        self.python_runtime_vars = None

   101

        self.TraceThread = None

   102

        self.TraceLock = Lock()

   103

        self.Traces = []

   104

        self.DebugToken = 0

   105

   106

        self._init_blobs()

   107

   108

    # First task of worker -> no @RunInMain

   109

    def AutoLoad(self, autostart):

   110

        # Get the last transfered PLC

   111

        try:

   112

            self.CurrentPLCFilename = open(

   113

                self._GetMD5FileName(),

   114

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

   115

            if self.LoadPLC():

   116

                self.PLCStatus = PlcStatus.Stopped

   117

                if autostart:

   118

                    self.StartPLC()

   119

                    return

   120

        except Exception:

   121

            self.PLCStatus = PlcStatus.Empty

   122

            self.CurrentPLCFilename = None

   123

   124

        self.StatusChange()

   125

   126

    def StatusChange(self):

   127

        if self.statuschange is not None:

   128

            for callee in self.statuschange:

   129

                callee(self.PLCStatus)

   130

   131

    @RunInMain

   132

    def LogMessage(self, *args):

   133

        if len(args) == 2:

   134

            level, msg = args

   135

        else:

   136

            level = LogLevelsDefault

   137

            msg, = args

   138

        PLCprint(msg)

   139

        if self._LogMessage is not None:

   140

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

   141

        return None

   142

   143

    @RunInMain

   144

    def ResetLogCount(self):

   145

        if self._ResetLogCount is not None:

   146

            self._ResetLogCount()

   147

   148

    # used internaly

   149

    def GetLogCount(self, level):

   150

        if self._GetLogCount is not None:

   151

            return int(self._GetLogCount(level))

   152

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

   153

            return 1

   154

   155

    @RunInMain

   156

    def GetLogMessage(self, level, msgid):

   157

        tick = ctypes.c_uint32()

   158

        tv_sec = ctypes.c_uint32()

   159

        tv_nsec = ctypes.c_uint32()

   160

        if self._GetLogMessage is not None:

   161

            maxsz = len(self._log_read_buffer)-1

   162

            sz = self._GetLogMessage(level, msgid,

   163

                                     self._log_read_buffer, maxsz,

   164

                                     ctypes.byref(tick),

   165

                                     ctypes.byref(tv_sec),

   166

                                     ctypes.byref(tv_nsec))

   167

            if sz and sz <= maxsz:

   168

                self._log_read_buffer[sz] = '\x00'

   169

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

   170

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

   171

            return self._loading_error, 0, 0, 0

   172

        return None

   173

   174

    def _GetMD5FileName(self):

   175

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

   176

   177

    def _GetLibFileName(self):

   178

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

   179

   180

    def _LoadPLC(self):

   181

        """

   182

        Load PLC library

   183

        Declare all functions, arguments and return values

   184

        """

   185

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

   186

        self.PLClibraryLock.acquire()

   187

        try:

   188

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

   189

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

   190

   191

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

   192

            if len(md5) == 32:

   193

                self.PLC_ID.value = md5

   194

   195

            self._startPLC = self.PLClibraryHandle.startPLC

   196

            self._startPLC.restype = ctypes.c_int

   197

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

   198

   199

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   200

            self._stopPLC_real.restype = None

   201

   202

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

   203

            if self._PythonIterator is not None:

   204

                self._PythonIterator.restype = ctypes.c_char_p

   205

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

   206

   207

                self._stopPLC = self._stopPLC_real

   208

            else:

   209

                # If python confnode is not enabled, we reuse _PythonIterator

   210

                # as a call that block pythonthread until StopPLC

   211

                self.PlcStopping = Event()

   212

   213

                def PythonIterator(res, blkid):

   214

                    self.PlcStopping.clear()

   215

                    self.PlcStopping.wait()

   216

                    return None

   217

                self._PythonIterator = PythonIterator

   218

   219

                def __StopPLC():

   220

                    self._stopPLC_real()

   221

                    self.PlcStopping.set()

   222

                self._stopPLC = __StopPLC

   223

   224

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   225

            self._ResetDebugVariables.restype = None

   226

   227

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   228

            self._RegisterDebugVariable.restype = None

   229

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

   230

   231

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   232

            self._FreeDebugData.restype = None

   233

   234

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   235

            self._GetDebugData.restype = ctypes.c_int

   236

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

   237

   238

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   239

            self._suspendDebug.restype = ctypes.c_int

   240

            self._suspendDebug.argtypes = [ctypes.c_int]

   241

   242

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   243

            self._resumeDebug.restype = None

   244

   245

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   246

            self._ResetLogCount.restype = None

   247

   248

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   249

            self._GetLogCount.restype = ctypes.c_uint32

   250

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   251

   252

            self._LogMessage = self.PLClibraryHandle.LogMessage

   253

            self._LogMessage.restype = ctypes.c_int

   254

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

   255

   256

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

   257

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   258

            self._GetLogMessage.restype = ctypes.c_uint32

   259

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

   260

   261

            self._loading_error = None

   262

   263

        except Exception:

   264

            self._loading_error = traceback.format_exc()

   265

            PLCprint(self._loading_error)

   266

            return False

   267

        finally:

   268

            self.PLClibraryLock.release()

   269

   270

        return True

   271

   272

    @RunInMain

   273

    def LoadPLC(self):

   274

        res = self._LoadPLC()

   275

        if res:

   276

            self.PythonRuntimeInit()

   277

        else:

   278

            self._FreePLC()

   279

   280

        return res

   281

   282

    @RunInMain

   283

    def UnLoadPLC(self):

   284

        self.PythonRuntimeCleanup()

   285

        self._FreePLC()

   286

   287

    def _InitPLCStubCalls(self):

   288

        """

   289

        create dummy C func proxies

   290

        """

   291

        self._startPLC = lambda x, y: None

   292

        self._stopPLC = lambda: None

   293

        self._ResetDebugVariables = lambda: None

   294

        self._RegisterDebugVariable = lambda x, y: None

   295

        self._IterDebugData = lambda x, y: None

   296

        self._FreeDebugData = lambda: None

   297

        self._GetDebugData = lambda: -1

   298

        self._suspendDebug = lambda x: -1

   299

        self._resumeDebug = lambda: None

   300

        self._PythonIterator = lambda: ""

   301

        self._GetLogCount = None

   302

        self._LogMessage = None

   303

        self._GetLogMessage = None

   304

        self._PLClibraryHandle = None

   305

        self.PLClibraryHandle = None

   306

   307

    def _FreePLC(self):

   308

        """

   309

        Unload PLC library.

   310

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

   311

        """

   312

        self.PLClibraryLock.acquire()

   313

        try:

   314

            # Unload library explicitely

   315

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

   316

                dlclose(self._PLClibraryHandle)

   317

   318

            # Forget all refs to library

   319

            self._InitPLCStubCalls()

   320

   321

        finally:

   322

            self.PLClibraryLock.release()

   323

   324

        return False

   325

   326

    def PythonRuntimeCall(self, methodname):

   327

        """

   328

        Calls init, start, stop or cleanup method provided by

   329

        runtime python files, loaded when new PLC uploaded

   330

        """

   331

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

   332

            _res, exp = self.evaluator(method)

   333

            if exp is not None:

   334

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

   335

   336

    # used internaly

   337

    def PythonRuntimeInit(self):

   338

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

   339

        self.python_runtime_vars = globals().copy()

   340

        self.python_runtime_vars.update(self.pyruntimevars)

   341

        parent = self

   342

   343

        class PLCSafeGlobals(object):

   344

            def __getattr__(self, name):

   345

                try:

   346

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

   347

                except KeyError:

   348

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

   349

                v = t()

   350

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

   351

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

   352

   353

            def __setattr__(self, name, value):

   354

                try:

   355

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

   356

                except KeyError:

   357

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

   358

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

   359

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

   360

   361

        self.python_runtime_vars.update({

   362

            "PLCGlobals":     PLCSafeGlobals(),

   363

            "WorkingDir":     self.workingdir,

   364

            "PLCObject":      self,

   365

            "PLCBinary":      self.PLClibraryHandle,

   366

            "PLCGlobalsDesc": []})

   367

   368

        for methodname in MethodNames:

   369

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

   370

   371

        try:

   372

            filenames = os.listdir(self.workingdir)

   373

            filenames.sort()

   374

            for filename in filenames:

   375

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

   376

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

   377

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

   378

                    for methodname in MethodNames:

   379

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

   380

                        if method is not None:

   381

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

   382

        except Exception:

   383

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

   384

            raise

   385

   386

        self.PythonRuntimeCall("init")

   387

   388

    # used internaly

   389

    def PythonRuntimeCleanup(self):

   390

        if self.python_runtime_vars is not None:

   391

            self.PythonRuntimeCall("cleanup")

   392

   393

        self.python_runtime_vars = None

   394

   395

    def PythonThreadProc(self):

   396

        self.StartSem.release()

   397

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

   398

        compile_cache = {}

   399

        while True:

   400

            cmd = self._PythonIterator(res, blkid)

   401

            FBID = blkid.value

   402

            if cmd is None:

   403

                break

   404

            try:

   405

                self.python_runtime_vars["FBID"] = FBID

   406

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

   407

                if ccmd is None or ccmd != cmd:

   408

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

   409

                    compile_cache[FBID] = (cmd, AST)

   410

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

   411

                if exp is not None:

   412

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

   413

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

   414

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

   415

                else:

   416

                    res = str(result)

   417

                self.python_runtime_vars["FBID"] = None

   418

            except Exception as e:

   419

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

   420

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

   421

   422

    @RunInMain

   423

    def StartPLC(self):

   424

        if self.CurrentPLCFilename is not None and self.PLCStatus == PlcStatus.Stopped:

   425

            c_argv = ctypes.c_char_p * len(self.argv)

   426

            res = self._startPLC(len(self.argv), c_argv(*self.argv))

   427

            if res == 0:

   428

                self.PLCStatus = PlcStatus.Started

   429

                self.StatusChange()

   430

                self.PythonRuntimeCall("start")

   431

                self.StartSem = Semaphore(0)

   432

                self.PythonThread = Thread(target=self.PythonThreadProc)

   433

                self.PythonThread.start()

   434

                self.StartSem.acquire()

   435

                self.LogMessage("PLC started")

   436

            else:

   437

                self.LogMessage(0, _("Problem starting PLC : error %d" % res))

   438

                self.PLCStatus = PlcStatus.Broken

   439

                self.StatusChange()

   440

   441

    @RunInMain

   442

    def StopPLC(self):

   443

        if self.PLCStatus == PlcStatus.Started:

   444

            self.LogMessage("PLC stopped")

   445

            self._stopPLC()

   446

            self.PythonThread.join()

   447

            self.PLCStatus = PlcStatus.Stopped

   448

            self.StatusChange()

   449

            self.PythonRuntimeCall("stop")

   450

            if self.TraceThread is not None:

   451

                self.TraceThread.join()

   452

                self.TraceThread = None

   453

            return True

   454

        return False

   455

   456

    @RunInMain

   457

    def GetPLCstatus(self):

   458

        return self.PLCStatus, map(self.GetLogCount, xrange(LogLevelsCount))

   459

   460

    @RunInMain

   461

    def GetPLCID(self):

   462

        return getPSKID()

   463

   464

    def _init_blobs(self):

   465

        self.blobs = {}

   466

        if os.path.exists(self.tmpdir):

   467

            shutil.rmtree(self.tmpdir)

   468

        os.mkdir(self.tmpdir)

   469

   470

    @RunInMain

   471

    def AppendChunkToBlob(self, data, blobID):

   472

        blob = ((mkstemp(dir=self.tmpdir) if data else None)\

   473

                   + (md5.new(),)) \

   474

               if blobID == empty_md5_digest \

   475

               else self.blobs.pop(blobID, None)

   476

   477

        if blob is None:

   478

            return None