def pipeline_build_gbs_images(config):
if 'build_containers' not in config:
config['build_containers'] = dict()
if 'base_containers' not in config:
config['base_containers'] = dict()
adhesive.process_start()\
.branch_start()\
.task("Checkout Code")\
.task("Fetch Base Images")\
.branch_end()\
.branch_start()\
.task("Ensure Tooling: behave")\
.branch_end()\
.branch_start()\
.task("Collect Images to Push")\
.branch_end()\
.subprocess_start("Base Images")\
.task("Create Base Image Image {loop.key}", loop="base_containers")\
.subprocess_end()\
.subprocess_start("Base Images")\
.task("Create Build Image Image {loop.key}", loop="build_containers")\
.subprocess_end()\
.task("Run Tool: behave")\
.task("Push Image {loop.value}", loop="containers_to_push")\
.process_end()\
.build(initial_data=config)
import adhesive
@adhesive.task("Loop on empty collection")
def loop_on_empty_collection(context):
raise Exception("shold not execute")
@adhesive.task("Task after loop")
def task_after_loop(context):
print("task after loop")
adhesive.process_start().task(
"Loop on empty collection",
loop="empty_collection").task("Task after loop").process_end().build(
initial_data={"empty_collection": []})
import adhesive
import uuid
import unittest
test = unittest.TestCase()
@adhesive.task("Running {loop.value} on {loop.parent_loop.value}")
def run_simple_task(context):
print(f"{context.task_name}")
context.data.execution_count.add(str(uuid.uuid4()))
data = (adhesive.process_start().subprocess_start(
"Run builds on {loop.value}", loop="platforms").task(
"Running {loop.value} on {loop.parent_loop.value}",
loop="tasks").subprocess_end().build(
initial_data={
"execution_count": set(),
"platforms": ["linux", "windows", "solaris"],
"tasks": ["archive", "compute", "list"],
}))
test.assertEqual(9, len(data.execution_count))
@adhesive.task('Remove DocBook documentation')
def remove_docbook_documentation(context):
context.workspace.run("""
rm README.docbook.xml
""")
adhesive.process_start()\
.subprocess_start("Render Documents", lane="local")\
.branch_start()\
.task("Render AsciiDoc to DocBook", lane="local")\
.branch_end()\
.branch_start()\
.task("Render AsciiDoc to PDF", lane="local")\
.branch_end()\
.subprocess_end()\
.subprocess_start("Convert Documents", lane="local")\
.branch_start()\
.task("Convert DocBook to Markdown", lane="local")\
.branch_end()\
.branch_start()\
.task("Convert DocBook to ReStructuredText", lane="local")\
.task("Validate ReStructuredText", lane="local")\
.branch_end()\
.subprocess_end()\
.task("Remove DocBook documentation", lane="local")\
.process_end()\
.build()
import adhesive
@adhesive.task("Loop on empty condition")
def loop_on_empty_condition(context):
raise Exception("shold not execute")
adhesive.process_start().task(
"Loop on empty condition", loop="false_value"
).process_end().build(initial_data={"false_value": False})
import adhesive
@adhesive.lane("Used Lane")
def used_lane(context):
yield context.workspace
@adhesive.task("Used Task")
def used_task(context):
pass
@adhesive.task("Not Used Task")
def not_used_task(context):
pass
@adhesive.usertask("Not Used UserTask")
def not_used_user(context):
pass
@adhesive.lane("Not Used Lane")
def not_used_lane(context):
pass
adhesive.process_start().task("Used Task",
lane="Used Lane").process_end().build()
context.data.third_task.add(str(uuid.uuid4()))
@adhesive.task("Fourth task")
def fourth_task(context):
context.data.fourth_task.add(str(uuid.uuid4()))
# we run it with wait_tasks = false because we want to ensure we have only one
# connection happening.
data = (adhesive.process_start().task("First task").task(
"Second task",
when="data.not_skip").task("Second task", when="data.not_skip").task(
"Third task",
when="data").task("Third task",
when="data").task("Fourth task").process_end().build(
initial_data={
"first_task": set(),
"second_task": set(),
"third_task": set(),
"fourth_task": set(),
}))
test.assertEqual(1, len(data.first_task),
"Expected a single first task execution")
test.assertEqual(0, len(data.second_task),
"Expected no second task executions")
test.assertEqual(2, len(data.third_task),
"Expected a double third task execution")
test.assertEqual(1, len(data.fourth_task),
"Expected a single fourth task execution")
import adhesive
import sys
@adhesive.task("Raise Exception")
def raise_exception(context):
raise Exception("ded")
@adhesive.task("Wait 2 seconds")
def wait_2_secs(context):
context.workspace.run(
"""
sleep 2
"""
)
adhesive.process_start().branch_start().task(
"Raise Exception"
).branch_end().branch_start().task("Wait 2 seconds").branch_end().process_end().build()
import adhesive
import uuid
@adhesive.task("Run in parallel")
def context_to_run(context):
if not context.data.executions:
context.data.executions = set()
context.data.executions.add(str(uuid.uuid4()))
data = (adhesive.process_start().branch_start().subprocess_start().task(
"Run in parallel", loop="context.data.items"
).subprocess_end().branch_end().branch_start().subprocess_start().task(
"Run in parallel", loop="context.data.items").subprocess_end().branch_end(
).process_end().build(initial_data={"items": [1, 2, 3, 4, 5]}))
assert len(data.executions) == 10
import adhesive
from adhesive.workspace import noop
import unittest
test = unittest.TestCase()
@adhesive.lane("custom")
def lane_custom(context):
with noop.inside(context.workspace) as w:
yield w
@adhesive.task("Task")
def simple_task(context):
test.assertTrue(isinstance(context.workspace, noop.NoopWorkspace))
adhesive.process_start().task("Task", lane="custom").process_end().build()
context.data.lane_executions.add(str(uuid.uuid4()))
yield w
@adhesive.task(re="Running (.*) on (.*)")
def run_simple_task(context, task_name, platform):
print(f"Running {task_name} on {platform}")
test.assertTrue(
isinstance(context.workspace, noop.NoopWorkspace),
"The workspace from the lane was not present",
)
context.data.task_executions.add(str(uuid.uuid4()))
data = (adhesive.process_start().subprocess_start(
"Run builds on {loop.value}", loop="platforms",
lane="custom").task("Running {loop.value} on {loop.parent_loop.value}",
loop="tasks",
lane="custom").subprocess_end().build(
initial_data={
"task_executions": set(),
"lane_executions": set(),
"platforms": ["linux", "windows", "mac"],
"tasks": ["archive", "untar", "backup"],
}))
test.assertEqual(9, len(data.task_executions))
test.assertEqual(1, len(data.lane_executions))
import adhesive
import unittest
test = unittest.TestCase()
@adhesive.task("Loop item")
def loop_item(context):
context.data.execution_count += 1
print(context.data.collection)
if isinstance(context.data.collection, list):
context.data.collection.pop()
else:
context.data.collection = ["a", "b", "c"]
data = (adhesive.process_start().task(
"Loop item", loop="collection").process_end().build(initial_data={
"execution_count": 0,
"collection": True
}))
test.assertEqual(4, data.execution_count, "It should have executed four times")
import unittest
test = unittest.TestCase()
@adhesive.task("Simple Looped Task")
def test_loop(context):
test.assertEqual("simple", context.loop.expression)
@adhesive.task("Simple Nested Loop Task")
def test_nested_task(context):
test.assertEqual("nested", context.loop.expression)
test.assertEqual("parents", context.loop.parent_loop.expression)
@adhesive.task("Simple Nested Task")
def simple_nested_task(context) -> None:
test.assertEqual("parents", context.loop.expression)
adhesive.process_start().task(
"Simple Looped Task", loop="simple").subprocess_start(loop="parents").task(
"Simple Nested Loop Task",
loop="nested").task("Simple Nested Task").subprocess_end().build(
initial_data={
"simple": [1, 2, 3],
"nested": [1, 2, 3],
"parents": [1, 2, 3],
})
@adhesive.task("Prepare data")
def prepare_data(context):
context.data.data_is_set = True
@adhesive.task("Run if data is set via attribute name")
def run_if_data_is_set_via_attribute_name(context):
context.data.set_via_attribute_name = True
@adhesive.task("Run if data is set via data.attribute")
def run_if_data_is_set_via_data_attribute(context):
context.data.set_via_data_attribute = True
@adhesive.task("Run if data is set via context.data.attribute")
def run_if_data_is_set_via_context_data_attribute(context):
context.data.set_via_context_data_attribute = True
data = (adhesive.process_start().task("Prepare data").task(
"Run if data is set via attribute name", when="data_is_set").task(
"Run if data is set via data.attribute", when="data.data_is_set").task(
"Run if data is set via context.data.attribute",
when="context.data.data_is_set").process_end().build())
assert data.set_via_attribute_name
assert data.set_via_data_attribute
assert data.set_via_context_data_attribute
import adhesive
adhesive.process_start().subprocess_start().subprocess_start().task(
"not existing").subprocess_end().subprocess_end().process_end().build()