greg@229: #!/usr/bin/env python
greg@229: # -*- coding: utf-8 -*-
greg@229: 
andrej@1667: # This file is part of Beremiz runtime.
greg@229: #
andrej@1571: # Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD
greg@229: #
andrej@1667: # See COPYING.Runtime file for copyrights details.
greg@229: #
andrej@1667: # This library is free software; you can redistribute it and/or
andrej@1667: # modify it under the terms of the GNU Lesser General Public
andrej@1667: # License as published by the Free Software Foundation; either
andrej@1667: # version 2.1 of the License, or (at your option) any later version.
andrej@1667: 
andrej@1667: # This library is distributed in the hope that it will be useful,
andrej@1571: # but WITHOUT ANY WARRANTY; without even the implied warranty of
andrej@1667: # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
andrej@1667: # Lesser General Public License for more details.
andrej@1667: 
andrej@1667: # You should have received a copy of the GNU Lesser General Public
andrej@1667: # License along with this library; if not, write to the Free Software
andrej@1667: # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
greg@229: 
andrej@1832: 
andrej@1881: from __future__ import absolute_import
Edouard@1984: import thread
Edouard@1984: from threading import Timer, Thread, Lock, Semaphore, Event, Condition
andrej@1732: import ctypes
andrej@1732: import os
andrej@1732: import sys
andrej@1783: import traceback
andrej@1832: from time import time
Edouard@1956: import _ctypes  # pylint: disable=wrong-import-order
andrej@1832: import Pyro.core as pyro
andrej@1832: 
Edouard@1902: from runtime.typemapping import TypeTranslator
Edouard@1902: from runtime.loglevels import LogLevelsDefault, LogLevelsCount
Edouard@917: 
greg@229: if os.name in ("nt", "ce"):
Edouard@1919:     dlopen = _ctypes.LoadLibrary
Edouard@1919:     dlclose = _ctypes.FreeLibrary
greg@229: elif os.name == "posix":
Edouard@1919:     dlopen = _ctypes.dlopen
Edouard@1919:     dlclose = _ctypes.dlclose
greg@229: 
andrej@1736: 
laurent@699: def get_last_traceback(tb):
laurent@699:     while tb.tb_next:
laurent@699:         tb = tb.tb_next
laurent@699:     return tb
greg@229: 
andrej@1749: 
andrej@1742: lib_ext = {
andrej@1878:     "linux2": ".so",
andrej@1878:     "win32":  ".dll",
andrej@1878: }.get(sys.platform, "")
greg@229: 
andrej@1736: 
etisserant@291: def PLCprint(message):
etisserant@291:     sys.stdout.write("PLCobject : "+message+"\n")
etisserant@291:     sys.stdout.flush()
etisserant@291: 
andrej@1736: 
Edouard@1984: class job(object):
Edouard@1984:     """
Edouard@1984:     job to be executed by a worker
Edouard@1984:     """
Edouard@1984:     def __init__(self,call,*args,**kwargs):
Edouard@1984:         self.job = (call,args,kwargs)
Edouard@1984:         self.result = None
Edouard@1984:         self.success = False
Edouard@1984:         self.exc_info = None
Edouard@1984: 
Edouard@1984:     def do(self):
Edouard@1984:         """
Edouard@1984:         do the job by executing the call, and deal with exceptions 
Edouard@1984:         """
Edouard@1984:         try :
Edouard@1984:             call, args, kwargs = self.job
Edouard@1984:             self.result = call(*args,**kwargs)
Edouard@1984:             self.success = True
Edouard@1984:         except Exception:
Edouard@1984:             self.success = False
Edouard@1984:             self.exc_info = sys.exc_info()
Edouard@1984: 
Edouard@1984: 
Edouard@1984: class worker(object):
Edouard@1984:     """
Edouard@1984:     serialize main thread load/unload of PLC shared objects
Edouard@1984:     """
Edouard@1984:     def __init__(self):
Edouard@1984:         # Only one job at a time
Edouard@1984:         self._finish = False
Edouard@1984:         self._threadID = None
Edouard@1984:         self.mutex = Lock()
Edouard@1984:         self.todo = Condition(self.mutex)
Edouard@1984:         self.done = Condition(self.mutex)
Edouard@1994:         self.free = Condition(self.mutex)
Edouard@1984:         self.job = None
Edouard@1984: 
Edouard@1988:     def runloop(self,*args,**kwargs):
Edouard@1984:         """
Edouard@1984:         meant to be called by worker thread (blocking)
Edouard@1984:         """
Edouard@1984:         self._threadID = thread.get_ident()
Edouard@1988:         if args or kwargs:
Edouard@1988:             job(*args,**kwargs).do()
Edouard@1988:             # result is ignored
Edouard@1984:         self.mutex.acquire()
Edouard@1984:         while not self._finish:
Edouard@1984:             self.todo.wait()
Edouard@1984:             if self.job is not None:
Edouard@1984:                 self.job.do()
Edouard@1994:                 self.done.notify()
Edouard@1994:             else:
Edouard@1994:                 self.free.notify()
Edouard@1984:         self.mutex.release()
Edouard@1984:     
Edouard@1984:     def call(self, *args, **kwargs):
Edouard@1984:         """
Edouard@1984:         creates a job, execute it in worker thread, and deliver result.
Edouard@1984:         if job execution raise exception, re-raise same exception 
Edouard@1984:         meant to be called by non-worker threads, but this is accepted.
Edouard@1984:         blocking until job done
Edouard@1984:         """
Edouard@1984: 
Edouard@1984:         _job = job(*args,**kwargs)
Edouard@1984: 
Edouard@1994:         if self._threadID == thread.get_ident() or self._threadID is None:
Edouard@1984:             # if caller is worker thread execute immediately
Edouard@1984:             _job.do()
Edouard@1984:         else:
Edouard@1984:             # otherwise notify and wait for completion
Edouard@1984:             self.mutex.acquire()
Edouard@1984: 
Edouard@1984:             while self.job is not None:
Edouard@1994:                 self.free.wait()
Edouard@1984: 
Edouard@1984:             self.job = _job
Edouard@1984:             self.todo.notify()
Edouard@1984:             self.done.wait()
Edouard@1984:             _job = self.job
Edouard@1984:             self.job = None
Edouard@1984:             self.mutex.release()
Edouard@1984: 
Edouard@1984:         if _job.success:
Edouard@1984:             return _job.result
Edouard@1984:         else:
Edouard@1984:             raise _job.exc_info[0], _job.exc_info[1], _job.exc_info[2]
Edouard@1984:         
Edouard@1984:     def quit(self):
Edouard@1984:         """
Edouard@1984:         unblocks main thread, and terminate execution of runloop()
Edouard@1984:         """
Edouard@1984:         # mark queue
Edouard@1984:         self._finish = True
Edouard@1984:         self.mutex.acquire()
Edouard@1984:         self.job = None
Edouard@1984:         self.todo.notify()
Edouard@1984:         self.mutex.release()
Edouard@1984: 
Edouard@1984: 
Edouard@1984: MainWorker = worker()
Edouard@1984: 
Edouard@1984: 
Edouard@1984: def RunInMain(func):
Edouard@1984:     def func_wrapper(*args,**kwargs):
Edouard@1984:         return MainWorker.call(func, *args, **kwargs)
Edouard@1984:     return func_wrapper
Edouard@1984:     
Edouard@1984: 
greg@229: class PLCObject(pyro.ObjBase):
Edouard@1984:     def __init__(self, server):
greg@229:         pyro.ObjBase.__init__(self)
Edouard@1984:         self.evaluator = server.evaluator
Edouard@1984:         self.argv = [server.workdir] + server.argv  # force argv[0] to be "path" to exec...
Edouard@1984:         self.workingdir = server.workdir
Edouard@1447:         self.PLCStatus = "Empty"
greg@229:         self.PLClibraryHandle = None
greg@352:         self.PLClibraryLock = Lock()
laurent@366:         self.DummyIteratorLock = None
greg@229:         # Creates fake C funcs proxies
Edouard@1984:         self._InitPLCStubCalls()
Edouard@1984:         self.daemon = server.daemon
Edouard@1984:         self.statuschange = server.statuschange
etisserant@301:         self.hmi_frame = None
Edouard@1984:         self.pyruntimevars = server.pyruntimevars
Edouard@914:         self._loading_error = None
Edouard@1014:         self.python_runtime_vars = None
Edouard@1434:         self.TraceThread = None
Edouard@1434:         self.TraceLock = Lock()
Edouard@1434:         self.Traces = []
Edouard@1433: 
Edouard@1994:     # First task of worker -> no @RunInMain
Edouard@1447:     def AutoLoad(self):
Edouard@1994:         # Get the last transfered PLC 
greg@229:         try:
andrej@1742:             self.CurrentPLCFilename = open(
andrej@1878:                 self._GetMD5FileName(),
andrej@1878:                 "r").read().strip() + lib_ext
andrej@1570:             if self.LoadPLC():
andrej@1570:                 self.PLCStatus = "Stopped"
andrej@1846:         except Exception:
greg@229:             self.PLCStatus = "Empty"
andrej@1742:             self.CurrentPLCFilename = None
greg@229: 
etisserant@286:     def StatusChange(self):
etisserant@286:         if self.statuschange is not None:
Edouard@1438:             for callee in self.statuschange:
Edouard@1438:                 callee(self.PLCStatus)
etisserant@286: 
Edouard@1994:     @RunInMain
Edouard@917:     def LogMessage(self, *args):
Edouard@917:         if len(args) == 2:
Edouard@917:             level, msg = args
Edouard@917:         else:
Edouard@917:             level = LogLevelsDefault
Edouard@917:             msg, = args
Edouard@1906:         PLCprint(msg)
Edouard@1906:         if self._LogMessage is not None:
Edouard@1906:             return self._LogMessage(level, msg, len(msg))
Edouard@1906:         return None
Edouard@917: 
Edouard@1994:     @RunInMain
Laurent@1093:     def ResetLogCount(self):
Laurent@1093:         if self._ResetLogCount is not None:
Laurent@1093:             self._ResetLogCount()
Edouard@917: 
Edouard@1994:     # used internaly 
Edouard@917:     def GetLogCount(self, level):
andrej@1739:         if self._GetLogCount is not None:
Edouard@917:             return int(self._GetLogCount(level))
andrej@1742:         elif self._loading_error is not None and level == 0:
Laurent@1093:             return 1
Edouard@914: 
Edouard@1994:     @RunInMain
Edouard@917:     def GetLogMessage(self, level, msgid):
Edouard@921:         tick = ctypes.c_uint32()
Edouard@921:         tv_sec = ctypes.c_uint32()
Edouard@921:         tv_nsec = ctypes.c_uint32()
Edouard@914:         if self._GetLogMessage is not None:
Edouard@914:             maxsz = len(self._log_read_buffer)-1
Edouard@1433:             sz = self._GetLogMessage(level, msgid,
andrej@1768:                                      self._log_read_buffer, maxsz,
andrej@1768:                                      ctypes.byref(tick),
andrej@1768:                                      ctypes.byref(tv_sec),
andrej@1768:                                      ctypes.byref(tv_nsec))
Edouard@914:             if sz and sz <= maxsz:
Edouard@914:                 self._log_read_buffer[sz] = '\x00'
andrej@1740:                 return self._log_read_buffer.value, tick.value, tv_sec.value, tv_nsec.value
andrej@1742:         elif self._loading_error is not None and level == 0:
andrej@1740:             return self._loading_error, 0, 0, 0
Edouard@914:         return None
Edouard@911: 
greg@229:     def _GetMD5FileName(self):
greg@229:         return os.path.join(self.workingdir, "lasttransferedPLC.md5")
greg@229: 
greg@229:     def _GetLibFileName(self):
andrej@1740:         return os.path.join(self.workingdir, self.CurrentPLCFilename)
greg@229: 
Edouard@1994:     def _LoadPLC(self):
greg@229:         """
greg@229:         Load PLC library
greg@229:         Declare all functions, arguments and return values
greg@229:         """
Edouard@1457:         md5 = open(self._GetMD5FileName(), "r").read()
Edouard@1994:         self.PLClibraryLock.acquire()
greg@229:         try:
greg@229:             self._PLClibraryHandle = dlopen(self._GetLibFileName())
greg@229:             self.PLClibraryHandle = ctypes.CDLL(self.CurrentPLCFilename, handle=self._PLClibraryHandle)
Edouard@1433: 
Edouard@1463:             self.PLC_ID = ctypes.c_char_p.in_dll(self.PLClibraryHandle, "PLC_ID")
andrej@1739:             if len(md5) == 32:
andrej@1730:                 self.PLC_ID.value = md5
Edouard@1457: 
greg@229:             self._startPLC = self.PLClibraryHandle.startPLC
greg@229:             self._startPLC.restype = ctypes.c_int
greg@229:             self._startPLC.argtypes = [ctypes.c_int, ctypes.POINTER(ctypes.c_char_p)]
Edouard@1433: 
ed@455:             self._stopPLC_real = self.PLClibraryHandle.stopPLC
ed@455:             self._stopPLC_real.restype = None
Edouard@1433: 
laurent@366:             self._PythonIterator = getattr(self.PLClibraryHandle, "PythonIterator", None)
laurent@366:             if self._PythonIterator is not None:
laurent@366:                 self._PythonIterator.restype = ctypes.c_char_p
Edouard@851:                 self._PythonIterator.argtypes = [ctypes.c_char_p, ctypes.POINTER(ctypes.c_void_p)]
Edouard@1433: 
edouard@483:                 self._stopPLC = self._stopPLC_real
laurent@366:             else:
Edouard@717:                 # If python confnode is not enabled, we reuse _PythonIterator
Edouard@1433:                 # as a call that block pythonthread until StopPLC
Edouard@1442:                 self.PlcStopping = Event()
andrej@1750: 
Edouard@868:                 def PythonIterator(res, blkid):
Edouard@1442:                     self.PlcStopping.clear()
Edouard@1442:                     self.PlcStopping.wait()
laurent@366:                     return None
ed@455:                 self._PythonIterator = PythonIterator
Edouard@1433: 
edouard@483:                 def __StopPLC():
ed@455:                     self._stopPLC_real()
Edouard@1442:                     self.PlcStopping.set()
edouard@483:                 self._stopPLC = __StopPLC
Edouard@1433: 
greg@229:             self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables
greg@229:             self._ResetDebugVariables.restype = None
Edouard@1433: 
etisserant@235:             self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable
greg@229:             self._RegisterDebugVariable.restype = None
edouard@477:             self._RegisterDebugVariable.argtypes = [ctypes.c_int, ctypes.c_void_p]
Edouard@1433: 
greg@229:             self._FreeDebugData = self.PLClibraryHandle.FreeDebugData
greg@229:             self._FreeDebugData.restype = None
Edouard@1433: 
edouard@450:             self._GetDebugData = self.PLClibraryHandle.GetDebugData
Edouard@1433:             self._GetDebugData.restype = ctypes.c_int
edouard@450:             self._GetDebugData.argtypes = [ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_void_p)]
etisserant@235: 
etisserant@235:             self._suspendDebug = self.PLClibraryHandle.suspendDebug
Edouard@614:             self._suspendDebug.restype = ctypes.c_int
edouard@462:             self._suspendDebug.argtypes = [ctypes.c_int]
etisserant@235: 
etisserant@235:             self._resumeDebug = self.PLClibraryHandle.resumeDebug
etisserant@235:             self._resumeDebug.restype = None
Edouard@906: 
Laurent@1093:             self._ResetLogCount = self.PLClibraryHandle.ResetLogCount
Laurent@1093:             self._ResetLogCount.restype = None
Laurent@1093: 
Edouard@906:             self._GetLogCount = self.PLClibraryHandle.GetLogCount
Edouard@906:             self._GetLogCount.restype = ctypes.c_uint32
Edouard@917:             self._GetLogCount.argtypes = [ctypes.c_uint8]
Edouard@906: 
Edouard@911:             self._LogMessage = self.PLClibraryHandle.LogMessage
Edouard@911:             self._LogMessage.restype = ctypes.c_int
Edouard@971:             self._LogMessage.argtypes = [ctypes.c_uint8, ctypes.c_char_p, ctypes.c_uint32]
Laurent@1093: 
andrej@1760:             self._log_read_buffer = ctypes.create_string_buffer(1 << 14)  # 16K
Edouard@911:             self._GetLogMessage = self.PLClibraryHandle.GetLogMessage
Edouard@911:             self._GetLogMessage.restype = ctypes.c_uint32
Edouard@921:             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)]
Edouard@911: 
Edouard@914:             self._loading_error = None
Edouard@1035: 
andrej@1780:         except Exception:
Edouard@914:             self._loading_error = traceback.format_exc()
Edouard@914:             PLCprint(self._loading_error)
Edouard@1994:             return False
Edouard@1994:         finally:
Edouard@1994:             self.PLClibraryLock.release()
Edouard@1994: 
Edouard@1994:         return True
Edouard@1994: 
Edouard@1994:     @RunInMain
Edouard@1994:     def LoadPLC(self):
Edouard@1994:         res = self._LoadPLC()
Edouard@1994:         if res:
Edouard@1994:             self.PythonRuntimeInit()
Edouard@1994:         else:
Edouard@1984:             self._FreePLC()
Edouard@1994: 
Edouard@1994:         return res
greg@229: 
Edouard@1984:     @RunInMain
Edouard@1045:     def UnLoadPLC(self):
Edouard@1045:         self.PythonRuntimeCleanup()
Edouard@1045:         self._FreePLC()
Edouard@1045: 
Edouard@1984:     def _InitPLCStubCalls(self):
Edouard@1984:         """
Edouard@1984:         create dummy C func proxies
Edouard@1984:         """
andrej@1740:         self._startPLC = lambda x, y: None
andrej@1740:         self._stopPLC = lambda: None
andrej@1740:         self._ResetDebugVariables = lambda: None
andrej@1740:         self._RegisterDebugVariable = lambda x, y: None
andrej@1740:         self._IterDebugData = lambda x, y: None
andrej@1740:         self._FreeDebugData = lambda: None
andrej@1740:         self._GetDebugData = lambda: -1
andrej@1740:         self._suspendDebug = lambda x: -1
andrej@1740:         self._resumeDebug = lambda: None
andrej@1740:         self._PythonIterator = lambda: ""
Edouard@1433:         self._GetLogCount = None
Edouard@1906:         self._LogMessage = None
Edouard@914:         self._GetLogMessage = None
Edouard@1984:         self._PLClibraryHandle = None
greg@229:         self.PLClibraryHandle = None
Edouard@1984: 
Edouard@1984:     def _FreePLC(self):
Edouard@1984:         """
Edouard@1984:         Unload PLC library.
Edouard@1984:         This is also called by __init__ to create dummy C func proxies
Edouard@1984:         """
Edouard@1984:         self.PLClibraryLock.acquire()
Edouard@1994:         try:
Edouard@1994:             # Unload library explicitely
Edouard@1994:             if getattr(self, "_PLClibraryHandle", None) is not None:
Edouard@1994:                 dlclose(self._PLClibraryHandle)
Edouard@1994: 
Edouard@1994:             # Forget all refs to library
Edouard@1994:             self._InitPLCStubCalls()
Edouard@1994: 
Edouard@1994:         finally:
Edouard@1994:             self.PLClibraryLock.release()
Edouard@1994: 
greg@229:         return False
greg@229: 
Edouard@1014:     def PythonRuntimeCall(self, methodname):
Edouard@1433:         """
Edouard@1433:         Calls init, start, stop or cleanup method provided by
Edouard@1014:         runtime python files, loaded when new PLC uploaded
Edouard@1014:         """
andrej@1734:         for method in self.python_runtime_vars.get("_runtime_%s" % methodname, []):
andrej@1847:             _res, exp = self.evaluator(method)
Edouard@1433:             if exp is not None:
andrej@1740:                 self.LogMessage(0, '\n'.join(traceback.format_exception(*exp)))
Edouard@1014: 
Edouard@1994:     # used internaly 
Edouard@1014:     def PythonRuntimeInit(self):
Edouard@1014:         MethodNames = ["init", "start", "stop", "cleanup"]
Edouard@1014:         self.python_runtime_vars = globals().copy()
Edouard@1438:         self.python_runtime_vars.update(self.pyruntimevars)
andrej@1868:         parent = self
Edouard@1438: 
andrej@1831:         class PLCSafeGlobals(object):
andrej@1868:             def __getattr__(self, name):
andrej@1739:                 try:
andrej@1868:                     t = parent.python_runtime_vars["_"+name+"_ctype"]
Edouard@1156:                 except KeyError:
andrej@1734:                     raise KeyError("Try to get unknown shared global variable : %s" % name)
Edouard@1156:                 v = t()
andrej@1868:                 parent.python_runtime_vars["_PySafeGetPLCGlob_"+name](ctypes.byref(v))
andrej@1868:                 return parent.python_runtime_vars["_"+name+"_unpack"](v)
andrej@1868: 
andrej@1868:             def __setattr__(self, name, value):
andrej@1739:                 try:
andrej@1868:                     t = parent.python_runtime_vars["_"+name+"_ctype"]
Edouard@1156:                 except KeyError:
andrej@1734:                     raise KeyError("Try to set unknown shared global variable : %s" % name)
andrej@1868:                 v = parent.python_runtime_vars["_"+name+"_pack"](t, value)
andrej@1868:                 parent.python_runtime_vars["_PySafeSetPLCGlob_"+name](ctypes.byref(v))
Edouard@1447: 
Edouard@1447:         self.python_runtime_vars.update({
andrej@1739:             "PLCGlobals":     PLCSafeGlobals(),
andrej@1739:             "WorkingDir":     self.workingdir,
andrej@1739:             "PLCObject":      self,
andrej@1739:             "PLCBinary":      self.PLClibraryHandle,
andrej@1739:             "PLCGlobalsDesc": []})
andrej@1739: 
andrej@1739:         for methodname in MethodNames:
andrej@1734:             self.python_runtime_vars["_runtime_%s" % methodname] = []
Edouard@1447: 
Edouard@972:         try:
Edouard@1447:             filenames = os.listdir(self.workingdir)
Edouard@1447:             filenames.sort()
Edouard@1447:             for filename in filenames:
Edouard@972:                 name, ext = os.path.splitext(filename)
Edouard@972:                 if name.upper().startswith("RUNTIME") and ext.upper() == ".PY":
Edouard@1014:                     execfile(os.path.join(self.workingdir, filename), self.python_runtime_vars)
Edouard@1433:                     for methodname in MethodNames:
Edouard@1014:                         method = self.python_runtime_vars.get("_%s_%s" % (name, methodname), None)
Edouard@1014:                         if method is not None:
andrej@1734:                             self.python_runtime_vars["_runtime_%s" % methodname].append(method)
andrej@1780:         except Exception:
andrej@1740:             self.LogMessage(0, traceback.format_exc())
Edouard@972:             raise
Edouard@1433: 
Edouard@1014:         self.PythonRuntimeCall("init")
Edouard@1014: 
Edouard@1994:     # used internaly 
Edouard@1014:     def PythonRuntimeCleanup(self):
Edouard@1014:         if self.python_runtime_vars is not None:
Edouard@1014:             self.PythonRuntimeCall("cleanup")
Edouard@1014: 
Edouard@1014:         self.python_runtime_vars = None
etisserant@291: 
edouard@462:     def PythonThreadProc(self):
laurent@798:         self.StartSem.release()
andrej@1740:         res, cmd, blkid = "None", "None", ctypes.c_void_p()
andrej@1742:         compile_cache = {}
laurent@798:         while True:
andrej@1740:             cmd = self._PythonIterator(res, blkid)
Edouard@1433:             FBID = blkid.value
laurent@798:             if cmd is None:
laurent@798:                 break
andrej@1739:             try:
andrej@1742:                 self.python_runtime_vars["FBID"] = FBID
andrej@1742:                 ccmd, AST = compile_cache.get(FBID, (None, None))
andrej@1742:                 if ccmd is None or ccmd != cmd:
Edouard@867:                     AST = compile(cmd, '<plc>', 'eval')
andrej@1742:                     compile_cache[FBID] = (cmd, AST)
andrej@1740:                 result, exp = self.evaluator(eval, AST, self.python_runtime_vars)
Edouard@1433:                 if exp is not None:
Edouard@1052:                     res = "#EXCEPTION : "+str(exp[1])
andrej@1768:                     self.LogMessage(1, ('PyEval@0x%x(Code="%s") Exception "%s"') % (
andrej@1768:                         FBID, cmd, '\n'.join(traceback.format_exception(*exp))))
Edouard@867:                 else:
andrej@1742:                     res = str(result)
andrej@1742:                 self.python_runtime_vars["FBID"] = None
andrej@1740:             except Exception, e:
laurent@798:                 res = "#EXCEPTION : "+str(e)
andrej@1740:                 self.LogMessage(1, ('PyEval@0x%x(Code="%s") Exception "%s"') % (FBID, cmd, str(e)))
Edouard@1433: 
Edouard@1988:     @RunInMain
edouard@462:     def StartPLC(self):
edouard@465:         if self.CurrentPLCFilename is not None and self.PLCStatus == "Stopped":
laurent@798:             c_argv = ctypes.c_char_p * len(self.argv)
andrej@1740:             res = self._startPLC(len(self.argv), c_argv(*self.argv))
Edouard@906:             if res == 0:
Edouard@1442:                 self.PLCStatus = "Started"
Edouard@1442:                 self.StatusChange()
Edouard@1442:                 self.PythonRuntimeCall("start")
andrej@1742:                 self.StartSem = Semaphore(0)
Edouard@906:                 self.PythonThread = Thread(target=self.PythonThreadProc)
Edouard@906:                 self.PythonThread.start()
Edouard@906:                 self.StartSem.acquire()
Edouard@917:                 self.LogMessage("PLC started")
laurent@798:             else:
andrej@1740:                 self.LogMessage(0, _("Problem starting PLC : error %d" % res))
laurent@798:                 self.PLCStatus = "Broken"
laurent@798:                 self.StatusChange()
Edouard@1433: 
Edouard@1988:     @RunInMain
greg@229:     def StopPLC(self):
greg@229:         if self.PLCStatus == "Started":
Edouard@917:             self.LogMessage("PLC stopped")
greg@352:             self._stopPLC()
laurent@798:             self.PythonThread.join()
Edouard@1442:             self.PLCStatus = "Stopped"
Edouard@1442:             self.StatusChange()
Edouard@1442:             self.PythonRuntimeCall("stop")
andrej@1739:             if self.TraceThread is not None:
Edouard@1434:                 self.TraceThread.join()
Edouard@1434:                 self.TraceThread = None
greg@229:             return True
greg@229:         return False
greg@229: 
Edouard@1994:     @RunInMain
greg@229:     def GetPLCstatus(self):
andrej@1740:         return self.PLCStatus, map(self.GetLogCount, xrange(LogLevelsCount))
Edouard@1433: 
Edouard@1988:     @RunInMain
greg@229:     def NewPLC(self, md5sum, data, extrafiles):
laurent@393:         if self.PLCStatus in ["Stopped", "Empty", "Broken"]:
greg@229:             NewFileName = md5sum + lib_ext
andrej@1740:             extra_files_log = os.path.join(self.workingdir, "extra_files.txt")
Edouard@906: 
Edouard@1994:             old_PLC_filename = os.path.join(self.workingdir, \
Edouard@1994:                                             self.CurrentPLCFilename) \
Edouard@1994:                                if self.CurrentPLCFilename is not None \
Edouard@1994:                                else None
Edouard@1994:             new_PLC_filename = os.path.join(self.workingdir, NewFileName)
Edouard@1994: 
Edouard@1994:             # Some platform (i.e. Xenomai) don't like reloading same .so file
Edouard@1994:             replace_PLC_shared_object = new_PLC_filename != old_PLC_filename
Edouard@1994: 
Edouard@1994:             if replace_PLC_shared_object:
Edouard@1994:                 self.UnLoadPLC()
Edouard@1045: 
andrej@1734:             self.LogMessage("NewPLC (%s)" % md5sum)
Edouard@906:             self.PLCStatus = "Empty"
Edouard@906: 
Edouard@1994: 
greg@229:             try:
Edouard@1994:                 if replace_PLC_shared_object:
Edouard@1994:                     os.remove(old_PLC_filename)
laurent@364:                 for filename in file(extra_files_log, "r").readlines() + [extra_files_log]:
greg@229:                     try:
laurent@364:                         os.remove(os.path.join(self.workingdir, filename.strip()))
andrej@1780:                     except Exception:
greg@229:                         pass
andrej@1780:             except Exception:
greg@229:                 pass
Edouard@1433: 
greg@229:             try:
greg@229:                 # Create new PLC file
Edouard@1994:                 if replace_PLC_shared_object:
Edouard@1994:                     open(new_PLC_filename, 'wb').write(data)
Edouard@1433: 
greg@229:                 # Store new PLC filename based on md5 key
greg@229:                 open(self._GetMD5FileName(), "w").write(md5sum)
Edouard@1433: 
greg@229:                 # Then write the files
greg@229:                 log = file(extra_files_log, "w")
andrej@1740:                 for fname, fdata in extrafiles:
andrej@1740:                     fpath = os.path.join(self.workingdir, fname)
greg@229:                     open(fpath, "wb").write(fdata)
greg@229:                     log.write(fname+'\n')
greg@229: 
greg@229:                 # Store new PLC filename
greg@229:                 self.CurrentPLCFilename = NewFileName
andrej@1780:             except Exception:
Edouard@906:                 self.PLCStatus = "Broken"
Edouard@906:                 self.StatusChange()
etisserant@291:                 PLCprint(traceback.format_exc())
greg@229:                 return False
Edouard@906: 
Edouard@1994:             if not replace_PLC_shared_object:
Edouard@1994:                 self.PLCStatus = "Stopped"
Edouard@1994:             elif self.LoadPLC():
greg@229:                 self.PLCStatus = "Stopped"
Edouard@906:             else:
Edouard@1035:                 self.PLCStatus = "Broken"
Edouard@906:             self.StatusChange()
Edouard@906: 
Edouard@906:             return self.PLCStatus == "Stopped"
greg@229:         return False
greg@229: 
greg@229:     def MatchMD5(self, MD5):
greg@229:         try:
greg@229:             last_md5 = open(self._GetMD5FileName(), "r").read()
greg@229:             return last_md5 == MD5
andrej@1780:         except Exception:
Edouard@1440:             pass
Edouard@1440:         return False
Edouard@1433: 
greg@229:     def SetTraceVariablesList(self, idxs):
greg@229:         """
Edouard@1433:         Call ctype imported function to append
greg@229:         these indexes to registred variables in PLC debugger
greg@229:         """
edouard@462:         if idxs:
edouard@462:             # suspend but dont disable
Edouard@614:             if self._suspendDebug(False) == 0:
Edouard@614:                 # keep a copy of requested idx
Edouard@614:                 self._ResetDebugVariables()
andrej@1740:                 for idx, iectype, force in idxs:
andrej@1743:                     if force is not None:
andrej@1847:                         c_type, _unpack_func, pack_func = \
Edouard@614:                             TypeTranslator.get(iectype,
andrej@1767:                                                (None, None, None))
andrej@1740:                         force = ctypes.byref(pack_func(c_type, force))
Edouard@614:                     self._RegisterDebugVariable(idx, force)
Edouard@1434:                 self._TracesSwap()
Edouard@614:                 self._resumeDebug()
edouard@462:         else:
edouard@462:             self._suspendDebug(True)
Edouard@1434: 
Edouard@1434: 
Edouard@1434:     def _TracesSwap(self):
Edouard@1434:         self.LastSwapTrace = time()
Edouard@1434:         if self.TraceThread is None and self.PLCStatus == "Started":
Edouard@1434:             self.TraceThread = Thread(target=self.TraceThreadProc)
Edouard@1434:             self.TraceThread.start()
Edouard@1434:         self.TraceLock.acquire()
Edouard@1434:         Traces = self.Traces
Edouard@1434:         self.Traces = []
Edouard@1434:         self.TraceLock.release()
Edouard@1434:         return Traces
Edouard@1434: 
Edouard@1994:     @RunInMain
greg@229:     def GetTraceVariables(self):
Edouard@1434:         return self.PLCStatus, self._TracesSwap()
Edouard@1434: 
Edouard@1434:     def TraceThreadProc(self):
Edouard@1434:         """
Edouard@1434:         Return a list of traces, corresponding to the list of required idx
Edouard@1434:         """
Edouard@1994:         self._resumeDebug()  # Re-enable debugger
andrej@1739:         while self.PLCStatus == "Started":
edouard@450:             tick = ctypes.c_uint32()
edouard@450:             size = ctypes.c_uint32()
Edouard@1075:             buff = ctypes.c_void_p()
Edouard@1433:             TraceBuffer = None
Edouard@1994: 
Edouard@1994:             self.PLClibraryLock.acquire()
Edouard@1994: 
Edouard@1994:             res = self._GetDebugData(ctypes.byref(tick),
Edouard@1994:                                      ctypes.byref(size),
Edouard@1994:                                      ctypes.byref(buff)) 
Edouard@1994:             if res == 0:
Edouard@1994:                 if size.value:
Edouard@1994:                     TraceBuffer = ctypes.string_at(buff.value, size.value)
Edouard@1994:                 self._FreeDebugData()
Edouard@1994: 
Edouard@1994:             self.PLClibraryLock.release()
Edouard@1990:                 
Edouard@1994:             # leave thread if GetDebugData isn't happy.
Edouard@1994:             if res != 0:
Edouard@1994:                 break
Edouard@1990: 
Edouard@1433:             if TraceBuffer is not None:
Edouard@1994:                 self.TraceLock.acquire()
Edouard@1994:                 lT = len(self.Traces)
Edouard@1994:                 if lT != 0 and lT * len(self.Traces[0]) > 1024 * 1024:
Edouard@1994:                     self.Traces.pop(0)
Edouard@1994:                 self.Traces.append((tick.value, TraceBuffer))
Edouard@1994:                 self.TraceLock.release()
Edouard@1994: 
Edouard@1994:             # TraceProc stops here if Traces not polled for 3 seconds
Edouard@1994:             traces_age = time() - self.LastSwapTrace
Edouard@1994:             if traces_age > 3:
Edouard@1994:                 self.TraceLock.acquire()
Edouard@1994:                 self.Traces = []
Edouard@1994:                 self.TraceLock.release()
Edouard@1994:                 self._suspendDebug(True)  # Disable debugger
Edouard@1994:                 break
Edouard@1994: 
Edouard@1994:         self.TraceThread = None
Edouard@1434: 
Edouard@1440:     def RemoteExec(self, script, *kwargs):
laurent@699:         try:
laurent@699:             exec script in kwargs
andrej@1780:         except Exception:
andrej@1847:             _e_type, e_value, e_traceback = sys.exc_info()
laurent@699:             line_no = traceback.tb_lineno(get_last_traceback(e_traceback))
Edouard@1433:             return (-1, "RemoteExec script failed!\n\nLine %d: %s\n\t%s" %
andrej@1878:                     (line_no, e_value, script.splitlines()[line_no - 1]))
laurent@699:         return (0, kwargs.get("returnVal", None))