return res

class Server(object):

def __init__(self, servicename, ip_addr, port,

workdir, argv,

sys.stdout.flush()

def PyroLoop(self, when_ready):

while self.continueloop:

Pyro.config.PYRO_MULTITHREADED = 0

# unwanted diconnection when IDE is kept busy for long periods

self.daemon.setTimeout(60)

if self._to_be_published():

self.servicepublisher = ServicePublisher.ServicePublisher()

self.plcobj.StartPLC()

self.plcobj.StatusChange()

if enabletwisted:

import warnings

with warnings.catch_warnings():

if havetwisted:

# reactor._installSignalHandlersAgain()

def ui_thread_target():

# signal not working in non-main thread

reactor.run(installSignalHandlers=False)

ui_thread_target = app.MainLoop

ui_thread.start()

# This order ui loop to unblock main thread when ready.

if havetwisted:

wx.CallAfter(ui_thread_started.release)

# Wait for ui thread to be effective

import re

import tempfile

from types import ListType

from datetime import datetime

from weakref import WeakKeyDictionary

from itertools import izip

values_buffer.append((value, forced))

self.DebugTicks.append(debug_tick)

buffers, self.DebugValuesBuffers = (self.DebugValuesBuffers,

[list() for dummy in xrange(len(self.TracedIECPath))])

if IECPath not in self.IECdebug_datas:

return

# If no entry exist, create a new one with a fresh WeakKeyDictionary

IECdebug_data = self.IECdebug_datas.get(IECPath, None)

IECdebug_data[2] = "Forced"

IECdebug_data[3] = fvalue

self.ReArmDebugRegisterTimer()

def ReleaseDebugIECVariable(self, IECPath):

if IECPath not in self.IECdebug_datas:

return

# If no entry exist, create a new one with a fresh WeakKeyDictionary

IECdebug_data = self.IECdebug_datas.get(IECPath, None)

IECdebug_data[2] = "Registered"

IECdebug_data[3] = None

self.ReArmDebugRegisterTimer()

def CallWeakcallables(self, IECPath, function_name, *cargs):

return -1, "No runtime connected!"

return self._connector.RemoteExec(script, **kwargs)

def DispatchDebugValuesProc(self, event):

debug_ticks, buffers = self.SnapshotAndResetDebugValuesBuffers()

start_time = time.time()

LOCATION_CONFNODE, \

LOCATION_VAR_MEMORY

from nodelist import NodeList

from nodemanager import NodeManager

import gen_cfile

import eds_utils

import canfestival_config as local_canfestival_config # pylint: disable=import-error

from commondialogs import CreateNodeDialog

from subindextable import IECTypeConversion, SizeConversion

from canfestival import config_utils

"GetPLCstatus": ("Broken", None),

"RemoteExec": (-1, "RemoteExec script failed!")

}

class PyroProxyProxy(object):

"""

A proxy proxy class to handle Beremiz Pyro interface specific behavior.

from __future__ import absolute_import

import thread

import ctypes

import os

import sys

"""

job to be executed by a worker

"""

self.result = None

self.success = False

self.exc_info = None

def do(self):

"""

"""

call, args, kwargs = self.job

self.success = True

except Exception:

self.success = False

self.free = Condition(self.mutex)

self.job = None

"""

meant to be called by worker thread (blocking)

"""

self._threadID = thread.get_ident()

if args or kwargs:

# result is ignored

self.mutex.acquire()

while not self._finish:

else:

self.free.notify()

self.mutex.release()

def call(self, *args, **kwargs):

"""

creates a job, execute it in worker thread, and deliver result.

meant to be called by non-worker threads, but this is accepted.

blocking until job done

"""

if self._threadID == thread.get_ident() or self._threadID is None:

# if caller is worker thread execute immediately

return _job.result

else:

raise _job.exc_info[0], _job.exc_info[1], _job.exc_info[2]

def quit(self):

"""

unblocks main thread, and terminate execution of runloop()

def RunInMain(func):

return MainWorker.call(func, *args, **kwargs)

return func_wrapper

class PLCObject(pyro.ObjBase):

def __init__(self, server):

# First task of worker -> no @RunInMain

def AutoLoad(self):

try:

self.CurrentPLCFilename = open(

self._GetMD5FileName(),

if self._ResetLogCount is not None:

self._ResetLogCount()

def GetLogCount(self, level):

if self._GetLogCount is not None:

return int(self._GetLogCount(level))

if exp is not None:

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

def PythonRuntimeInit(self):

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

self.python_runtime_vars = globals().copy()

self.PythonRuntimeCall("init")

def PythonRuntimeCleanup(self):

if self.python_runtime_vars is not None:

self.PythonRuntimeCall("cleanup")

NewFileName = md5sum + lib_ext

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

new_PLC_filename = os.path.join(self.workingdir, NewFileName)

# Some platform (i.e. Xenomai) don't like reloading same .so file

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

self.PLCStatus = "Empty"

try:

if replace_PLC_shared_object:

os.remove(old_PLC_filename)

else:

self._suspendDebug(True)

def _TracesSwap(self):

self.LastSwapTrace = time()

if self.TraceThread is None and self.PLCStatus == "Started":

res = self._GetDebugData(ctypes.byref(tick),

ctypes.byref(size),

if res == 0:

if size.value:

TraceBuffer = ctypes.string_at(buff.value, size.value)

self._FreeDebugData()

self.PLClibraryLock.release()

# leave thread if GetDebugData isn't happy.

if res != 0:

break