Main entrypoinint into LambdaCD. Provides core functionality to assemble an instance of LambdaCD that can run.

(let [subscription (subscribe ctx :some-topic)
      payloads (only-payload subscription)]
  (<! (go-loop []
        (if-let [event (<! payloads)]
          (do
            (publish! ctx :some-other-topic (:some-value event))
            (recur)))))
  (unsubscribe ctx :some-topic subscription))

Entry-point into the LambdaCD event bus.

The event-bus exists to decouple communication between various parts of LambdaCD and
allow external libraries to act on or publish events in a LambdaCD instance.

Usage example:
```clojure
(let [subscription (subscribe ctx :some-topic)
      payloads (only-payload subscription)]
  (<! (go-loop []
        (if-let [event (<! payloads)]
          (do
            (publish! ctx :some-other-topic (:some-value event))
            (recur)))))
  (unsubscribe ctx :some-topic subscription))
```

Entrypoint into the pipeline/step execution engine.

responsible to manage the current state of the pipeline
i.e. what's currently running, what are the results of each step, ...

stores the current build history on disk

This namespace contains functions useful to convert the internal state of a pipeline into something more easy to use
for further processing, e.g. to present it to a user.

Functions taking a map step-id to step-result are usually called with the result of `lambdacd.state.core/get-step-results`

This namespace is responsible for converting the pipeline
into a nice map-format that we can use to display the pipeline
in a UI

This namespace contains functions to convert the current internal state of a pipeline and it's structure
into a form that's easier to handle. Unifies the information from `lambdacd.presentation.pipeline-state` and `lambdacd.presentation.pipeline-structure`.
Used for example to be able to display a pipeline and it's current state in a UI.

Runners are what keeps a pipeline going. The start new builds based on some logic,
e.g. when the previous build is finished or (e.g if the first step is a trigger) after the first step is done.

Facade for all functions related to dealing with LambdaCDs state. Wraps the related interfaces to simplify compatibility and API.

Defines protocols that need to be implemented by a state component

Utility functions to deal with the logic behind step ids:
step-ids are a sequence of numbers that represent the structure of the pipeline.

Examples:

* `[1]` is the first step of the pipeline
* `[2 1]` is the second child of the first step of the pipeline.

For detailed examples on these functions, refer to their [tests](https://github.com/flosell/lambdacd/blob/master/test/clj/lambdacd/step_id_test.clj).

Functions to convert a nested step result and transform it into a flat list

Functions that can help merge several step results into one

Contains functions that can act as resolvers in merge-two-step-results
by returning a merged result of two values if they match or nil if they don't.

Control-flow elements for a pipeline: steps that control the way their child-steps are being run.

DEPRECATED: Build-steps that let you work with git repositories.
Use the [`lambdacd-git` library](https://github.com/flosell/lambdacd-git) instead.

> (wait-for-manual-trigger args ctx) ; Blocks, but setting `:trigger-id` in step-result to a random UUID
> (post-id ctx trigger-id trigger-parameters) ; Returns immediately, unblocks the waiting manual trigger

Build step that waits for manual user interaction.

Example:
```clojure
> (wait-for-manual-trigger args ctx) ; Blocks, but setting `:trigger-id` in step-result to a random UUID
> (post-id ctx trigger-id trigger-parameters) ; Returns immediately, unblocks the waiting manual trigger
```

Build step to run scripts in a separate shell process. Needs `bash` to run.

Predicates over step status.

Functions that implement logic to summarize a list of statuses into a single status.
Commonly used in combination with `unify-only-status` as a `:unify-results-fn` to generate the status of a parent step from the statuses of child steps.
These functions might return `:unknown` if a combination of statuses does not make sense to their scenario.

(defn some-step [args ctx]
  (chaining args ctx
            (shell/bash injected-ctx "/ " "echo hello ")
            (shell/bash injected-ctx "/ " "echo world ")))

(defn some-step-with-error-handling [args ctx]
  (always-chaining args ctx
                   (run-tests injected-args injected-ctx)
                   (if (= :failure (:status injected-args))
                     (publish-test-failures injected-args injected-ctx))))

Functions that allow you to use LambdaCDs pipeline mechanisms inside a step, i.e. chain several steps together:

```clojure
(defn some-step [args ctx]
  (chaining args ctx
            (shell/bash injected-ctx "/ " "echo hello ")
            (shell/bash injected-ctx "/ " "echo world ")))

(defn some-step-with-error-handling [args ctx]
  (always-chaining args ctx
                   (run-tests injected-args injected-ctx)
                   (if (= :failure (:status injected-args))
                     (publish-test-failures injected-args injected-ctx))))
```

Functions that help in adding the ability for a step to be killed.

Functions that support build steps in dealing with metadata

Functions and macros that simplify dealing with a steps user readable output (`:out`). Two approaches are provided:
The _printer_ approach that gives full control over what will be provided as output and the `capture-output`-approach that just redirects all stdout.

REST-API into the current state, structure and history of the pipeline for use by the UI.