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

import shutil

    32

from time import time

    33

import hashlib

    34

from tempfile import mkstemp

    35

from functools import wraps, partial

    36

from six.moves import xrange

    37

from past.builtins import execfile

    38

import _ctypes

    39

    40

from runtime.typemapping import TypeTranslator

    41

from runtime.loglevels import LogLevelsDefault, LogLevelsCount

    42

from runtime.Stunnel import getPSKID

    43

from runtime import PlcStatus

    44

from runtime import MainWorker

    45

    46

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

    47

    dlopen = _ctypes.LoadLibrary

    48

    dlclose = _ctypes.FreeLibrary

    49

elif os.name == "posix":

    50

    dlopen = _ctypes.dlopen

    51

    dlclose = _ctypes.dlclose

    52

    53

    54

def get_last_traceback(tb):

    55

    while tb.tb_next:

    56

        tb = tb.tb_next

    57

    return tb

    58

    59

    60

lib_ext = {

    61

    "linux2": ".so",

    62

    "win32":  ".dll",

    63

}.get(sys.platform, "")

    64

    65

    66

def PLCprint(message):

    67

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

    68

    sys.stdout.flush()

    69

    70

    71

def RunInMain(func):

    72

    @wraps(func)

    73

    def func_wrapper(*args, **kwargs):

    74

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

    75

    return func_wrapper

    76

    77

    78

class PLCObject(object):

    79

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

    80

        self.workingdir = WorkingDir  # must exits already

    81

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

    82

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

    83

            shutil.rmtree(self.tmpdir)

    84

        os.mkdir(self.tmpdir)

    85

        # FIXME : is argv of any use nowadays ?

    86

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

    87

        self.statuschange = statuschange

    88

        self.evaluator = evaluator

    89

        self.pyruntimevars = pyruntimevars

    90

        self.PLCStatus = PlcStatus.Empty

    91

        self.PLClibraryHandle = None

    92

        self.PLClibraryLock = Lock()

    93

        # Creates fake C funcs proxies

    94

        self._InitPLCStubCalls()

    95

        self._loading_error = None

    96

        self.python_runtime_vars = None

    97

        self.TraceThread = None

    98

        self.TraceLock = Lock()

    99

        self.Traces = []

   100

        self.DebugToken = 0

   101

   102

        self._init_blobs()

   103

   104

    # First task of worker -> no @RunInMain

   105

    def AutoLoad(self, autostart):

   106

        # Get the last transfered PLC

   107

        try:

   108

            self.CurrentPLCFilename = open(

   109

                self._GetMD5FileName(),

   110

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

   111

            if self.LoadPLC():

   112

                self.PLCStatus = PlcStatus.Stopped

   113

                if autostart:

   114

                    self.StartPLC()

   115

                    return

   116

        except Exception:

   117

            self.PLCStatus = PlcStatus.Empty

   118

            self.CurrentPLCFilename = None

   119

   120

        self.StatusChange()

   121

   122

    def StatusChange(self):

   123

        if self.statuschange is not None:

   124

            for callee in self.statuschange:

   125

                callee(self.PLCStatus)

   126

   127

    @RunInMain

   128

    def LogMessage(self, *args):

   129

        if len(args) == 2:

   130

            level, msg = args

   131

        else:

   132

            level = LogLevelsDefault

   133

            msg, = args

   134

        PLCprint(msg)

   135

        if self._LogMessage is not None:

   136

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

   137

        return None

   138

   139

    @RunInMain

   140

    def ResetLogCount(self):

   141

        if self._ResetLogCount is not None:

   142

            self._ResetLogCount()

   143

   144

    # used internaly

   145

    def GetLogCount(self, level):

   146

        if self._GetLogCount is not None:

   147

            return int(self._GetLogCount(level))

   148

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

   149

            return 1

   150

   151

    @RunInMain

   152

    def GetLogMessage(self, level, msgid):

   153

        tick = ctypes.c_uint32()

   154

        tv_sec = ctypes.c_uint32()

   155

        tv_nsec = ctypes.c_uint32()

   156

        if self._GetLogMessage is not None:

   157

            maxsz = len(self._log_read_buffer)-1

   158

            sz = self._GetLogMessage(level, msgid,

   159

                                     self._log_read_buffer, maxsz,

   160

                                     ctypes.byref(tick),

   161

                                     ctypes.byref(tv_sec),

   162

                                     ctypes.byref(tv_nsec))

   163

            if sz and sz <= maxsz:

   164

                self._log_read_buffer[sz] = '\x00'

   165

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

   166

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

   167

            return self._loading_error, 0, 0, 0

   168

        return None

   169

   170

    def _GetMD5FileName(self):

   171

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

   172

   173

    def _GetLibFileName(self):

   174

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

   175

   176

    def _LoadPLC(self):

   177

        """

   178

        Load PLC library

   179

        Declare all functions, arguments and return values

   180

        """

   181

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

   182

        self.PLClibraryLock.acquire()

   183

        try:

   184

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

   185

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

   186

   187

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

   188

            if len(md5) == 32:

   189

                self.PLC_ID.value = md5

   190

   191

            self._startPLC = self.PLClibraryHandle.startPLC

   192

            self._startPLC.restype = ctypes.c_int

   193

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

   194

   195

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   196

            self._stopPLC_real.restype = None

   197

   198

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

   199

            if self._PythonIterator is not None:

   200

                self._PythonIterator.restype = ctypes.c_char_p

   201

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

   202

   203

                self._stopPLC = self._stopPLC_real

   204

            else:

   205

                # If python confnode is not enabled, we reuse _PythonIterator

   206

                # as a call that block pythonthread until StopPLC

   207

                self.PlcStopping = Event()

   208

   209

                def PythonIterator(res, blkid):

   210

                    self.PlcStopping.clear()

   211

                    self.PlcStopping.wait()

   212

                    return None

   213

                self._PythonIterator = PythonIterator

   214

   215

                def __StopPLC():

   216

                    self._stopPLC_real()

   217

                    self.PlcStopping.set()

   218

                self._stopPLC = __StopPLC

   219

   220

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   221

            self._ResetDebugVariables.restype = None

   222

   223

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   224

            self._RegisterDebugVariable.restype = None

   225

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

   226

   227

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   228

            self._FreeDebugData.restype = None

   229

   230

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   231

            self._GetDebugData.restype = ctypes.c_int

   232

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

   233

   234

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   235

            self._suspendDebug.restype = ctypes.c_int

   236

            self._suspendDebug.argtypes = [ctypes.c_int]

   237

   238

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   239

            self._resumeDebug.restype = None

   240

   241

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   242

            self._ResetLogCount.restype = None

   243

   244

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   245

            self._GetLogCount.restype = ctypes.c_uint32

   246

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   247

   248

            self._LogMessage = self.PLClibraryHandle.LogMessage

   249

            self._LogMessage.restype = ctypes.c_int

   250

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

   251

   252

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

   253

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   254

            self._GetLogMessage.restype = ctypes.c_uint32

   255

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

   256

   257

            self._loading_error = None

   258

   259

        except Exception:

   260

            self._loading_error = traceback.format_exc()

   261

            PLCprint(self._loading_error)

   262

            return False

   263

        finally:

   264

            self.PLClibraryLock.release()

   265

   266

        return True

   267

   268

    @RunInMain

   269

    def LoadPLC(self):

   270

        res = self._LoadPLC()

   271

        if res:

   272

            self.PythonRuntimeInit()

   273

        else:

   274

            self._FreePLC()

   275

   276

        return res

   277

   278

    @RunInMain

   279

    def UnLoadPLC(self):

   280

        self.PythonRuntimeCleanup()

   281

        self._FreePLC()

   282

   283

    def _InitPLCStubCalls(self):

   284

        """

   285

        create dummy C func proxies

   286

        """

   287

        self._startPLC = lambda x, y: None

   288

        self._stopPLC = lambda: None

   289

        self._ResetDebugVariables = lambda: None

   290

        self._RegisterDebugVariable = lambda x, y: None

   291

        self._IterDebugData = lambda x, y: None

   292

        self._FreeDebugData = lambda: None

   293

        self._GetDebugData = lambda: -1

   294

        self._suspendDebug = lambda x: -1

   295

        self._resumeDebug = lambda: None

   296

        self._PythonIterator = lambda: ""

   297

        self._GetLogCount = None

   298

        self._LogMessage = None

   299

        self._GetLogMessage = None

   300

        self._PLClibraryHandle = None

   301

        self.PLClibraryHandle = None

   302

   303

    def _FreePLC(self):

   304

        """

   305

        Unload PLC library.

   306

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

   307

        """

   308

        self.PLClibraryLock.acquire()

   309

        try:

   310

            # Unload library explicitely

   311

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

   312

                dlclose(self._PLClibraryHandle)

   313

   314

            # Forget all refs to library

   315

            self._InitPLCStubCalls()

   316

   317

        finally:

   318

            self.PLClibraryLock.release()

   319

   320

        return False

   321

   322

    def PythonRuntimeCall(self, methodname):

   323

        """

   324

        Calls init, start, stop or cleanup method provided by

   325

        runtime python files, loaded when new PLC uploaded

   326

        """

   327

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

   328

            _res, exp = self.evaluator(method)

   329

            if exp is not None:

   330

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

   331

   332

    # used internaly

   333

    def PythonRuntimeInit(self):

   334

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

   335

        self.python_runtime_vars = globals().copy()

   336

        self.python_runtime_vars.update(self.pyruntimevars)

   337

        parent = self

   338

   339

        class PLCSafeGlobals(object):

   340

            def __getattr__(self, name):

   341

                try:

   342

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

   343

                except KeyError:

   344

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

   345

                v = t()

   346

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

   347

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

   348

   349

            def __setattr__(self, name, value):

   350

                try:

   351

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

   352

                except KeyError:

   353

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

   354

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

   355

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

   356

   357

        self.python_runtime_vars.update({

   358

            "PLCGlobals":     PLCSafeGlobals(),

   359

            "WorkingDir":     self.workingdir,

   360

            "PLCObject":      self,

   361

            "PLCBinary":      self.PLClibraryHandle,

   362

            "PLCGlobalsDesc": []})

   363

   364

        for methodname in MethodNames:

   365

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

   366

   367

        try:

   368

            filenames = os.listdir(self.workingdir)

   369

            filenames.sort()

   370

            for filename in filenames:

   371

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

   372

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

   373

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

   374

                    for methodname in MethodNames:

   375

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

   376

                        if method is not None:

   377

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

   378

        except Exception:

   379

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

   380

            raise

   381

   382

        self.PythonRuntimeCall("init")

   383

   384

    # used internaly

   385

    def PythonRuntimeCleanup(self):

   386

        if self.python_runtime_vars is not None:

   387

            self.PythonRuntimeCall("cleanup")

   388

   389

        self.python_runtime_vars = None

   390

   391

    def PythonThreadProc(self):

   392

        self.StartSem.release()

   393

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

   394

        compile_cache = {}

   395

        while True:

   396

            cmd = self._PythonIterator(res, blkid)

   397

            FBID = blkid.value

   398

            if cmd is None:

   399

                break

   400

            try:

   401

                self.python_runtime_vars["FBID"] = FBID

   402

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

   403

                if ccmd is None or ccmd != cmd:

   404

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

   405

                    compile_cache[FBID] = (cmd, AST)

   406

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

   407

                if exp is not None:

   408

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

   409

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

   410

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

   411

                else:

   412

                    res = str(result)

   413

                self.python_runtime_vars["FBID"] = None

   414

            except Exception as e:

   415

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

   416

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

   417

   418

    @RunInMain

   419

    def StartPLC(self):

   420

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

   421

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

   422

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

   423

            if res == 0:

   424

                self.PLCStatus = PlcStatus.Started

   425

                self.StatusChange()

   426

                self.PythonRuntimeCall("start")

   427

                self.StartSem = Semaphore(0)

   428

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

   429

                self.PythonThread.start()

   430

                self.StartSem.acquire()

   431

                self.LogMessage("PLC started")

   432

            else:

   433

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

   434

                self.PLCStatus = PlcStatus.Broken

   435

                self.StatusChange()

   436

   437

    @RunInMain

   438

    def StopPLC(self):

   439

        if self.PLCStatus == PlcStatus.Started:

   440

            self.LogMessage("PLC stopped")

   441

            self._stopPLC()

   442

            self.PythonThread.join()

   443

            self.PLCStatus = PlcStatus.Stopped

   444

            self.StatusChange()

   445

            self.PythonRuntimeCall("stop")

   446

            if self.TraceThread is not None:

   447

                self.TraceThread.join()

   448

                self.TraceThread = None

   449

            return True

   450

        return False

   451

   452

    @RunInMain

   453

    def GetPLCstatus(self):

   454

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

   455

   456

    @RunInMain

   457

    def GetPLCID(self):

   458

        return getPSKID(partial(self.LogMessage, 0))

   459

   460

    def _init_blobs(self):

   461

        self.blobs = {}

   462

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

   463

            shutil.rmtree(self.tmpdir)

   464

        os.mkdir(self.tmpdir)

   465

   466

    @RunInMain

   467

    def SeedBlob(self, seed):

   468

        blob = (mkstemp(dir=self.tmpdir) + (hashlib.new('md5'),))

   469

        _fobj, _path, md5sum = blob

   470

        md5sum.update(seed)

   471

        newBlobID = md5sum.digest()

   472

        self.blobs[newBlobID] = blob

   473

        return newBlobID

   474

   475

    @RunInMain

   476

    def AppendChunkToBlob(self, data, blobID):

   477

        blob = self.blobs.pop(blobID, None)