def startup(self):
""" Start a background thread that periodically run()s"""
super(TaskRegistry, self).startup()
from Ganga.Core.GangaThread import GangaThread
self._main_thread = GangaThread(name="GangaTasks",
target=self._thread_main)
self._main_thread.start()
# create a registry flusher
self.flush_thread = RegistryFlusher(self, 'TaskRegistryFlusher')
self.flush_thread.start()
def startup(self):
self._needs_metadata = True
super(JobRegistry, self).startup()
if len(self.metadata.ids()) == 0:
from Ganga.GPIDev.Lib.JobTree import JobTree
jt = JobTree()
stripProxy(jt)._setRegistry(self.metadata)
self.metadata._add(jt)
self.jobtree = self.metadata[self.metadata.ids()[-1]]
self.flush_thread = RegistryFlusher(self)
self.flush_thread.start()
def startup(self):
""" Start a background thread that periodically run()s"""
super(TaskRegistry, self).startup()
from Ganga.Core.GangaThread import GangaThread
self._main_thread = GangaThread(name="GangaTasks", target=self._thread_main)
self._main_thread.start()
# create a registry flusher
self.flush_thread = RegistryFlusher(self)
self.flush_thread.start()
def startup(self):
self._needs_metadata = True
super(JobRegistry, self).startup()
if len(self.metadata.ids()) == 0:
from Ganga.GPIDev.Lib.JobTree import JobTree
jt = JobTree()
stripProxy(jt)._setRegistry(self.metadata)
self.metadata._add(jt)
self.jobtree = self.metadata[self.metadata.ids()[-1]]
self.flush_thread = RegistryFlusher(self)
self.flush_thread.start()
class TaskRegistry(Registry):
def __init__(self, name, doc, dirty_flush_counter=10, update_index_time=30):
super(TaskRegistry, self).__init__( name, doc, dirty_flush_counter=dirty_flush_counter, update_index_time=update_index_time )
self._main_thread = None
self.stored_slice = TaskRegistrySlice(self.name)
self.stored_slice.objects = self
self.stored_proxy = TaskRegistrySliceProxy(self.stored_slice)
def getSlice(self):
return self.stored_slice
def getProxy(self):
return self.stored_proxy
def getIndexCache(self, obj):
if obj._data is None:
raise Exception("Currently don't support Index Caching")
cached_values = ['status', 'id', 'name']
c = {}
for cv in cached_values:
if cv in obj._data:
c[cv] = getattr(obj, cv)
this_slice = TaskRegistrySlice("tmp")
for dpv in this_slice._display_columns:
c["display:" + dpv] = this_slice._get_display_value(obj, dpv)
return c
def _thread_main(self):
""" This is an internal function; the main loop of the background thread """
from Ganga.Core.GangaRepository import getRegistry
while getRegistry("jobs").hasStarted() is not True:
time.sleep(0.1)
if self._main_thread is None or self._main_thread.should_stop():
return
while True:
from Ganga.Core import monitoring_component
if (not monitoring_component is None and monitoring_component.enabled) or config['ForceTaskMonitoring']:
break
time.sleep(0.1)
if self._main_thread is None or self._main_thread.should_stop():
return
# setup the tasks - THIS IS INCOMPATIBLE WITH CONCURRENCY
# and must go away soon
for tid in self.ids():
try:
self[tid].startup()
except Exception as err:
logger.error("Unknown/Unexpected Error in starting up tasks main loop")
logger.error("Exiting: err=%s" % str(err))
return
logger.debug("Entering main loop")
# Main loop
while self._main_thread is not None and not self._main_thread.should_stop():
# If monitoring is enabled (or forced for Tasks) loop over each one and update
if (config['ForceTaskMonitoring'] or monitoring_component.enabled) and not config['disableTaskMon']:
for tid in self.ids():
logger.debug("Running over tid: %s" % str(tid))
try:
p = self[tid]
p.update()
except Exception as x:
logger.error(
"Exception occurred in task monitoring loop: %s %s\nThe offending task was paused." % (x.__class__, x))
type_, value_, traceback_ = sys.exc_info()
logger.error("Full traceback:\n %s" % ' '.join(
traceback.format_exception(type_, value_, traceback_)))
p.pause()
if self._main_thread.should_stop():
break
if self._main_thread.should_stop():
break
logger.debug("TaskRegistry Sleeping for: %s seconds" % str(config['TaskLoopFrequency']))
# Sleep interruptible for 10 seconds
for i in range(0, int(config['TaskLoopFrequency'] * 100)):
if self._main_thread.should_stop():
break
time.sleep(0.01)
def startup(self):
""" Start a background thread that periodically run()s"""
super(TaskRegistry, self).startup()
from Ganga.Core.GangaThread import GangaThread
self._main_thread = GangaThread(name="GangaTasks", target=self._thread_main)
self._main_thread.start()
# create a registry flusher
self.flush_thread = RegistryFlusher(self)
self.flush_thread.start()
def shutdown(self):
self.flush_thread.join()
super(TaskRegistry, self).shutdown()
def stop(self):
if self._main_thread is not None:
self._main_thread.stop()
self._main_thread.join()
class JobRegistry(Registry):
def __init__(self, name, doc, dirty_flush_counter=10, update_index_time=30, dirty_max_timeout=60, dirty_min_timeout=30):
super(JobRegistry, self).__init__(name, doc, dirty_flush_counter, update_index_time, dirty_max_timeout, dirty_min_timeout)
self.stored_slice = JobRegistrySlice(self.name)
self.stored_slice.objects = self
self.stored_proxy = JobRegistrySliceProxy(self.stored_slice)
def getSlice(self):
return self.stored_slice
def getProxy(self):
return self.stored_proxy
def getIndexCache(self, obj):
cached_values = ['status', 'id', 'name']
cache = {}
for cv in cached_values:
#print("cv: %s" % str(cv))
cache[cv] = getattr(obj, cv)
#logger.info("Setting: %s = %s" % (str(cv), str(cache[cv])))
this_slice = JobRegistrySlice("jobs")
for dpv in this_slice._display_columns:
#logger.debug("Storing: %s" % str(dpv))
try:
value = this_slice._get_display_value(obj, dpv)
cache["display:" + dpv] = value
except Exception as err:
value = None
del this_slice
# store subjob status
if hasattr(obj, "subjobs"):
cache["subjobs:status"] = []
if hasattr(obj.subjobs, "getAllCachedData"):
for sj in obj.subjobs.getAllCachedData():
cache["subjobs:status"].append(sj['status'])
else:
for sj in obj.subjobs:
cache["subjobs:status"].append(sj.status)
#print("Cache: %s" % str(cache))
return cache
def startup(self):
self._needs_metadata = True
super(JobRegistry, self).startup()
if len(self.metadata.ids()) == 0:
from Ganga.GPIDev.Lib.JobTree import JobTree
jt = JobTree()
stripProxy(jt)._setRegistry(self.metadata)
self.metadata._add(jt)
self.jobtree = self.metadata[self.metadata.ids()[-1]]
self.flush_thread = RegistryFlusher(self)
self.flush_thread.start()
def shutdown(self):
self.flush_thread.join()
super(JobRegistry, self).shutdown()
def getJobTree(self):
return self.jobtree
def _remove(self, obj, auto_removed=0):
super(JobRegistry, self)._remove(obj, auto_removed)
try:
self.jobtree.cleanlinks()
except Exception as err:
logger.debug("Exception in _remove: %s" % str(err))
pass
class TaskRegistry(Registry):
def __init__(self, name, doc):
super(TaskRegistry, self).__init__(name, doc)
self._main_thread = None
self.stored_slice = TaskRegistrySlice(self.name)
self.stored_slice.objects = self
self.stored_proxy = TaskRegistrySliceProxy(self.stored_slice)
def getSlice(self):
return self.stored_slice
def getProxy(self):
return self.stored_proxy
def getIndexCache(self, obj):
cached_values = ['status', 'id', 'name']
c = {}
for cv in cached_values:
if hasattr(obj, cv):
c[cv] = getattr(obj, cv)
this_slice = TaskRegistrySlice("tmp")
for dpv in this_slice._display_columns:
c["display:" + dpv] = this_slice._get_display_value(obj, dpv)
return c
def _thread_main(self):
""" This is an internal function; the main loop of the background thread """
from Ganga.Core.GangaRepository import getRegistry
while getRegistry("jobs").hasStarted() is not True:
time.sleep(0.1)
if self._main_thread is None or self._main_thread.should_stop():
return
while True:
from Ganga.Core import monitoring_component
if (not monitoring_component is None
and monitoring_component.enabled
) or config['ForceTaskMonitoring']:
break
time.sleep(0.1)
if self._main_thread is None or self._main_thread.should_stop():
return
# setup the tasks - THIS IS INCOMPATIBLE WITH CONCURRENCY
# and must go away soon
for tid in self.ids():
try:
self[tid].startup()
except Exception as err:
logger.error(
"Unknown/Unexpected Error in starting up tasks main loop")
logger.error("Exiting: err=%s" % str(err))
return
logger.debug("Entering main loop")
# Main loop
while self._main_thread is not None and not self._main_thread.should_stop(
):
# If monitoring is enabled (or forced for Tasks) loop over each one and update
if (config['ForceTaskMonitoring'] or monitoring_component.enabled
) and not config['disableTaskMon']:
for tid in self.ids():
logger.debug("Running over tid: %s" % str(tid))
try:
p = self[tid]
p.update()
except Exception as x:
logger.error(
"Exception occurred in task monitoring loop: %s %s\nThe offending task was paused."
% (x.__class__, x))
type_, value_, traceback_ = sys.exc_info()
logger.error("Full traceback:\n %s" % ' '.join(
traceback.format_exception(type_, value_,
traceback_)))
p.pause()
if self._main_thread.should_stop():
break
if self._main_thread.should_stop():
break
logger.debug("TaskRegistry Sleeping for: %s seconds" %
str(config['TaskLoopFrequency']))
# Sleep interruptible for 10 seconds
for i in range(0, int(config['TaskLoopFrequency'] * 100)):
if self._main_thread.should_stop():
break
time.sleep(0.01)
def startup(self):
""" Start a background thread that periodically run()s"""
super(TaskRegistry, self).startup()
from Ganga.Core.GangaThread import GangaThread
self._main_thread = GangaThread(name="GangaTasks",
target=self._thread_main)
self._main_thread.start()
# create a registry flusher
self.flush_thread = RegistryFlusher(self, 'TaskRegistryFlusher')
self.flush_thread.start()
def shutdown(self):
self.flush_thread.join()
super(TaskRegistry, self).shutdown()
def stop(self):
if self._main_thread is not None:
self._main_thread.stop()
self._main_thread.join()
class JobRegistry(Registry):
def __init__(self, name, doc):
super(JobRegistry, self).__init__(name, doc)
self.stored_slice = JobRegistrySlice(self.name)
self.stored_slice.objects = self
self.stored_proxy = JobRegistrySliceProxy(self.stored_slice)
def getSlice(self):
return self.stored_slice
def getProxy(self):
return self.stored_proxy
def getIndexCache(self, obj):
cached_values = ['status', 'id', 'name']
cache = {}
for cv in cached_values:
#print("cv: %s" % str(cv))
cache[cv] = getattr(obj, cv)
#logger.info("Setting: %s = %s" % (str(cv), str(cache[cv])))
this_slice = JobRegistrySlice("jobs")
for dpv in this_slice._display_columns:
#logger.debug("Storing: %s" % str(dpv))
try:
value = this_slice._get_display_value(obj, dpv)
cache["display:" + dpv] = value
except Exception as err:
value = None
del this_slice
# store subjob status
if hasattr(obj, "subjobs"):
cache["subjobs:status"] = []
if hasattr(obj.subjobs, "getAllCachedData"):
for sj in obj.subjobs.getAllCachedData():
cache["subjobs:status"].append(sj['status'])
else:
for sj in obj.subjobs:
cache["subjobs:status"].append(sj.status)
#print("Cache: %s" % str(cache))
return cache
def startup(self):
self._needs_metadata = True
super(JobRegistry, self).startup()
if len(self.metadata.ids()) == 0:
from Ganga.GPIDev.Lib.JobTree import JobTree
jt = JobTree()
stripProxy(jt)._setRegistry(self.metadata)
self.metadata._add(jt)
self.jobtree = self.metadata[self.metadata.ids()[-1]]
self.flush_thread = RegistryFlusher(self)
self.flush_thread.start()
def shutdown(self):
self.flush_thread.join()
super(JobRegistry, self).shutdown()
def getJobTree(self):
return self.jobtree
def _remove(self, obj, auto_removed=0):
super(JobRegistry, self)._remove(obj, auto_removed)
try:
self.jobtree.cleanlinks()
except Exception as err:
logger.debug("Exception in _remove: %s" % str(err))
pass
