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()