def _incref(self, force=False):
with self.lock:
if self.aborting() and (self._forceAbort or not force):
raise se.TaskAborted(six.text_type(self))
self.ref += 1
ref = self.ref
return ref
def _incref(self, force=False):
self.lock.acquire()
try:
if self.aborting() and (self._forceAbort or not force):
raise se.TaskAborted(unicode(self))
self.ref += 1
ref = self.ref
return ref
finally:
self.lock.release()
def __init__(self,
id,
name="",
tag="",
recovery=TaskRecoveryType.none,
priority=TaskPriority.low,
abort_callback=None):
"""
id - Unique ID
name - human readable name
persist - persistency type: auto-clean/manual-clean/not-persistent
"""
if not id:
id = str(uuid.uuid4())
self.metadataVersion = TASK_METADATA_VERSION
self.validateID(id)
self.lock = threading.Lock()
self.callbackLock = threading.Lock()
self.id = str(id)
self.name = name
self.tag = tag
self.priority = priority
self.recoveryPolicy = recovery
self.persistPolicy = TaskPersistType.none
self.cleanPolicy = TaskCleanType.auto
self.store = None
self.defaultException = None
self.state = State(State.init)
self.result = TaskResult(0, "Task is initializing", "")
self.resOwner = resourceManager.Owner(proxy(self), raiseonfailure=True)
self.error = se.TaskAborted("Unknown error encountered")
self.mng = None
self._abort_lock = threading.Lock()
self._abort_callbacks = set()
if abort_callback is not None:
self._abort_callbacks.add(abort_callback)
self._aborting = False
self._forceAbort = False
self.ref = 0
self.recoveries = []
self.jobs = []
self.nrecoveries = 0 # just utility count - used by save/load
self.njobs = 0 # just utility count - used by save/load
# Used by tests to wait for a task from another thread.
self._is_done = threading.Event()
self.log = SimpleLogAdapter(self.log, {"Task": self.id})
def _runJobs(self):
result = ""
code = 100
message = "Unknown Error"
i = 0
j = None
try:
if self.aborting():
raise se.TaskAborted("shutting down")
if not self.state == State.running:
raise se.TaskStateError("%s: can't run Jobs in state %s" %
(self, self.state))
# for now: result is the last job result, jobs are run sequentially
for j in self.jobs:
if self.aborting():
raise se.TaskAborted("shutting down")
self.log.debug("Task.run: running job %s: %s" % (i, j))
self._updateResult(
0, 'running job {0} of {1}'.format(i + 1, len(self.jobs)),
'')
result = self._run(j.run)
if self.aborting():
raise se.TaskAborted("shutting down")
if result is None:
result = ""
i += 1
j = None
self._updateResult(0, "%s jobs completed successfully" % i, result)
self._updateState(State.finished)
self.log.debug('Task.run: exit - success: result %s' % result)
return result
except se.TaskAborted as e:
self.log.debug("aborting: %s", e)
message = e.value
code = e.abortedcode
if not self.aborting():
self.log.error("Aborted exception but not in aborting state")
raise
self._updateResult(code, message, "")
def _run(self, fn, *args, **kargs):
code = 100
message = "Unknown Error"
try:
return fn(*args, **kargs)
except se.StorageException as e:
code = e.code
message = e.message
self._setError(e)
except Exception as e:
message = unicode(e)
self._setError(e)
except:
self._setError()
self.log.debug("Task._run: %s %s %s failed - stopping task", self,
args, kargs)
self.stop()
raise se.TaskAborted(message, code)
def _setError(self, e=se.TaskAborted("Unknown error encountered")):
self.log.error("Unexpected error", exc_info=True)
self.error = e
def _setError(self, e=se.TaskAborted("Unknown error encountered"),
expected=False):
if not expected:
self.log.exception("Unexpected error")
self.error = e
