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

    33

import Pyro.core as pyro

    34

    35

from runtime.typemapping import TypeTranslator

    36

from runtime.loglevels import LogLevelsDefault, LogLevelsCount

    37

    38

    39

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

    40

    from _ctypes import LoadLibrary as dlopen

    41

    from _ctypes import FreeLibrary as dlclose

    42

elif os.name == "posix":

    43

    from _ctypes import dlopen, 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

   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

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

   478

        """