Liking cljdoc? Tell your friends :D

lambdacd.core

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

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

lambdacd.event-bus

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:

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

lambdacd.execution.core

Entrypoint into the pipeline/step execution engine.

Entrypoint into the pipeline/step execution engine.

lambdacd.internal.default-pipeline-state

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

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

lambdacd.presentation.pipeline-state

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 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`

lambdacd.presentation.pipeline-structure

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 is responsible for converting the pipeline
into a nice map-format that we can use to display the pipeline
in a UI

lambdacd.presentation.unified

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.

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.

lambdacd.runners

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.

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.

lambdacd.state.core

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

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

lambdacd.step-id

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.

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

lambdacd.stepresults.flatten

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

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

lambdacd.stepresults.merge

Functions that can help merge several step results into one

Functions that can help merge several step results into one

lambdacd.stepresults.merge-resolvers

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.

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.

lambdacd.steps.control-flow

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

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

lambdacd.steps.git

DEPRECATED: Build-steps that let you work with git repositories. Use the lambdacd-git library instead.

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

lambdacd.steps.manualtrigger

Build step that waits for manual user interaction.

Example:

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

lambdacd.steps.shell

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

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

lambdacd.stepstatus.predicates

Predicates over step status.

Predicates over step status.

lambdacd.stepstatus.unify

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.

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.

lambdacd.stepsupport.chaining

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

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

lambdacd.stepsupport.killable

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

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

lambdacd.stepsupport.metadata

Functions that support build steps in dealing with metadata

Functions that support build steps in dealing with metadata

lambdacd.stepsupport.output

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.

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.

lambdacd.ui.api

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

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

cljdoc is a website building & hosting documentation for Clojure/Script libraries

× close