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 Timer, 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

import Pyro.core as pyro

    34

    35

from runtime.typemapping import TypeTranslator

    36

from runtime.loglevels import LogLevelsDefault, LogLevelsCount

    37

    38

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

    39

    dlopen = _ctypes.LoadLibrary

    40

    dlclose = _ctypes.FreeLibrary

    41

elif os.name == "posix":

    42

    dlopen = _ctypes.dlopen

    43

    dlclose = _ctypes.dlclose

    44

    45

    46

def get_last_traceback(tb):

    47

    while tb.tb_next:

    48

        tb = tb.tb_next

    49

    return tb

    50

    51

    52

lib_ext = {

    53

    "linux2": ".so",

    54

    "win32":  ".dll",

    55

}.get(sys.platform, "")

    56

    57

    58

def PLCprint(message):

    59

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

    60

    sys.stdout.flush()

    61

    62

    63

class PLCObject(pyro.ObjBase):

    64

    def __init__(self, workingdir, daemon, argv, statuschange, evaluator, pyruntimevars):

    65

        pyro.ObjBase.__init__(self)

    66

        self.evaluator = evaluator

    67

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

    68

        self.workingdir = workingdir

    69

        self.PLCStatus = "Empty"

    70

        self.PLClibraryHandle = None

    71

        self.PLClibraryLock = Lock()

    72

        self.DummyIteratorLock = None

    73

        # Creates fake C funcs proxies

    74

        self._FreePLC()

    75

        self.daemon = daemon

    76

        self.statuschange = statuschange

    77

        self.hmi_frame = None

    78

        self.pyruntimevars = pyruntimevars

    79

        self._loading_error = None

    80

        self.python_runtime_vars = None

    81

        self.TraceThread = None

    82

        self.TraceLock = Lock()

    83

        self.TraceWakeup = Event()

    84

        self.Traces = []

    85

    86

    def AutoLoad(self):

    87

        # Get the last transfered PLC if connector must be restart

    88

        try:

    89

            self.CurrentPLCFilename = open(

    90

                self._GetMD5FileName(),

    91

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

    92

            if self.LoadPLC():

    93

                self.PLCStatus = "Stopped"

    94

        except Exception:

    95

            self.PLCStatus = "Empty"

    96

            self.CurrentPLCFilename = None

    97

    98

    def StatusChange(self):

    99

        if self.statuschange is not None:

   100

            for callee in self.statuschange:

   101

                callee(self.PLCStatus)

   102

   103

    def LogMessage(self, *args):

   104

        if len(args) == 2:

   105

            level, msg = args

   106

        else:

   107

            level = LogLevelsDefault

   108

            msg, = args

   109

        PLCprint(msg)

   110

        if self._LogMessage is not None:

   111

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

   112

        return None

   113

   114

    def ResetLogCount(self):

   115

        if self._ResetLogCount is not None:

   116

            self._ResetLogCount()

   117

   118

    def GetLogCount(self, level):

   119

        if self._GetLogCount is not None:

   120

            return int(self._GetLogCount(level))

   121

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

   122

            return 1

   123

   124

    def GetLogMessage(self, level, msgid):

   125

        tick = ctypes.c_uint32()

   126

        tv_sec = ctypes.c_uint32()

   127

        tv_nsec = ctypes.c_uint32()

   128

        if self._GetLogMessage is not None:

   129

            maxsz = len(self._log_read_buffer)-1

   130

            sz = self._GetLogMessage(level, msgid,

   131

                                     self._log_read_buffer, maxsz,

   132

                                     ctypes.byref(tick),

   133

                                     ctypes.byref(tv_sec),

   134

                                     ctypes.byref(tv_nsec))

   135

            if sz and sz <= maxsz:

   136

                self._log_read_buffer[sz] = '\x00'

   137

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

   138

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

   139

            return self._loading_error, 0, 0, 0

   140

        return None

   141

   142

    def _GetMD5FileName(self):

   143

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

   144

   145

    def _GetLibFileName(self):

   146

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

   147

   148

    def LoadPLC(self):

   149

        """

   150

        Load PLC library

   151

        Declare all functions, arguments and return values

   152

        """

   153

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

   154

        try:

   155

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

   156

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

   157

   158

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

   159

            if len(md5) == 32:

   160

                self.PLC_ID.value = md5

   161

   162

            self._startPLC = self.PLClibraryHandle.startPLC

   163

            self._startPLC.restype = ctypes.c_int

   164

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

   165

   166

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   167

            self._stopPLC_real.restype = None

   168

   169

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

   170

            if self._PythonIterator is not None:

   171

                self._PythonIterator.restype = ctypes.c_char_p

   172

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

   173

   174

                self._stopPLC = self._stopPLC_real

   175

            else:

   176

                # If python confnode is not enabled, we reuse _PythonIterator

   177

                # as a call that block pythonthread until StopPLC

   178

                self.PlcStopping = Event()

   179

   180

                def PythonIterator(res, blkid):

   181

                    self.PlcStopping.clear()

   182

                    self.PlcStopping.wait()

   183

                    return None

   184

                self._PythonIterator = PythonIterator

   185

   186

                def __StopPLC():

   187

                    self._stopPLC_real()

   188

                    self.PlcStopping.set()

   189

                self._stopPLC = __StopPLC

   190

   191

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   192

            self._ResetDebugVariables.restype = None

   193

   194

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   195

            self._RegisterDebugVariable.restype = None

   196

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

   197

   198

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   199

            self._FreeDebugData.restype = None

   200

   201

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   202

            self._GetDebugData.restype = ctypes.c_int

   203

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

   204

   205

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   206

            self._suspendDebug.restype = ctypes.c_int

   207

            self._suspendDebug.argtypes = [ctypes.c_int]

   208

   209

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   210

            self._resumeDebug.restype = None

   211

   212

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   213

            self._ResetLogCount.restype = None

   214

   215

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   216

            self._GetLogCount.restype = ctypes.c_uint32

   217

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   218

   219

            self._LogMessage = self.PLClibraryHandle.LogMessage

   220

            self._LogMessage.restype = ctypes.c_int

   221

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

   222

   223

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

   224

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   225

            self._GetLogMessage.restype = ctypes.c_uint32

   226

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

   227

   228

            self._loading_error = None

   229

   230

            self.PythonRuntimeInit()

   231

   232

            return True

   233

        except Exception:

   234

            self._loading_error = traceback.format_exc()

   235

            PLCprint(self._loading_error)

   236

            return False

   237

   238

    def UnLoadPLC(self):

   239

        self.PythonRuntimeCleanup()

   240

        self._FreePLC()

   241

   242

    def _FreePLC(self):

   243

        """

   244

        Unload PLC library.

   245

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

   246

        """

   247

        self.PLClibraryLock.acquire()

   248

        # Forget all refs to library

   249

        self._startPLC = lambda x, y: None

   250

        self._stopPLC = lambda: None

   251

        self._ResetDebugVariables = lambda: None

   252

        self._RegisterDebugVariable = lambda x, y: None

   253

        self._IterDebugData = lambda x, y: None

   254

        self._FreeDebugData = lambda: None

   255

        self._GetDebugData = lambda: -1

   256

        self._suspendDebug = lambda x: -1

   257

        self._resumeDebug = lambda: None

   258

        self._PythonIterator = lambda: ""

   259

        self._GetLogCount = None

   260

        self._LogMessage = None

   261

        self._GetLogMessage = None

   262

        self.PLClibraryHandle = None

   263

        # Unload library explicitely

   264

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

   265

            dlclose(self._PLClibraryHandle)

   266

            self._PLClibraryHandle = None

   267

   268

        self.PLClibraryLock.release()

   269

        return False

   270

   271

    def PythonRuntimeCall(self, methodname):

   272

        """

   273

        Calls init, start, stop or cleanup method provided by

   274

        runtime python files, loaded when new PLC uploaded

   275

        """

   276

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

   277

            _res, exp = self.evaluator(method)

   278

            if exp is not None:

   279

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

   280

   281

    def PythonRuntimeInit(self):

   282

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

   283

        self.python_runtime_vars = globals().copy()

   284

        self.python_runtime_vars.update(self.pyruntimevars)

   285

        parent = self

   286

   287

        class PLCSafeGlobals(object):

   288

            def __getattr__(self, name):

   289

                try:

   290

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

   291

                except KeyError:

   292

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

   293

                v = t()

   294

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

   295

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

   296

   297

            def __setattr__(self, name, value):

   298

                try:

   299

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

   300

                except KeyError:

   301

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

   302

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

   303

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

   304

   305

        self.python_runtime_vars.update({

   306

            "PLCGlobals":     PLCSafeGlobals(),

   307

            "WorkingDir":     self.workingdir,

   308

            "PLCObject":      self,

   309

            "PLCBinary":      self.PLClibraryHandle,

   310

            "PLCGlobalsDesc": []})

   311

   312

        for methodname in MethodNames:

   313

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

   314

   315

        try:

   316

            filenames = os.listdir(self.workingdir)

   317

            filenames.sort()

   318

            for filename in filenames:

   319

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

   320

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

   321

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

   322

                    for methodname in MethodNames:

   323

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

   324

                        if method is not None:

   325

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

   326

        except Exception:

   327

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

   328

            raise

   329

   330

        self.PythonRuntimeCall("init")

   331

   332

    def PythonRuntimeCleanup(self):

   333

        if self.python_runtime_vars is not None:

   334

            self.PythonRuntimeCall("cleanup")

   335

   336

        self.python_runtime_vars = None

   337

   338

    def PythonThreadProc(self):

   339

        self.StartSem.release()

   340

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

   341

        compile_cache = {}

   342

        while True:

   343

            # print "_PythonIterator(", res, ")",

   344

            cmd = self._PythonIterator(res, blkid)

   345

            FBID = blkid.value

   346

            # print " -> ", cmd, blkid

   347

            if cmd is None:

   348

                break

   349

            try:

   350

                self.python_runtime_vars["FBID"] = FBID

   351

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

   352

                if ccmd is None or ccmd != cmd:

   353

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

   354

                    compile_cache[FBID] = (cmd, AST)

   355

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

   356

                if exp is not None:

   357

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

   358

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

   359

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

   360

                else:

   361

                    res = str(result)

   362

                self.python_runtime_vars["FBID"] = None

   363

            except Exception, e:

   364

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

   365

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

   366

   367

    def StartPLC(self):

   368

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

   369

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

   370

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

   371

            if res == 0:

   372

                self.PLCStatus = "Started"

   373

                self.StatusChange()

   374

                self.PythonRuntimeCall("start")

   375

                self.StartSem = Semaphore(0)

   376

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

   377

                self.PythonThread.start()

   378

                self.StartSem.acquire()

   379

                self.LogMessage("PLC started")

   380

            else:

   381

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

   382

                self.PLCStatus = "Broken"

   383

                self.StatusChange()

   384

   385

    def StopPLC(self):

   386

        if self.PLCStatus == "Started":

   387

            self.LogMessage("PLC stopped")

   388

            self._stopPLC()

   389

            self.PythonThread.join()

   390

            self.PLCStatus = "Stopped"

   391

            self.StatusChange()

   392

            self.PythonRuntimeCall("stop")

   393

            if self.TraceThread is not None:

   394

                self.TraceWakeup.set()

   395

                self.TraceThread.join()

   396

                self.TraceThread = None

   397

            return True

   398

        return False

   399

   400

    def _Reload(self):

   401

        self.daemon.shutdown(True)

   402

        self.daemon.sock.close()

   403

        os.execv(sys.executable, [sys.executable]+sys.argv[:])

   404

        # never reached

   405

        return 0

   406

   407

    def ForceReload(self):

   408

        # respawn python interpreter

   409

        Timer(0.1, self._Reload).start()

   410

        return True

   411

   412

    def GetPLCstatus(self):

   413

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

   414

   415

    def NewPLC(self, md5sum, data, extrafiles):

   416

        if self.PLCStatus in ["Stopped", "Empty", "Broken"]:

   417

            NewFileName = md5sum + lib_ext

   418

            extra_files_log = os.path.join(self.workingdir, "extra_files.txt")

   419

   420

            self.UnLoadPLC()

   421

   422

            self.LogMessage("NewPLC (%s)" % md5sum)

   423

            self.PLCStatus = "Empty"

   424

   425

            try:

   426

                os.remove(os.path.join(self.workingdir,

   427

                                       self.CurrentPLCFilename))

   428

                for filename in file(extra_files_log, "r").readlines() + [extra_files_log]:

   429

                    try:

   430

                        os.remove(os.path.join(self.workingdir, filename.strip()))

   431

                    except Exception:

   432

                        pass

   433

            except Exception:

   434

                pass

   435

   436

            try:

   437

                # Create new PLC file

   438

                open(os.path.join(self.workingdir, NewFileName),

   439

                     'wb').write(data)

   440

   441

                # Store new PLC filename based on md5 key

   442

                open(self._GetMD5FileName(), "w").write(md5sum)

   443

   444

                # Then write the files

   445

                log = file(extra_files_log, "w")

   446

                for fname, fdata in extrafiles:

   447

                    fpath = os.path.join(self.workingdir, fname)

   448

                    open(fpath, "wb").write(fdata)

   449

                    log.write(fname+'\n')

   450

   451

                # Store new PLC filename

   452

                self.CurrentPLCFilename = NewFileName

   453

            except Exception:

   454

                self.PLCStatus = "Broken"

   455

                self.StatusChange()

   456

                PLCprint(traceback.format_exc())

   457

                return False

   458

   459

            if self.LoadPLC():

   460

                self.PLCStatus = "Stopped"

   461

            else:

   462

                self.PLCStatus = "Broken"

   463

                self._FreePLC()

   464

            self.StatusChange()

   465

   466

            return self.PLCStatus == "Stopped"

   467

        return False

   468

   469

    def MatchMD5(self, MD5):

   470

        try:

   471

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

   472

            return last_md5 == MD5

   473

        except Exception:

   474

            pass

   475

        return False

   476

   477

    def SetTraceVariablesList(self, idxs):