def test_tasks_with_handler():
from arbiter.task import create_task
from arbiter.sync import run_tasks
from arbiter.utils import retry_handler
foo = create_task(
len,
[1, 2, 3],
handler=retry_handler(retries=5, delay=timedelta(), conditions=[]),
)
run_tasks((foo, ))
def test_no_dependencies():
"""
run dependency-less tasks
"""
from arbiter.sync import run_tasks
executed_tasks = set()
def make_task(name, dependencies=(), should_succeed=True):
"""
Make a task
"""
from arbiter.task import create_task
function = succeed if should_succeed else fail
return create_task(lambda: executed_tasks.add(name) or function(),
name=name,
dependencies=dependencies)
results = run_tasks((make_task('foo'), make_task('bar'), make_task('baz'),
make_task('fail', should_succeed=False)))
assert_equals(executed_tasks, frozenset(('foo', 'bar', 'baz', 'fail')))
assert_equals(results.completed, frozenset(('foo', 'bar', 'baz')))
assert_equals(results.failed, frozenset(('fail', )))
def test_tasks_with_handler():
from arbiter.task import create_task
from arbiter.sync import run_tasks
from arbiter.utils import retry_handler
foo = create_task(
len,
[1, 2, 3],
handler=retry_handler(
retries=5,
delay=timedelta(),
conditions=[]
),
)
run_tasks((foo,))
def test_chain():
"""
run a dependency chain
"""
from arbiter.sync import run_tasks
executed_tasks = set()
def make_task(name, dependencies=(), should_succeed=True):
"""
Make a task
"""
from arbiter.task import create_task
function = succeed if should_succeed else fail
return create_task(
lambda: executed_tasks.add(name) or function(),
name=name,
dependencies=dependencies
)
results = run_tasks(
(
make_task('foo'),
make_task('bar', ('foo',)),
make_task('baz', ('bar',), should_succeed=False),
make_task('qux', ('baz',)),
)
)
assert_equals(executed_tasks, frozenset(('foo', 'bar', 'baz',)))
assert_equals(results.completed, frozenset(('foo', 'bar',)))
assert_equals(results.failed, frozenset(('baz', 'qux')))
def test_empty():
"""
Solve no tasks
"""
from arbiter.sync import run_tasks
results = run_tasks(())
assert_equals(results.completed, frozenset())
assert_equals(results.failed, frozenset())
def test_empty():
"""
Solve no tasks
"""
from arbiter.sync import run_tasks
results = run_tasks(())
assert_equals(results.completed, frozenset())
assert_equals(results.failed, frozenset())
def provision_resources(self, resources=None):
"""
Handles building a list of create tasks and
running them with dynamic dependency handling via
run_tasks. Roles back changes in case of failure.
ke: if provisioning fails any already provisioned resource
are deprovision automatically.
Args:
resources (list, optional): a list of the subset of resources in the stack
to provision. Defaults to all of them.
Raises:
StackError: if not all resources are successfully provisioned.
"""
logger.debug('Building create tasks list')
if resources is None:
logger.debug(
'No resources list provided. '
'Provisioning all stack resources.'
)
resources = self._resources
tasks = []
for resource in resources:
logger.info(
'Stack.provision_resources - %s marked for creation',
resource.local_name
)
logger.debug(
'Stack.provision_resources - Dependencies: %s',
resource.get_dependencies()
)
tasks.append(
create_task(
resource.local_name,
resource.create,
tuple(dep.local_name for dep in resource.get_dependencies())
)
)
# This should be in a try except cause arbiter won't catch anything
logger.info("Provisioning Resources ...")
results = run_tasks(tasks)
tasks_passed(
results,
logger,
msg='Failed to provision resources',
exception=StackError
)
def create(self):
tasks = (
create_task('create', self._create_group),
create_task(
'check', self._check_created, ('create',),
retries=self.stack.settings["retries"],
delay=self.stack.settings["delay"]
)
)
results = run_tasks(tasks)
return tasks_passed(
results, self._logger,
msg='Failed to provision security group {}'.format(self._local_name)
)
def test_tree():
"""
run a dependency tree
"""
from arbiter.sync import run_tasks
executed_tasks = set()
def make_task(name, dependencies=(), should_succeed=True):
"""
Make a task
"""
from arbiter.task import create_task
function = succeed if should_succeed else fail
return create_task(lambda: executed_tasks.add(name) or function(),
name=name,
dependencies=dependencies)
results = run_tasks((
make_task('foo'),
make_task('bar', ('foo', )),
make_task('baz', ('bar', ), should_succeed=False),
make_task('qux', ('baz', )),
make_task('bell', ('bar', )),
make_task('alugosi', ('bell', ), should_succeed=False),
make_task('lorem'),
make_task('ipsum', ('lorem', )),
make_task('ouroboros', ('ouroboros', )),
make_task('tick', ('tock', )),
make_task('tock', ('tick', )),
make_task('success', ('foo', 'lorem')),
make_task('failed', ('qux', 'lorem')),
))
assert_equals(
executed_tasks,
frozenset(('foo', 'bar', 'baz', 'bell', 'alugosi', 'lorem', 'ipsum',
'success')))
assert_equals(
results.completed,
frozenset(('foo', 'bar', 'bell', 'lorem', 'ipsum', 'success')))
assert_equals(
results.failed,
frozenset(
('baz', 'qux', 'alugosi', 'ouroboros', 'tick', 'tock', 'failed')))
def test_with_data():
"""
Pass data.
"""
from arbiter.sync import run_tasks
from arbiter.task import create_task
data = [4, 5, 6]
def myfunc(val=-1):
"""
Modify some data which will be passed from another task.
"""
data.append(val)
foo = create_task(len, [1, 2], name='foo')
bar = create_task(myfunc, name='bar', val=foo)
results = run_tasks((foo, bar))
assert_equals(results.exceptions, [])
assert_equals(results.completed, frozenset(('foo', 'bar')))
assert_equals(data, [4, 5, 6, 2])
def test_with_data():
"""
Pass data.
"""
from arbiter.sync import run_tasks
from arbiter.task import create_task
data = [4, 5, 6]
def myfunc(val=-1):
"""
Modify some data which will be passed from another task.
"""
data.append(val)
foo = create_task(len, [1, 2], name='foo')
bar = create_task(myfunc, name='bar', val=foo)
results = run_tasks((foo, bar))
assert_equals(results.exceptions, [])
assert_equals(results.completed, frozenset(('foo', 'bar')))
assert_equals(data, [4, 5, 6, 2])
def deprovision_resources(self, resources=None):
"""
Handles building a list of destroy tasks and
running them with dynamic dependency handling via
run_tasks.
NOTE: We are also responsible for inverting the
dependency cases to the standard creation dependencies.
Args:
resources (list, optional): a list of the subset of resources in the stack
to deprovision. Defaults to all of them.
Raises:
StackError: if not all resources are successfully deprovisioned.
"""
logger.debug('Building destroy tasks list')
if resources is None:
logger.debug(
'No resources list provided. '
'Deprovisioning all stack resources.'
)
resources = self._resources
inverse_dependencies = {}
for resource in resources:
inverse_dependencies[resource.local_name] = []
for dep in resource.get_dependencies():
if dep.local_name not in inverse_dependencies:
inverse_dependencies[dep.local_name] = []
inverse_dependencies[dep.local_name].append(resource.local_name)
tasks = []
for resource in resources:
logger.info(
'Stack.deprovision_resources - %s marked for deletion',
resource.local_name
)
logger.debug(
'Stack.deprovision_resources - Dependencies: %s',
inverse_dependencies[resource.local_name]
)
tasks.append(
create_task(
resource.local_name,
resource.destroy,
tuple(dep for dep in inverse_dependencies[resource.local_name])
)
)
# TODO: Should check for failed tasks and throw an exception and traceback
# This should be in a try except
logger.info("Deprovisioning Resources ...")
results = run_tasks(tasks)
tasks_passed(
results,
logger,
msg='Failed to deprovision resources',
exception=StackError
)
def test_tree():
"""
run a dependency tree
"""
from arbiter.sync import run_tasks
executed_tasks = set()
def make_task(name, dependencies=(), should_succeed=True):
"""
Make a task
"""
from arbiter.task import create_task
function = succeed if should_succeed else fail
return create_task(
lambda: executed_tasks.add(name) or function(),
name=name,
dependencies=dependencies
)
results = run_tasks(
(
make_task('foo'),
make_task('bar', ('foo',)),
make_task('baz', ('bar',), should_succeed=False),
make_task('qux', ('baz',)),
make_task('bell', ('bar',)),
make_task('alugosi', ('bell',), should_succeed=False),
make_task('lorem'),
make_task('ipsum', ('lorem',)),
make_task('ouroboros', ('ouroboros',)),
make_task('tick', ('tock',)),
make_task('tock', ('tick',)),
make_task('success', ('foo', 'lorem')),
make_task('failed', ('qux', 'lorem')),
)
)
assert_equals(
executed_tasks,
frozenset(
(
'foo', 'bar', 'baz', 'bell', 'alugosi',
'lorem', 'ipsum', 'success'
)
)
)
assert_equals(
results.completed,
frozenset(
('foo', 'bar', 'bell', 'lorem', 'ipsum', 'success')
)
)
assert_equals(
results.failed,
frozenset(
('baz', 'qux', 'alugosi', 'ouroboros', 'tick', 'tock', 'failed')
)
)