def test_acquire_error(self, locktype, tmp_manager):
owner_object = OwnerObject()
owner = rm.Owner(owner_object, raiseonfailure=True)
# The error resource factory is expected to raise a ResourceException
# upon creation of any resource.
with pytest.raises(se.ResourceException):
owner.acquire("error", "any", locktype, timeout_ms=1)
owner.releaseAll()
def test_acquire_missing_resource(self, locktype, tmp_manager):
owner_object = OwnerObject()
owner = rm.Owner(owner_object, raiseonfailure=True)
# The null resource factory always determines that the requested
# resource does not exist, hence ResourceDoesNotExist is expected.
with pytest.raises(rm.ResourceDoesNotExist) as e:
owner.acquire("null", "no_such_resource", locktype, timeout_ms=1)
error_str = str(e)
assert "no_such_resource" in error_str
assert "null" in error_str
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 test_acquire_twice(self, old_locktype, new_locktype, tmp_manager):
owner_object = OwnerObject()
owner = rm.Owner(owner_object, raiseonfailure=True)
# Acquire a resource within time period allowing it to happen
owner.acquire("storage", "resource", old_locktype, timeout_ms=5000)
# Requiring an already acquired resource should fail immediately
with pytest.raises(rm.ResourceAlreadyAcquired) as e:
owner.acquire("storage", "resource", new_locktype, timeout_ms=1)
owner.releaseAll()
error_str = str(e)
assert "storage" in error_str
assert "resource" in error_str
assert "fake_id" in error_str
def test_acquire_release_resource(self, tmp_manager):
resources = [
("storage", "A", rm.SHARED),
("storage", "B", rm.SHARED),
("storage", "C", rm.EXCLUSIVE),
]
actions = [
("acquired", "storage", "A", rm.SHARED),
("acquired", "storage", "B", rm.SHARED),
("acquired", "storage", "C", rm.EXCLUSIVE),
("released", "storage", "A"),
("released", "storage", "B"),
("released", "storage", "C"),
]
owner_object = OwnerObject()
owner = rm.Owner(owner_object, raiseonfailure=True)
for namespace, resources, locktype in resources:
owner.acquire(namespace, resources, locktype, timeout_ms=5000)
owner.releaseAll()
assert owner_object.actions == actions
def test_acquire_invalid_locktype(self, locktype, tmp_manager):
owner_object = OwnerObject()
owner = rm.Owner(owner_object, raiseonfailure=True)
with pytest.raises(se.ResourceException):
owner.acquire("storage", "resource", locktype, timeout_ms=1)
assert owner_object.actions == []
def test_release_empty_resources(self, tmp_manager):
owner_object = OwnerObject()
owner = rm.Owner(owner_object, raiseonfailure=True)
owner.releaseAll()
assert owner_object.actions == []
