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

    40

    41

from runtime.typemapping import TypeTranslator

    42

from runtime.loglevels import LogLevelsDefault, LogLevelsCount

    43

from runtime.Stunnel import getPSKID

    44

from runtime import PlcStatus

    45

from runtime import MainWorker

    46

    47

empty_md5_digest = md5.new().digest()

    48

    49

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

    50

    dlopen = _ctypes.LoadLibrary

    51

    dlclose = _ctypes.FreeLibrary

    52

elif os.name == "posix":

    53

    dlopen = _ctypes.dlopen

    54

    dlclose = _ctypes.dlclose

    55

    56

    57

def get_last_traceback(tb):

    58

    while tb.tb_next:

    59

        tb = tb.tb_next

    60

    return tb

    61

    62

    63

lib_ext = {

    64

    "linux2": ".so",

    65

    "win32":  ".dll",

    66

}.get(sys.platform, "")

    67

    68

    69

def PLCprint(message):

    70

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

    71

    sys.stdout.flush()

    72

    73

    74

def RunInMain(func):

    75

    def func_wrapper(*args, **kwargs):

    76

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

    77

    return func_wrapper

    78

    79

    80

class PLCObject(object):

    81

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

    82

        self.workingdir = WorkingDir # must exits already

    83

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

    84

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

    85

            shutil.rmtree(self.tmpdir)

    86

        os.mkdir(self.tmpdir)

    87

        # FIXME : is argv of any use nowadays ?

    88

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

    89

        self.statuschange = statuschange

    90

        self.evaluator = evaluator

    91

        self.pyruntimevars = pyruntimevars

    92

        self.PLCStatus = PlcStatus.Empty

    93

        self.PLClibraryHandle = None

    94

        self.PLClibraryLock = Lock()

    95

        # Creates fake C funcs proxies

    96

        self._InitPLCStubCalls()

    97

        self._loading_error = None

    98

        self.python_runtime_vars = None

    99

        self.TraceThread = None

   100

        self.TraceLock = Lock()

   101

        self.Traces = []

   102

   103

        self._init_blobs()

   104

   105

    # First task of worker -> no @RunInMain

   106

    def AutoLoad(self, autostart):

   107

        # Get the last transfered PLC

   108

        try:

   109

            self.CurrentPLCFilename = open(

   110

                self._GetMD5FileName(),

   111

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

   112

            if self.LoadPLC():

   113

                self.PLCStatus = PlcStatus.Stopped

   114

                if autostart:

   115

                    self.StartPLC()

   116

                    return

   117

        except Exception:

   118

            self.PLCStatus = PlcStatus.Empty

   119

            self.CurrentPLCFilename = None

   120

   121

        self.StatusChange()

   122

   123

    def StatusChange(self):

   124

        if self.statuschange is not None:

   125

            for callee in self.statuschange:

   126

                callee(self.PLCStatus)

   127

   128

    @RunInMain

   129

    def LogMessage(self, *args):

   130

        if len(args) == 2:

   131

            level, msg = args

   132

        else:

   133

            level = LogLevelsDefault

   134

            msg, = args

   135

        PLCprint(msg)

   136

        if self._LogMessage is not None:

   137

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

   138

        return None

   139

   140

    @RunInMain

   141

    def ResetLogCount(self):

   142

        if self._ResetLogCount is not None:

   143

            self._ResetLogCount()

   144

   145

    # used internaly

   146

    def GetLogCount(self, level):

   147

        if self._GetLogCount is not None:

   148

            return int(self._GetLogCount(level))

   149

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

   150

            return 1

   151

   152

    @RunInMain

   153

    def GetLogMessage(self, level, msgid):

   154

        tick = ctypes.c_uint32()

   155

        tv_sec = ctypes.c_uint32()

   156

        tv_nsec = ctypes.c_uint32()

   157

        if self._GetLogMessage is not None:

   158

            maxsz = len(self._log_read_buffer)-1

   159

            sz = self._GetLogMessage(level, msgid,

   160

                                     self._log_read_buffer, maxsz,

   161

                                     ctypes.byref(tick),

   162

                                     ctypes.byref(tv_sec),

   163

                                     ctypes.byref(tv_nsec))

   164

            if sz and sz <= maxsz:

   165

                self._log_read_buffer[sz] = '\x00'

   166

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

   167

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

   168

            return self._loading_error, 0, 0, 0

   169

        return None

   170

   171

    def _GetMD5FileName(self):

   172

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

   173

   174

    def _GetLibFileName(self):

   175

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

   176

   177

    def _LoadPLC(self):

   178

        """

   179

        Load PLC library

   180

        Declare all functions, arguments and return values

   181

        """

   182

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

   183

        self.PLClibraryLock.acquire()

   184

        try:

   185

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

   186

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

   187

   188

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

   189

            if len(md5) == 32:

   190

                self.PLC_ID.value = md5

   191

   192

            self._startPLC = self.PLClibraryHandle.startPLC

   193

            self._startPLC.restype = ctypes.c_int

   194

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

   195

   196

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   197

            self._stopPLC_real.restype = None

   198

   199

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

   200

            if self._PythonIterator is not None:

   201

                self._PythonIterator.restype = ctypes.c_char_p

   202

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

   203

   204

                self._stopPLC = self._stopPLC_real

   205

            else:

   206

                # If python confnode is not enabled, we reuse _PythonIterator

   207

                # as a call that block pythonthread until StopPLC

   208

                self.PlcStopping = Event()

   209

   210

                def PythonIterator(res, blkid):

   211

                    self.PlcStopping.clear()

   212

                    self.PlcStopping.wait()

   213

                    return None

   214

                self._PythonIterator = PythonIterator

   215

   216

                def __StopPLC():

   217

                    self._stopPLC_real()

   218

                    self.PlcStopping.set()

   219

                self._stopPLC = __StopPLC

   220

   221

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   222

            self._ResetDebugVariables.restype = None

   223

   224

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   225

            self._RegisterDebugVariable.restype = None

   226

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

   227

   228

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   229

            self._FreeDebugData.restype = None

   230

   231

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   232

            self._GetDebugData.restype = ctypes.c_int

   233

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

   234

   235

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   236

            self._suspendDebug.restype = ctypes.c_int

   237

            self._suspendDebug.argtypes = [ctypes.c_int]

   238

   239

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   240

            self._resumeDebug.restype = None

   241

   242

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   243

            self._ResetLogCount.restype = None

   244

   245

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   246

            self._GetLogCount.restype = ctypes.c_uint32

   247

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   248

   249

            self._LogMessage = self.PLClibraryHandle.LogMessage

   250

            self._LogMessage.restype = ctypes.c_int

   251

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

   252

   253

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

   254

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   255

            self._GetLogMessage.restype = ctypes.c_uint32

   256

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

   257

   258

            self._loading_error = None

   259

   260

        except Exception:

   261

            self._loading_error = traceback.format_exc()

   262

            PLCprint(self._loading_error)

   263

            return False

   264

        finally:

   265

            self.PLClibraryLock.release()

   266

   267

        return True

   268

   269

    @RunInMain

   270

    def LoadPLC(self):

   271

        res = self._LoadPLC()

   272

        if res:

   273

            self.PythonRuntimeInit()

   274

        else:

   275

            self._FreePLC()

   276

   277

        return res

   278

   279

    @RunInMain

   280

    def UnLoadPLC(self):

   281

        self.PythonRuntimeCleanup()

   282

        self._FreePLC()

   283

   284

    def _InitPLCStubCalls(self):

   285

        """

   286

        create dummy C func proxies

   287

        """

   288

        self._startPLC = lambda x, y: None

   289

        self._stopPLC = lambda: None

   290

        self._ResetDebugVariables = lambda: None

   291

        self._RegisterDebugVariable = lambda x, y: None

   292

        self._IterDebugData = lambda x, y: None

   293

        self._FreeDebugData = lambda: None

   294

        self._GetDebugData = lambda: -1

   295

        self._suspendDebug = lambda x: -1

   296

        self._resumeDebug = lambda: None

   297

        self._PythonIterator = lambda: ""

   298

        self._GetLogCount = None

   299

        self._LogMessage = None

   300

        self._GetLogMessage = None

   301

        self._PLClibraryHandle = None

   302

        self.PLClibraryHandle = None

   303

   304

    def _FreePLC(self):

   305

        """

   306

        Unload PLC library.

   307

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

   308

        """

   309

        self.PLClibraryLock.acquire()

   310

        try:

   311

            # Unload library explicitely

   312

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

   313

                dlclose(self._PLClibraryHandle)

   314

   315

            # Forget all refs to library

   316

            self._InitPLCStubCalls()

   317

   318

        finally:

   319

            self.PLClibraryLock.release()

   320

   321

        return False

   322

   323

    def PythonRuntimeCall(self, methodname):

   324

        """

   325

        Calls init, start, stop or cleanup method provided by

   326

        runtime python files, loaded when new PLC uploaded

   327

        """

   328

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

   329

            _res, exp = self.evaluator(method)

   330

            if exp is not None:

   331

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

   332

   333

    # used internaly

   334

    def PythonRuntimeInit(self):

   335

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

   336

        self.python_runtime_vars = globals().copy()

   337

        self.python_runtime_vars.update(self.pyruntimevars)

   338

        parent = self

   339

   340

        class PLCSafeGlobals(object):

   341

            def __getattr__(self, name):

   342

                try:

   343

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

   344

                except KeyError:

   345

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

   346

                v = t()

   347

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

   348

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

   349

   350

            def __setattr__(self, name, value):

   351

                try:

   352

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

   353

                except KeyError:

   354

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

   355

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

   356

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

   357

   358

        self.python_runtime_vars.update({

   359

            "PLCGlobals":     PLCSafeGlobals(),

   360

            "WorkingDir":     self.workingdir,

   361

            "PLCObject":      self,

   362

            "PLCBinary":      self.PLClibraryHandle,

   363

            "PLCGlobalsDesc": []})

   364

   365

        for methodname in MethodNames:

   366

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

   367

   368

        try:

   369

            filenames = os.listdir(self.workingdir)

   370

            filenames.sort()

   371

            for filename in filenames:

   372

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

   373

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

   374

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

   375

                    for methodname in MethodNames:

   376

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

   377

                        if method is not None:

   378

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

   379

        except Exception:

   380

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

   381

            raise

   382

   383

        self.PythonRuntimeCall("init")

   384

   385

    # used internaly

   386

    def PythonRuntimeCleanup(self):

   387

        if self.python_runtime_vars is not None:

   388

            self.PythonRuntimeCall("cleanup")

   389

   390

        self.python_runtime_vars = None

   391

   392

    def PythonThreadProc(self):

   393

        self.StartSem.release()

   394

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

   395

        compile_cache = {}

   396

        while True:

   397

            cmd = self._PythonIterator(res, blkid)

   398

            FBID = blkid.value

   399

            if cmd is None:

   400

                break

   401

            try:

   402

                self.python_runtime_vars["FBID"] = FBID

   403

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

   404

                if ccmd is None or ccmd != cmd:

   405

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

   406

                    compile_cache[FBID] = (cmd, AST)

   407

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

   408

                if exp is not None:

   409

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

   410

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

   411

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

   412

                else:

   413

                    res = str(result)

   414

                self.python_runtime_vars["FBID"] = None

   415

            except Exception as e:

   416

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

   417

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

   418

   419

    @RunInMain

   420

    def StartPLC(self):

   421

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

   422

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

   423

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

   424

            if res == 0:

   425

                self.PLCStatus = PlcStatus.Started

   426

                self.StatusChange()

   427

                self.PythonRuntimeCall("start")

   428

                self.StartSem = Semaphore(0)

   429

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

   430

                self.PythonThread.start()

   431

                self.StartSem.acquire()

   432

                self.LogMessage("PLC started")

   433

            else:

   434

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

   435

                self.PLCStatus = PlcStatus.Broken

   436

                self.StatusChange()

   437

   438

    @RunInMain

   439

    def StopPLC(self):

   440

        if self.PLCStatus == PlcStatus.Started:

   441

            self.LogMessage("PLC stopped")

   442

            self._stopPLC()

   443

            self.PythonThread.join()

   444

            self.PLCStatus = PlcStatus.Stopped

   445

            self.StatusChange()

   446

            self.PythonRuntimeCall("stop")

   447

            if self.TraceThread is not None:

   448

                self.TraceThread.join()

   449

                self.TraceThread = None

   450

            return True

   451

        return False

   452

   453

    @RunInMain

   454

    def GetPLCstatus(self):

   455

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

   456

   457

    @RunInMain

   458

    def GetPLCID(self):

   459

        return getPSKID()

   460

   461

    def _init_blobs(self):

   462

        self.blobs = {}

   463

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

   464

            shutil.rmtree(self.tmpdir)

   465

        os.mkdir(self.tmpdir)

   466

   467

    @RunInMain

   468

    def AppendChunkToBlob(self, data, blobID):

   469

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

   470

                   + (md5.new(),)) \

   471

               if blobID == empty_md5_digest \

   472

               else self.blobs.pop(blobID, None)

   473

   474

        if blob is None:

   475

            return None

   476

   477

        fobj, path, md5sum = blob

   478

        md5sum.update(data)