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 targets.typemapping import LogLevelsDefault, LogLevelsCount, TypeTranslator

    36

    37

    38

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

    39

    from _ctypes import LoadLibrary as dlopen

    40

    from _ctypes import FreeLibrary as dlclose

    41

elif os.name == "posix":

    42

    from _ctypes import dlopen, dlclose

    43

    44

    45

def get_last_traceback(tb):

    46

    while tb.tb_next:

    47

        tb = tb.tb_next

    48

    return tb

    49

    50

    51

lib_ext = {

    52

    "linux2": ".so",

    53

    "win32":  ".dll",

    54

}.get(sys.platform, "")

    55

    56

    57

def PLCprint(message):

    58

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

    59

    sys.stdout.flush()

    60

    61

    62

class PLCObject(pyro.ObjBase):

    63

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

    64

        pyro.ObjBase.__init__(self)

    65

        self.evaluator = evaluator

    66

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

    67

        self.workingdir = workingdir

    68

        self.PLCStatus = "Empty"

    69

        self.PLClibraryHandle = None

    70

        self.PLClibraryLock = Lock()

    71

        self.DummyIteratorLock = None

    72

        # Creates fake C funcs proxies

    73

        self._FreePLC()

    74

        self.daemon = daemon

    75

        self.statuschange = statuschange

    76

        self.hmi_frame = None

    77

        self.pyruntimevars = pyruntimevars

    78

        self._loading_error = None

    79

        self.python_runtime_vars = None

    80

        self.TraceThread = None

    81

        self.TraceLock = Lock()

    82

        self.TraceWakeup = Event()

    83

        self.Traces = []

    84

    85

    def AutoLoad(self):

    86

        # Get the last transfered PLC if connector must be restart

    87

        try:

    88

            self.CurrentPLCFilename = open(

    89

                self._GetMD5FileName(),

    90

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

    91

            if self.LoadPLC():

    92

                self.PLCStatus = "Stopped"

    93

        except Exception:

    94

            self.PLCStatus = "Empty"

    95

            self.CurrentPLCFilename = None

    96

    97

    def StatusChange(self):

    98

        if self.statuschange is not None:

    99

            for callee in self.statuschange:

   100

                callee(self.PLCStatus)

   101

   102

    def LogMessage(self, *args):

   103

        if len(args) == 2:

   104

            level, msg = args

   105

        else:

   106

            level = LogLevelsDefault

   107

            msg, = args

   108

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

   109

   110

    def ResetLogCount(self):

   111

        if self._ResetLogCount is not None:

   112

            self._ResetLogCount()

   113

   114

    def GetLogCount(self, level):

   115

        if self._GetLogCount is not None:

   116

            return int(self._GetLogCount(level))

   117

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

   118

            return 1

   119

   120

    def GetLogMessage(self, level, msgid):

   121

        tick = ctypes.c_uint32()

   122

        tv_sec = ctypes.c_uint32()

   123

        tv_nsec = ctypes.c_uint32()

   124

        if self._GetLogMessage is not None:

   125

            maxsz = len(self._log_read_buffer)-1

   126

            sz = self._GetLogMessage(level, msgid,

   127

                                     self._log_read_buffer, maxsz,

   128

                                     ctypes.byref(tick),

   129

                                     ctypes.byref(tv_sec),

   130

                                     ctypes.byref(tv_nsec))

   131

            if sz and sz <= maxsz:

   132

                self._log_read_buffer[sz] = '\x00'

   133

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

   134

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

   135

            return self._loading_error, 0, 0, 0

   136

        return None

   137

   138

    def _GetMD5FileName(self):

   139

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

   140

   141

    def _GetLibFileName(self):

   142

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

   143

   144

    def LoadPLC(self):

   145

        """

   146

        Load PLC library

   147

        Declare all functions, arguments and return values

   148

        """

   149

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

   150

        try:

   151

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

   152

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

   153

   154

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

   155

            if len(md5) == 32:

   156

                self.PLC_ID.value = md5

   157

   158

            self._startPLC = self.PLClibraryHandle.startPLC

   159

            self._startPLC.restype = ctypes.c_int

   160

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

   161

   162

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   163

            self._stopPLC_real.restype = None

   164

   165

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

   166

            if self._PythonIterator is not None:

   167

                self._PythonIterator.restype = ctypes.c_char_p

   168

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

   169

   170

                self._stopPLC = self._stopPLC_real

   171

            else:

   172

                # If python confnode is not enabled, we reuse _PythonIterator

   173

                # as a call that block pythonthread until StopPLC

   174

                self.PlcStopping = Event()

   175

   176

                def PythonIterator(res, blkid):

   177

                    self.PlcStopping.clear()

   178

                    self.PlcStopping.wait()

   179

                    return None

   180

                self._PythonIterator = PythonIterator

   181

   182

                def __StopPLC():

   183

                    self._stopPLC_real()

   184

                    self.PlcStopping.set()

   185

                self._stopPLC = __StopPLC

   186

   187

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   188

            self._ResetDebugVariables.restype = None

   189

   190

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   191

            self._RegisterDebugVariable.restype = None

   192

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

   193

   194

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   195

            self._FreeDebugData.restype = None

   196

   197

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   198

            self._GetDebugData.restype = ctypes.c_int

   199

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

   200

   201

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   202

            self._suspendDebug.restype = ctypes.c_int

   203

            self._suspendDebug.argtypes = [ctypes.c_int]

   204

   205

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   206

            self._resumeDebug.restype = None

   207

   208

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   209

            self._ResetLogCount.restype = None

   210

   211

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   212

            self._GetLogCount.restype = ctypes.c_uint32

   213

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   214

   215

            self._LogMessage = self.PLClibraryHandle.LogMessage

   216

            self._LogMessage.restype = ctypes.c_int

   217

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

   218

   219

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

   220

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   221

            self._GetLogMessage.restype = ctypes.c_uint32

   222

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

   223

   224

            self._loading_error = None

   225

   226

            self.PythonRuntimeInit()

   227

   228

            return True

   229

        except Exception:

   230

            self._loading_error = traceback.format_exc()

   231

            PLCprint(self._loading_error)

   232

            return False

   233

   234

    def UnLoadPLC(self):

   235

        self.PythonRuntimeCleanup()

   236

        self._FreePLC()

   237

   238

    def _FreePLC(self):

   239

        """

   240

        Unload PLC library.

   241

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

   242

        """

   243

        self.PLClibraryLock.acquire()

   244

        # Forget all refs to library

   245

        self._startPLC = lambda x, y: None

   246

        self._stopPLC = lambda: None

   247

        self._ResetDebugVariables = lambda: None

   248

        self._RegisterDebugVariable = lambda x, y: None

   249

        self._IterDebugData = lambda x, y: None

   250

        self._FreeDebugData = lambda: None

   251

        self._GetDebugData = lambda: -1

   252

        self._suspendDebug = lambda x: -1

   253

        self._resumeDebug = lambda: None

   254

        self._PythonIterator = lambda: ""

   255

        self._GetLogCount = None

   256

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

   257

        self._GetLogMessage = None

   258

        self.PLClibraryHandle = None

   259

        # Unload library explicitely

   260

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

   261

            dlclose(self._PLClibraryHandle)

   262

            self._PLClibraryHandle = None

   263

   264

        self.PLClibraryLock.release()

   265

        return False

   266

   267

    def PythonRuntimeCall(self, methodname):

   268

        """

   269

        Calls init, start, stop or cleanup method provided by

   270

        runtime python files, loaded when new PLC uploaded

   271

        """

   272

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

   273

            _res, exp = self.evaluator(method)

   274

            if exp is not None:

   275

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

   276

   277

    def PythonRuntimeInit(self):

   278

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

   279

        self.python_runtime_vars = globals().copy()

   280

        self.python_runtime_vars.update(self.pyruntimevars)

   281

        parent = self

   282

   283

        class PLCSafeGlobals(object):

   284

            def __getattr__(self, name):

   285

                try:

   286

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

   287

                except KeyError:

   288

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

   289

                v = t()

   290

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

   291

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

   292

   293

            def __setattr__(self, name, value):

   294

                try:

   295

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

   296

                except KeyError:

   297

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

   298

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

   299

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

   300

   301

        self.python_runtime_vars.update({

   302

            "PLCGlobals":     PLCSafeGlobals(),

   303

            "WorkingDir":     self.workingdir,

   304

            "PLCObject":      self,

   305

            "PLCBinary":      self.PLClibraryHandle,

   306

            "PLCGlobalsDesc": []})

   307

   308

        for methodname in MethodNames:

   309

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

   310

   311

        try:

   312

            filenames = os.listdir(self.workingdir)

   313

            filenames.sort()

   314

            for filename in filenames:

   315

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

   316

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

   317

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

   318

                    for methodname in MethodNames:

   319

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

   320

                        if method is not None:

   321

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

   322

        except Exception:

   323

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

   324

            raise

   325

   326

        self.PythonRuntimeCall("init")

   327

   328

    def PythonRuntimeCleanup(self):

   329

        if self.python_runtime_vars is not None:

   330

            self.PythonRuntimeCall("cleanup")

   331

   332

        self.python_runtime_vars = None

   333

   334

    def PythonThreadProc(self):

   335

        self.StartSem.release()

   336

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

   337

        compile_cache = {}

   338

        while True:

   339

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

   340

            cmd = self._PythonIterator(res, blkid)

   341

            FBID = blkid.value

   342

            # print " -> ", cmd, blkid

   343

            if cmd is None:

   344

                break

   345

            try:

   346

                self.python_runtime_vars["FBID"] = FBID

   347

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

   348

                if ccmd is None or ccmd != cmd:

   349

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

   350

                    compile_cache[FBID] = (cmd, AST)

   351

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

   352

                if exp is not None:

   353

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

   354

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

   355

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

   356

                else:

   357

                    res = str(result)

   358

                self.python_runtime_vars["FBID"] = None

   359

            except Exception, e:

   360

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

   361

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

   362

   363

    def StartPLC(self):

   364

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

   365

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

   366

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

   367

            if res == 0:

   368

                self.PLCStatus = "Started"

   369

                self.StatusChange()

   370

                self.PythonRuntimeCall("start")

   371

                self.StartSem = Semaphore(0)

   372

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

   373

                self.PythonThread.start()

   374

                self.StartSem.acquire()

   375

                self.LogMessage("PLC started")

   376

            else:

   377

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

   378

                self.PLCStatus = "Broken"

   379

                self.StatusChange()

   380

   381

    def StopPLC(self):

   382

        if self.PLCStatus == "Started":

   383

            self.LogMessage("PLC stopped")

   384

            self._stopPLC()

   385

            self.PythonThread.join()

   386

            self.PLCStatus = "Stopped"

   387

            self.StatusChange()

   388

            self.PythonRuntimeCall("stop")

   389

            if self.TraceThread is not None:

   390

                self.TraceWakeup.set()

   391

                self.TraceThread.join()

   392

                self.TraceThread = None

   393

            return True

   394

        return False

   395

   396

    def _Reload(self):

   397

        self.daemon.shutdown(True)

   398

        self.daemon.sock.close()

   399

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

   400

        # never reached

   401

        return 0

   402

   403

    def ForceReload(self):

   404

        # respawn python interpreter

   405

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

   406

        return True

   407

   408

    def GetPLCstatus(self):

   409

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

   410

   411

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

   412

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

   413

            NewFileName = md5sum + lib_ext

   414

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

   415

   416

            self.UnLoadPLC()

   417

   418

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

   419

            self.PLCStatus = "Empty"

   420

   421

            try:

   422

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

   423

                                       self.CurrentPLCFilename))

   424

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

   425

                    try:

   426

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

   427

                    except Exception:

   428

                        pass

   429

            except Exception:

   430

                pass

   431

   432

            try:

   433

                # Create new PLC file

   434

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

   435

                     'wb').write(data)

   436

   437

                # Store new PLC filename based on md5 key

   438

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

   439

   440

                # Then write the files

   441

                log = file(extra_files_log, "w")

   442

                for fname, fdata in extrafiles:

   443

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

   444

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

   445

                    log.write(fname+'\n')

   446

   447

                # Store new PLC filename

   448

                self.CurrentPLCFilename = NewFileName

   449

            except Exception:

   450

                self.PLCStatus = "Broken"

   451

                self.StatusChange()

   452

                PLCprint(traceback.format_exc())

   453

                return False

   454

   455

            if self.LoadPLC():

   456

                self.PLCStatus = "Stopped"

   457

            else:

   458

                self.PLCStatus = "Broken"

   459

                self._FreePLC()

   460

            self.StatusChange()

   461

   462

            return self.PLCStatus == "Stopped"

   463

        return False

   464

   465

    def MatchMD5(self, MD5):

   466

        try:

   467

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

   468

            return last_md5 == MD5

   469

        except Exception:

   470

            pass

   471

        return False

   472

   473

    def SetTraceVariablesList(self, idxs):

   474

        """

   475

        Call ctype imported function to append

   476

        these indexes to registred variables in PLC debugger

   477

        """

   478

        if idxs: