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

import Pyro.core as pyro

    25

from threading import Timer, Thread, Lock, Semaphore, Event

    26

import ctypes

    27

import os

    28

import commands

    29

import types

    30

import sys

    31

import traceback

    32

from targets.typemapping import LogLevelsDefault, LogLevelsCount, TypeTranslator, UnpackDebugBuffer

    33

from time import time

    34

    35

    36

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

    37

    from _ctypes import LoadLibrary as dlopen

    38

    from _ctypes import FreeLibrary as dlclose

    39

elif os.name == "posix":

    40

    from _ctypes import dlopen, dlclose

    41

    42

    43

def get_last_traceback(tb):

    44

    while tb.tb_next:

    45

        tb = tb.tb_next

    46

    return tb

    47

    48

    49

lib_ext = {

    50

     "linux2": ".so",

    51

     "win32":  ".dll",

    52

     }.get(sys.platform, "")

    53

    54

    55

def PLCprint(message):

    56

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

    57

    sys.stdout.flush()

    58

    59

    60

class PLCObject(pyro.ObjBase):

    61

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

    62

        pyro.ObjBase.__init__(self)

    63

        self.evaluator = evaluator

    64

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

    65

        self.workingdir = workingdir

    66

        self.PLCStatus = "Empty"

    67

        self.PLClibraryHandle = None

    68

        self.PLClibraryLock = Lock()

    69

        self.DummyIteratorLock = None

    70

        # Creates fake C funcs proxies

    71

        self._FreePLC()

    72

        self.daemon = daemon

    73

        self.statuschange = statuschange

    74

        self.hmi_frame = None

    75

        self.pyruntimevars = pyruntimevars

    76

        self._loading_error = None

    77

        self.python_runtime_vars = None

    78

        self.TraceThread = None

    79

        self.TraceLock = Lock()

    80

        self.TraceWakeup = Event()

    81

        self.Traces = []

    82

    83

    def AutoLoad(self):

    84

        # Get the last transfered PLC if connector must be restart

    85

        try:

    86

            self.CurrentPLCFilename = open(

    87

                             self._GetMD5FileName(),

    88

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

    89

            if self.LoadPLC():

    90

                self.PLCStatus = "Stopped"

    91

        except Exception, e:

    92

            self.PLCStatus = "Empty"

    93

            self.CurrentPLCFilename = None

    94

    95

    def StatusChange(self):

    96

        if self.statuschange is not None:

    97

            for callee in self.statuschange:

    98

                callee(self.PLCStatus)

    99

   100

    def LogMessage(self, *args):

   101

        if len(args) == 2:

   102

            level, msg = args

   103

        else:

   104

            level = LogLevelsDefault

   105

            msg, = args

   106

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

   107

   108

    def ResetLogCount(self):

   109

        if self._ResetLogCount is not None:

   110

            self._ResetLogCount()

   111

   112

    def GetLogCount(self, level):

   113

        if self._GetLogCount is not None:

   114

            return int(self._GetLogCount(level))

   115

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

   116

            return 1

   117

   118

    def GetLogMessage(self, level, msgid):

   119

        tick = ctypes.c_uint32()

   120

        tv_sec = ctypes.c_uint32()

   121

        tv_nsec = ctypes.c_uint32()

   122

        if self._GetLogMessage is not None:

   123

            maxsz = len(self._log_read_buffer)-1

   124

            sz = self._GetLogMessage(level, msgid,

   125

                                     self._log_read_buffer, maxsz,

   126

                                     ctypes.byref(tick),

   127

                                     ctypes.byref(tv_sec),

   128

                                     ctypes.byref(tv_nsec))

   129

            if sz and sz <= maxsz:

   130

                self._log_read_buffer[sz] = '\x00'

   131

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

   132

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

   133

            return self._loading_error, 0, 0, 0

   134

        return None

   135

   136

    def _GetMD5FileName(self):

   137

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

   138

   139

    def _GetLibFileName(self):

   140

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

   141

   142

    def LoadPLC(self):

   143

        """

   144

        Load PLC library

   145

        Declare all functions, arguments and return values

   146

        """

   147

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

   148

        try:

   149

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

   150

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

   151

   152

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

   153

            if len(md5) == 32:

   154

                self.PLC_ID.value = md5

   155

   156

            self._startPLC = self.PLClibraryHandle.startPLC

   157

            self._startPLC.restype = ctypes.c_int

   158

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

   159

   160

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   161

            self._stopPLC_real.restype = None

   162

   163

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

   164

            if self._PythonIterator is not None:

   165

                self._PythonIterator.restype = ctypes.c_char_p

   166

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

   167

   168

                self._stopPLC = self._stopPLC_real

   169

            else:

   170

                # If python confnode is not enabled, we reuse _PythonIterator

   171

                # as a call that block pythonthread until StopPLC

   172

                self.PlcStopping = Event()

   173

   174

                def PythonIterator(res, blkid):

   175

                    self.PlcStopping.clear()

   176

                    self.PlcStopping.wait()

   177

                    return None

   178

                self._PythonIterator = PythonIterator

   179

   180

                def __StopPLC():

   181

                    self._stopPLC_real()

   182

                    self.PlcStopping.set()

   183

                self._stopPLC = __StopPLC

   184

   185

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   186

            self._ResetDebugVariables.restype = None

   187

   188

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   189

            self._RegisterDebugVariable.restype = None

   190

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

   191

   192

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   193

            self._FreeDebugData.restype = None

   194

   195

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   196

            self._GetDebugData.restype = ctypes.c_int

   197

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

   198

   199

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   200

            self._suspendDebug.restype = ctypes.c_int

   201

            self._suspendDebug.argtypes = [ctypes.c_int]

   202

   203

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   204

            self._resumeDebug.restype = None

   205

   206

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   207

            self._ResetLogCount.restype = None

   208

   209

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   210

            self._GetLogCount.restype = ctypes.c_uint32

   211

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   212

   213

            self._LogMessage = self.PLClibraryHandle.LogMessage

   214

            self._LogMessage.restype = ctypes.c_int

   215

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

   216

   217

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

   218

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   219

            self._GetLogMessage.restype = ctypes.c_uint32

   220

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

   221

   222

            self._loading_error = None

   223

   224

            self.PythonRuntimeInit()

   225

   226

            return True

   227

        except Exception:

   228

            self._loading_error = traceback.format_exc()

   229

            PLCprint(self._loading_error)

   230

            return False

   231

   232

    def UnLoadPLC(self):

   233

        self.PythonRuntimeCleanup()

   234

        self._FreePLC()

   235

   236

    def _FreePLC(self):

   237

        """

   238

        Unload PLC library.

   239

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

   240

        """

   241

        self.PLClibraryLock.acquire()

   242

        # Forget all refs to library

   243

        self._startPLC = lambda x, y: None

   244

        self._stopPLC = lambda: None

   245

        self._ResetDebugVariables = lambda: None

   246

        self._RegisterDebugVariable = lambda x, y: None

   247

        self._IterDebugData = lambda x, y: None

   248

        self._FreeDebugData = lambda: None

   249

        self._GetDebugData = lambda: -1

   250

        self._suspendDebug = lambda x: -1

   251

        self._resumeDebug = lambda: None

   252

        self._PythonIterator = lambda: ""

   253

        self._GetLogCount = None

   254

        self._LogMessage = lambda l, m, s: PLCprint("OFF LOG :"+m)

   255

        self._GetLogMessage = None

   256

        self.PLClibraryHandle = None

   257

        # Unload library explicitely

   258

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

   259

            dlclose(self._PLClibraryHandle)

   260

            self._PLClibraryHandle = None

   261

   262

        self.PLClibraryLock.release()

   263

        return False

   264

   265

    def PythonRuntimeCall(self, methodname):

   266

        """

   267

        Calls init, start, stop or cleanup method provided by

   268

        runtime python files, loaded when new PLC uploaded

   269

        """

   270

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

   271

            res, exp = self.evaluator(method)

   272

            if exp is not None:

   273

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

   274

   275

    def PythonRuntimeInit(self):

   276

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

   277

        self.python_runtime_vars = globals().copy()

   278

        self.python_runtime_vars.update(self.pyruntimevars)

   279

   280

        class PLCSafeGlobals:

   281

            def __getattr__(_self, name):

   282

                try:

   283

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

   284

                except KeyError:

   285

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

   286

                v = t()

   287

                r = self.python_runtime_vars["_PySafeGetPLCGlob_"+name](ctypes.byref(v))

   288

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

   289

   290

            def __setattr__(_self, name, value):

   291

                try:

   292

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

   293

                except KeyError:

   294

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

   295

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

   296

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

   297

   298

        self.python_runtime_vars.update({

   299

            "PLCGlobals":     PLCSafeGlobals(),

   300

            "WorkingDir":     self.workingdir,

   301

            "PLCObject":      self,

   302

            "PLCBinary":      self.PLClibraryHandle,

   303

            "PLCGlobalsDesc": []})

   304

   305

        for methodname in MethodNames:

   306

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

   307

   308

        try:

   309

            filenames = os.listdir(self.workingdir)

   310

            filenames.sort()

   311

            for filename in filenames:

   312

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

   313

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

   314

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

   315

                    for methodname in MethodNames:

   316

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

   317

                        if method is not None:

   318

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

   319

        except Exception:

   320

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

   321

            raise

   322

   323

        self.PythonRuntimeCall("init")

   324

   325

    def PythonRuntimeCleanup(self):

   326

        if self.python_runtime_vars is not None:

   327

            self.PythonRuntimeCall("cleanup")

   328

   329

        self.python_runtime_vars = None

   330

   331

    def PythonThreadProc(self):

   332

        self.StartSem.release()

   333

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

   334

        compile_cache = {}

   335

        while True:

   336

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

   337

            cmd = self._PythonIterator(res, blkid)

   338

            FBID = blkid.value

   339

            # print " -> ", cmd, blkid

   340

            if cmd is None:

   341

                break

   342

            try:

   343

                self.python_runtime_vars["FBID"] = FBID

   344

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

   345

                if ccmd is None or ccmd != cmd:

   346

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

   347

                    compile_cache[FBID] = (cmd, AST)

   348

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

   349

                if exp is not None:

   350

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

   351

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

   352

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

   353

                else:

   354

                    res = str(result)

   355

                self.python_runtime_vars["FBID"] = None

   356

            except Exception, e:

   357

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

   358

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

   359

   360

    def StartPLC(self):

   361

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

   362

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

   363

            error = None

   364

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

   365

            if res == 0:

   366

                self.PLCStatus = "Started"

   367

                self.StatusChange()

   368

                self.PythonRuntimeCall("start")

   369

                self.StartSem = Semaphore(0)

   370

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

   371

                self.PythonThread.start()

   372

                self.StartSem.acquire()

   373

                self.LogMessage("PLC started")

   374

            else:

   375

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

   376

                self.PLCStatus = "Broken"

   377

                self.StatusChange()

   378

   379

    def StopPLC(self):

   380

        if self.PLCStatus == "Started":

   381

            self.LogMessage("PLC stopped")

   382

            self._stopPLC()

   383

            self.PythonThread.join()

   384

            self.PLCStatus = "Stopped"

   385

            self.StatusChange()

   386

            self.PythonRuntimeCall("stop")

   387

            if self.TraceThread is not None:

   388

                self.TraceWakeup.set()

   389

                self.TraceThread.join()

   390

                self.TraceThread = None

   391

            return True

   392

        return False

   393

   394

    def _Reload(self):

   395

        self.daemon.shutdown(True)

   396

        self.daemon.sock.close()

   397

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

   398

        # never reached

   399

        return 0

   400

   401

    def ForceReload(self):

   402

        # respawn python interpreter

   403

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

   404

        return True

   405

   406

    def GetPLCstatus(self):

   407

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

   408

   409

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

   410

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

   411

            NewFileName = md5sum + lib_ext

   412

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

   413

   414

            self.UnLoadPLC()

   415

   416

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

   417

            self.PLCStatus = "Empty"

   418

   419

            try:

   420

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

   421

                                       self.CurrentPLCFilename))

   422

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

   423

                    try:

   424

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

   425

                    except Exception:

   426

                        pass

   427

            except Exception:

   428

                pass

   429

   430

            try:

   431

                # Create new PLC file

   432

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

   433

                     'wb').write(data)

   434

   435

                # Store new PLC filename based on md5 key

   436

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

   437

   438

                # Then write the files

   439

                log = file(extra_files_log, "w")

   440

                for fname, fdata in extrafiles:

   441

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

   442

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

   443

                    log.write(fname+'\n')

   444

   445

                # Store new PLC filename

   446

                self.CurrentPLCFilename = NewFileName

   447

            except Exception:

   448

                self.PLCStatus = "Broken"

   449

                self.StatusChange()

   450

                PLCprint(traceback.format_exc())

   451

                return False

   452

   453

            if self.LoadPLC():

   454

                self.PLCStatus = "Stopped"

   455

            else:

   456

                self.PLCStatus = "Broken"

   457

                self._FreePLC()

   458

            self.StatusChange()

   459

   460

            return self.PLCStatus == "Stopped"

   461

        return False

   462

   463

    def MatchMD5(self, MD5):

   464

        try:

   465

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

   466

            return last_md5 == MD5

   467

        except Exception:

   468

            pass

   469

        return False

   470

   471

    def SetTraceVariablesList(self, idxs):

   472

        """

   473

        Call ctype imported function to append

   474

        these indexes to registred variables in PLC debugger

   475

        """

   476

        if idxs:

   477

            # suspend but dont disable

   478

            if self._suspendDebug(False) == 0: