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@1997: from threading import 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@1997: def __init__(self, call, *args, **kwargs): Edouard@1997: 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@1997: do the job by executing the call, and deal with exceptions Edouard@1997: """ Edouard@1997: try: Edouard@1984: call, args, kwargs = self.job Edouard@1997: 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@1997: 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@1997: 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@1997: Edouard@1984: def call(self, *args, **kwargs): Edouard@1984: """ Edouard@1984: creates a job, execute it in worker thread, and deliver result. Edouard@1997: 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@1997: _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@1997: 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@1997: def func_wrapper(*args, **kwargs): Edouard@1984: return MainWorker.call(func, *args, **kwargs) Edouard@1984: return func_wrapper Edouard@1997: 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@1997: # 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@1997: # 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@1997: # 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@1997: # 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, '', '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@1997: old_PLC_filename = os.path.join(self.workingdir, self.CurrentPLCFilename) \ Edouard@1997: if self.CurrentPLCFilename is not None \ Edouard@1997: 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: 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: 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@1997: 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@1997: 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))