{:group-id "com.monkeyci", :artifact-id "app", :version "0.4.9.1", :analysis {"clj" ({:name monkey.ci.artifacts, :publics ({:name artifact-archive-path, :file "monkey/ci/artifacts.clj", :line 21, :arglists ([{:keys [build]} id]), :type :var} {:name restore-artifacts, :file "monkey/ci/artifacts.clj", :line 92, :arglists ([rt]), :type :var} {:name restore-blob, :file "monkey/ci/artifacts.clj", :line 70, :arglists ([{:keys [store-key build-path]} rt {:keys [id path]}]), :type :var} {:name restore-generic, :file "monkey/ci/artifacts.clj", :line 89, :arglists ([rt conf]), :type :var} {:name save-artifacts, :file "monkey/ci/artifacts.clj", :line 62, :arglists ([rt]), :doc "Saves all artifacts according to the job configuration.\n", :type :var} {:name save-blob, :file "monkey/ci/artifacts.clj", :line 40, :arglists ([{:keys [build-path store-key]} rt {:keys [path id]}]), :doc "Saves a single blob path\n", :type :var} {:name save-generic, :file "monkey/ci/artifacts.clj", :line 57, :arglists ([rt conf]), :type :var} {:name wrap-artifacts, :file "monkey/ci/artifacts.clj", :line 99, :arglists ([f]), :type :var}), :doc "Functionality for saving/restoring artifacts.  This is similar to caches, but\nwhere caches are used between the same jobs in different builds, artifacts are\nused for different jobs in the same build.  Artifacts can also be exposed to\nthe outside world."} {:name monkey.ci.blob, :publics ({:name archive-type, :file "monkey/ci/blob.clj", :line 32, :type :var} {:name blob-store?, :file "monkey/ci/blob.clj", :line 29, :type :var} {:name compression-type, :file "monkey/ci/blob.clj", :line 31, :type :var} {:name extension, :file "monkey/ci/blob.clj", :line 169, :type :var} {:name make-archive, :file "monkey/ci/blob.clj", :line 107, :arglists ([src dest]), :doc "Archives the `src` directory or file into `dest` file.\n", :type :var} {:name make-blob-store, :file "monkey/ci/blob.clj", :line 26, :type :multimethod} {:name normalize-blob-config, :file "monkey/ci/blob.clj", :line 243, :type :multimethod} {:name restore, :file "monkey/ci/blob.clj", :line 24, :type :var} {:name save, :file "monkey/ci/blob.clj", :line 23, :type :var} {:name stream-factory, :file "monkey/ci/blob.clj", :line 34, :type :var}), :doc "Blob storage functionality, used to store and restore large files\nor entire directories."} {:name monkey.ci.build, :publics ({:name account->sid, :file "monkey/ci/build.clj", :line 14, :type :var} {:name build->evt, :file "monkey/ci/build.clj", :line 138, :arglists ([build]), :doc "Prepare build object so it can be added to an event\n", :type :var} {:name build-completed-evt, :file "monkey/ci/build.clj", :line 153, :deprecated true, :type :var} {:name build-end-evt, :file "monkey/ci/build.clj", :line 143, :arglists ([build & [exit-code]]), :doc "Creates a `build/end` event\n", :type :var} {:name build-sid-length, :file "monkey/ci/build.clj", :line 16, :type :var} {:name calc-checkout-dir, :file "monkey/ci/build.clj", :line 105, :doc "Calculates the checkout directory for the build, by combining the checkout\nbase directory and the build id.", :type :var} {:name calc-script-dir, :file "monkey/ci/build.clj", :line 121, :arglists ([wd sd]), :doc "Given an (absolute) working directory and scripting directory, determines\nthe absolute script dir.", :type :var} {:name checkout-dir, :file "monkey/ci/build.clj", :line 110, :doc "Gets the checkout dir as stored in the build structure\n", :type :var} {:name default-script-dir, :file "monkey/ci/build.clj", :line 119, :type :var} {:name exit-code->status, :file "monkey/ci/build.clj", :line 134, :arglists ([exit]), :type :var} {:name get-build-id, :file "monkey/ci/build.clj", :line 28, :arglists ([rt]), :type :var} {:name get-job-id, :file "monkey/ci/build.clj", :line 38, :doc "Creates a string representation of the job sid\n", :type :var} {:name get-job-sid, :file "monkey/ci/build.clj", :line 31, :doc "Creates a job sid using the build id and job id.  Note that this does\nnot include the customer and repo ids, so this is only unique within the repo.", :type :var} {:name get-sid, :file "monkey/ci/build.clj", :line 18, :arglists ([rt]), :doc "Gets current build sid from the runtime.  This is either specified directly,\nor taken from account settings.", :type :var} {:name job-relative-dir, :file "monkey/ci/build.clj", :line 169, :arglists ([rt p]), :doc "Calculates path `p` as relative to the work dir for the current job\n", :type :var} {:name job-work-dir, :file "monkey/ci/build.clj", :line 155, :arglists ([rt]), :doc "Given a runtime, determines the job working directory.  This is either the\nwork dir as configured on the job, or the context work dir, or the process dir.", :type :var} {:name make-build-ctx, :file "monkey/ci/build.clj", :line 61, :arglists ([rt]), :doc "Creates a build context that can be added to the runtime.\n", :type :var} {:name rt->checkout-dir, :file "monkey/ci/build.clj", :line 117, :type :var} {:name rt->job-id, :file "monkey/ci/build.clj", :line 42, :type :var} {:name rt->script-dir, :file "monkey/ci/build.clj", :line 94, :doc "Gets script dir for the build from runtime\n", :type :var} {:name script, :file "monkey/ci/build.clj", :line 84, :doc "Gets script from the build\n", :type :var} {:name script-dir, :file "monkey/ci/build.clj", :line 87, :doc "Gets script dir from the build\n", :type :var} {:name set-checkout-dir, :file "monkey/ci/build.clj", :line 114, :arglists ([b d]), :type :var} {:name set-script-dir, :file "monkey/ci/build.clj", :line 91, :arglists ([b d]), :type :var} {:name ssh-keys-dir, :file "monkey/ci/build.clj", :line 130, :doc "Calculates ssh keys dir for the build\n", :type :var}), :doc "Functions for working with the build object in the runtime.  This\nrepresents the current build."} {:name monkey.ci.build.api, :publics ({:name build-params, :file "monkey/ci/build/api.clj", :line 19, :type :var} {:name rt->api-client, :file "monkey/ci/build/api.clj", :line 7, :type :var}), :doc "Functions for invoking the script API.\n"} {:name monkey.ci.build.container, :publics ({:name image, :file "monkey/ci/build/container.clj", :line 4, :arglists ([step img]), :type :var}), :doc "Functions to configure container images on a build step\n"} {:name monkey.ci.build.core, :publics ({:name action-job, :file "monkey/ci/build/core.clj", :line 35, :arglists ([id action opts] [id action]), :doc "Creates a new job\n", :type :var} {:name action-job?, :file "monkey/ci/build/core.clj", :line 42, :type :var} {:name as-job, :file "monkey/ci/build/core.clj", :line 93, :arglists ([f]), :doc "Marks fn `f` as a job\n", :type :var} {:name branch, :file "monkey/ci/build/core.clj", :line 122, :doc "Gets the commit branch from the context\n", :type :var} {:name branch-regex, :file "monkey/ci/build/core.clj", :line 113, :type :var} {:name container-job, :file "monkey/ci/build/core.clj", :line 47, :arglists ([id props]), :doc "Creates a job that executes in a container\n", :type :var} {:name container-job?, :file "monkey/ci/build/core.clj", :line 52, :type :var} {:name defjob, :file "monkey/ci/build/core.clj", :line 98, :arglists ([n & args]), :doc "Defines an action job function\n", :type :macro} {:name defpipeline, :file "monkey/ci/build/core.clj", :line 84, :arglists ([n jobs]), :doc "Convenience macro that declares a var for a pipeline with the given name \nwith specified jobs", :type :macro} {:name depends-on, :file "monkey/ci/build/core.clj", :line 103, :arglists ([job ids]), :doc "Adds dependencies to the given job\n", :type :var} {:name failed?, :file "monkey/ci/build/core.clj", :line 26, :arglists ([{:keys [status]}]), :type :var} {:name failure, :file "monkey/ci/build/core.clj", :line 14, :type :var} {:name git-ref, :file "monkey/ci/build/core.clj", :line 108, :arglists ([ctx]), :doc "Gets the git ref from the context\n", :type :var} {:name job-id, :file "monkey/ci/build/core.clj", :line 70, :arglists ([x]), :type :var} {:name main-branch, :file "monkey/ci/build/core.clj", :line 126, :type :var} {:name main-branch?, :file "monkey/ci/build/core.clj", :line 128, :arglists ([ctx]), :type :var} {:name pipeline, :file "monkey/ci/build/core.clj", :line 73, :arglists ([config]), :doc "Create a pipeline with given config\n", :type :var} {:name pipeline?, :file "monkey/ci/build/core.clj", :line 67, :arglists ([x]), :type :var} {:name ref-regex, :file "monkey/ci/build/core.clj", :line 116, :arglists ([ctx re]), :doc "Applies the given regex on the ref from the context, returns the matching groups.\n", :type :var} {:name skipped, :file "monkey/ci/build/core.clj", :line 15, :type :var} {:name skipped?, :file "monkey/ci/build/core.clj", :line 29, :arglists ([{:keys [status]}]), :type :var} {:name status, :file "monkey/ci/build/core.clj", :line 10, :arglists ([v]), :type :var} {:name status?, :file "monkey/ci/build/core.clj", :line 17, :arglists ([x]), :doc "Checks if the given object is a job status\n", :type :var} {:name step->job, :file "monkey/ci/build/core.clj", :line 54, :arglists ([m]), :doc "Converts legacy map jobs into job records\n", :type :var} {:name success, :file "monkey/ci/build/core.clj", :line 13, :type :var} {:name success?, :file "monkey/ci/build/core.clj", :line 22, :arglists ([{:keys [status]}]), :type :var} {:name tag, :file "monkey/ci/build/core.clj", :line 132, :doc "Gets the commit tag from the context\n", :type :var} {:name tag-regex, :file "monkey/ci/build/core.clj", :line 114, :type :var} {:name work-dir, :file "monkey/ci/build/core.clj", :line 136, :doc "The job work dir\n", :type :var}), :doc "Core build script functionality.  This is used by build scripts to create\nthe configuration which is then executed by the configured runner.  Which\nrunner is configured or active depends on the configuration of the MonkeyCI\napplication that executes the script."} {:name monkey.ci.build.shell, :publics ({:name bash, :file "monkey/ci/build/shell.clj", :line 11, :arglists ([& args]), :type :var} {:name container-work-dir, :file "monkey/ci/build/shell.clj", :line 55, :doc "Returns the dir where the workspace would be mounted in a container.\n", :type :var} {:name home, :file "monkey/ci/build/shell.clj", :line 31, :type :var} {:name in-work, :file "monkey/ci/build/shell.clj", :line 48, :arglists ([ctx p]), :doc "Given a relative path `p`, returns it as a subpath to the job working directory.\nFails if an absolute path is given.", :type :var} {:name param-to-file, :file "monkey/ci/build/shell.clj", :line 33, :arglists ([ctx param out]), :doc "Takes the value of `param` from the build parameters and writes it to \nthe file at path `out`.  Creates any directories as needed.  Returns \n`nil` if the operation succeeded.", :type :var})} {:name monkey.ci.build.spec, :publics ()} {:name monkey.ci.cache, :publics ({:name cache-archive-path, :file "monkey/ci/cache.clj", :line 14, :arglists ([{:keys [build]} id]), :type :var} {:name cache-config, :file "monkey/ci/cache.clj", :line 19, :type :var} {:name restore-caches, :file "monkey/ci/cache.clj", :line 29, :arglists ([rt]), :type :var} {:name save-caches, :file "monkey/ci/cache.clj", :line 23, :arglists ([rt]), :doc "If the job configured in the context uses caching, saves it according\nto the cache configurations.", :type :var} {:name wrap-caches, :file "monkey/ci/cache.clj", :line 33, :arglists ([f]), :doc "Wraps fn `f` so that caches are restored/saved as configured on the job.\n", :type :var}), :doc "Functionality for saving/restoring caches.  This uses blobs.\n"} {:name monkey.ci.cli, :publics ({:name base-config, :file "monkey/ci/cli.clj", :line 117, :type :var} {:name build-cmd, :file "monkey/ci/cli.clj", :line 59, :type :var} {:name list-build-cmd, :file "monkey/ci/cli.clj", :line 47, :type :var} {:name run-build-cmd, :file "monkey/ci/cli.clj", :line 15, :type :var} {:name script-location-opt, :file "monkey/ci/cli.clj", :line 8, :type :var} {:name server-cmd, :file "monkey/ci/cli.clj", :line 79, :type :var} {:name set-invoker, :file "monkey/ci/cli.clj", :line 138, :arglists ([conf inv]), :doc "Updates the cli config to replace the `runs` config with the given invoker.\n", :type :var} {:name sidecar-cmd, :file "monkey/ci/cli.clj", :line 92, :type :var} {:name verify-build-cmd, :file "monkey/ci/cli.clj", :line 40, :type :var} {:name watch-cmd, :file "monkey/ci/cli.clj", :line 53, :type :var})} {:name monkey.ci.commands, :publics ({:name http-server, :file "monkey/ci/commands.clj", :line 121, :arglists ([{:keys [http], :as rt}]), :doc "Starts the server by invoking the function in the runtime.  This function is supposed\nto return another function that can be invoked to stop the http server.  Returns a \ndeferred that resolves when the server is stopped.", :type :var} {:name list-builds, :file "monkey/ci/commands.clj", :line 110, :arglists ([rt]), :type :var} {:name prepare-build-ctx, :file "monkey/ci/commands.clj", :line 19, :arglists ([rt]), :doc "Updates the runtime for the build runner, by adding a `build` object\n", :type :var} {:name run-build, :file "monkey/ci/commands.clj", :line 67, :arglists ([rt]), :doc "Performs a build, using the runner from the context.  Returns a deferred\nthat will complete when the build finishes.", :type :var} {:name sidecar, :file "monkey/ci/commands.clj", :line 165, :arglists ([rt]), :doc "Runs the application as a sidecar, that is meant to capture events \nand logs from a container process.  This is necessary because when\nrunning containers from third-party images, we don't have control\nover them.  Instead, we launch a sidecar and execute the commands\nin the container in a script that writes events and output to files,\nwhich are then picked up by the sidecar to dispatch or store.  \n\nThe sidecar loop will stop when the events file is deleted.", :type :var} {:name verify-build, :file "monkey/ci/commands.clj", :line 85, :arglists ([rt]), :doc "Verifies the build in the current directory by loading the script files in-process\nand resolving the jobs.  This is useful when checking if there are any compilation\nerrors in the script.", :type :var} {:name watch, :file "monkey/ci/commands.clj", :line 133, :arglists ([rt]), :doc "Starts listening for events and prints the results.  The arguments determine\nthe event filter (all for a customer, project, or repo).", :type :var}), :doc "Event handlers for commands\n"} {:name monkey.ci.config, :publics ({:name *global-config-file*, :file "monkey/ci/config.clj", :line 21, :dynamic true, :type :var} {:name *home-config-file*, :file "monkey/ci/config.clj", :line 22, :dynamic true, :type :var} {:name abs-work-dir, :file "monkey/ci/config.clj", :line 159, :arglists ([conf]), :type :var} {:name app-config, :file "monkey/ci/config.clj", :line 222, :arglists ([env args]), :doc "Combines app environment with command-line args into a unified \nconfiguration structure.  Args have precedence over env vars,\nwhich in turn override config loaded from files and default values.", :type :var} {:name config->env, :file "monkey/ci/config.clj", :line 257, :arglists ([c]), :doc "Creates a map of env vars from the config.  This is done by flattening\nthe entries and prepending them with `monkeyci-`.  Values are converted \nto string.", :type :var} {:name default-app-config, :file "monkey/ci/config.clj", :line 110, :doc "Default configuration for the application, without env vars or args applied.\n", :type :var} {:name env-prefix, :file "monkey/ci/config.clj", :line 26, :type :var} {:name group-and-merge-from-env, :file "monkey/ci/config.clj", :line 60, :arglists ([m prefix]), :doc "Given a map, takes all keys in `:env` that start with the given prefix \n(using `group-keys`) and merges them with the existing submap with same \nkey.\nFor example, `{:env {:test-key \"value\"} :test {:other-key \"other-value\"}}` \nwould become `{:test {:key \"value\" :other-key \"other-value\"}}`.  \nThe newly grouped values overwrite any existing values.", :type :var} {:name group-keys, :file "monkey/ci/config.clj", :line 48, :arglists ([m prefix]), :doc "Takes all keys in given map `m` that start with `:prefix-` and\nmoves them to a submap with the prefix name, and the prefix \nstripped from the keys.  E.g. `{:test-key 100}` with prefix `:test`\nwould become `{:test {:key 100}}`", :type :var} {:name keywordize-type, :file "monkey/ci/config.clj", :line 73, :arglists ([v]), :type :var} {:name load-config-file, :file "monkey/ci/config.clj", :line 95, :arglists ([f]), :doc "Loads configuration from given file.  This supports json and edn and converts\nkeys always to kebab-case.", :type :var} {:name load-raw-config, :file "monkey/ci/config.clj", :line 136, :arglists ([extra-files]), :doc "Loads raw (not normalized) configuration from its various sources\n", :type :var} {:name normalize-config, :file "monkey/ci/config.clj", :line 194, :arglists ([conf env args]), :doc "Given a configuration map loaded from file, environment variables and command-line\nargs, applies all registered normalizers to it and returns the result.  Since the \norder of normalizers is undefined, they should not be dependent on each other.", :type :var} {:name normalize-key, :file "monkey/ci/config.clj", :line 145, :doc "Normalizes the config as read from files and env, for the specific key.\nThe method receives the entire config, that also holds the env and args\nand should return the updated config.", :type :multimethod} {:name normalize-typed, :file "monkey/ci/config.clj", :line 268, :arglists ([k conf f]), :doc "Convenience function that converts the `:type` of an entry into a keyword and\nthen invokes `f` on it.", :type :var} {:name serialize-config, :file "monkey/ci/config.clj", :line 246, :type :multimethod} {:name strip-env-prefix, :file "monkey/ci/config.clj", :line 45, :arglists ([e]), :type :var} {:name version, :file "monkey/ci/config.clj", :line 29, :arglists ([]), :type :macro}), :doc "Configuration functionality.  This reads the application configuration from various\nsources, like environment vars or command-line args.  The configuration is structured\nin a hierarchy and optionally some values are converted.  Then this configuration is\nused to add any 'constructor functions', that are then used to create new functions to\ndo some actual work.  This allows us to change the behaviour of the application with\nconfiguration, but also makes it possible to inject dummy functions for testing \npurposes."} {:name monkey.ci.containers, :publics ({:name cmd, :file "monkey/ci/containers.clj", :line 41, :type :var} {:name entrypoint, :file "monkey/ci/containers.clj", :line 43, :type :var} {:name env, :file "monkey/ci/containers.clj", :line 40, :type :var} {:name image, :file "monkey/ci/containers.clj", :line 39, :type :var} {:name mounts, :file "monkey/ci/containers.clj", :line 42, :type :var} {:name normalize-containers-config, :file "monkey/ci/containers.clj", :line 27, :type :multimethod} {:name rt->container-config, :file "monkey/ci/containers.clj", :line 15, :arglists ([rt]), :doc "Extracts all keys from the context step that have the `container` namespace,\nand drops that namespace.", :type :var} {:name run-container, :file "monkey/ci/containers.clj", :line 9, :type :multimethod}), :doc "Generic functionality for running containers\n"} {:name monkey.ci.containers.docker, :publics ({:name api-version, :file "monkey/ci/containers/docker.clj", :line 17, :type :var} {:name attach-container, :file "monkey/ci/containers/docker.clj", :line 95, :arglists ([client id]), :doc "Attaches to given container.  Returns a socket that can be used to communicate with it.\n", :type :var} {:name container-logs, :file "monkey/ci/containers/docker.clj", :line 106, :arglists ([client id & [opts]]), :doc "Attaches to the container in order to read logs\n", :type :var} {:name container-opts, :file "monkey/ci/containers/docker.clj", :line 194, :arglists ([rt]), :type :var} {:name create-container, :file "monkey/ci/containers/docker.clj", :line 55, :arglists ([client name config]), :doc "Creates a container with given name and configuration.  `client` must\nbe for category `:containers`.", :type :var} {:name default-conn, :file "monkey/ci/containers/docker.clj", :line 16, :type :var} {:name delete-container, :file "monkey/ci/containers/docker.clj", :line 70, :arglists ([client id]), :type :var} {:name inspect-container, :file "monkey/ci/containers/docker.clj", :line 64, :arglists ([client id]), :type :var} {:name list-containers, :file "monkey/ci/containers/docker.clj", :line 75, :arglists ([client args]), :type :var} {:name make-client, :file "monkey/ci/containers/docker.clj", :line 19, :arglists ([category & [conn]]), :doc "Creates a client for given category using the specified connection settings\n", :type :var} {:name parse-log-stream, :file "monkey/ci/containers/docker.clj", :line 171, :arglists ([s]), :doc "Given a Docker input stream, parses it in to lines and returns it as\na lazy seq of parsed maps, containing the stream type, size and message.", :type :var} {:name pull-image, :file "monkey/ci/containers/docker.clj", :line 48, :arglists ([client url]), :doc "Pulls image from given url.  Requires a client for category `:images`.\n", :type :var} {:name run-container, :file "monkey/ci/containers/docker.clj", :line 178, :arglists ([c name config]), :doc "Utility function that creates and starts a container, and then reads the logs\nand returns them as a seq of strings.", :type :var} {:name start-container, :file "monkey/ci/containers/docker.clj", :line 81, :arglists ([client id]), :doc "Starts the container, returns the output as a stream\n", :type :var} {:name stop-container, :file "monkey/ci/containers/docker.clj", :line 88, :arglists ([client id]), :doc "Stops the container\n", :type :var} {:name stream-types, :file "monkey/ci/containers/docker.clj", :line 117, :type :var}), :doc "Functions for running build jobs using Docker api.\n"} {:name monkey.ci.containers.oci, :publics ({:name abort-file, :file "monkey/ci/containers/oci.clj", :line 29, :type :var} {:name config-dir, :file "monkey/ci/containers/oci.clj", :line 34, :type :var} {:name config-vol, :file "monkey/ci/containers/oci.clj", :line 33, :type :var} {:name event-file, :file "monkey/ci/containers/oci.clj", :line 30, :type :var} {:name events-dir, :file "monkey/ci/containers/oci.clj", :line 27, :type :var} {:name instance-config, :file "monkey/ci/containers/oci.clj", :line 188, :arglists ([conf rt]), :doc "Generates the configuration for the container instance.  It has \na container that runs the job, as configured in the `:job`, and\nnext to that a sidecar that is responsible for capturing the output\nand dispatching events.  If configured, it also ", :type :var} {:name job-config-file, :file "monkey/ci/containers/oci.clj", :line 35, :type :var} {:name job-container-name, :file "monkey/ci/containers/oci.clj", :line 36, :type :var} {:name job-script, :file "monkey/ci/containers/oci.clj", :line 32, :type :var} {:name log-dir, :file "monkey/ci/containers/oci.clj", :line 26, :type :var} {:name promtail-config-dir, :file "monkey/ci/containers/oci.clj", :line 42, :type :var} {:name promtail-config-file, :file "monkey/ci/containers/oci.clj", :line 43, :type :var} {:name promtail-config-vol, :file "monkey/ci/containers/oci.clj", :line 41, :type :var} {:name script-dir, :file "monkey/ci/containers/oci.clj", :line 25, :type :var} {:name script-vol, :file "monkey/ci/containers/oci.clj", :line 31, :type :var} {:name sidecar-config, :file "monkey/ci/containers/oci.clj", :line 39, :type :var} {:name sidecar-container-name, :file "monkey/ci/containers/oci.clj", :line 38, :type :var} {:name start-file, :file "monkey/ci/containers/oci.clj", :line 28, :type :var} {:name wait-for-instance-end-events, :file "monkey/ci/containers/oci.clj", :line 213, :arglists ([events sid job-id max-timeout]), :doc "Checks the incoming events to see if a container and job end event has been received.\nReturns a deferred that will contain both events.", :type :var} {:name wait-or-timeout, :file "monkey/ci/containers/oci.clj", :line 231, :arglists ([rt max-timeout get-details]), :doc "Waits for the container end event, or times out.  Afterwards, the full container\ninstance details are fetched.  The exit codes in the received events are used for\nthe container exit codes.", :type :var} {:name work-dir, :file "monkey/ci/containers/oci.clj", :line 24, :type :var}), :doc "Container runner implementation that uses OCI container instances.\n"} {:name monkey.ci.containers.podman, :publics ({:name build-cmd-args, :file "monkey/ci/containers/podman.clj", :line 52, :arglists ([{:keys [job], :as rt}]), :doc "Builds command line args for the podman executable\n", :type :var}), :doc "Functions for running containers using Podman.  We don't use the api here, because\nit requires a socket, which is not always available.  Instead, we invoke the podman\ncommand as a child process and communicate with it using the standard i/o streams."} {:name monkey.ci.containers.promtail, :publics ({:name ->yaml, :file "monkey/ci/containers/promtail.clj", :line 38, :arglists ([conf]), :type :var} {:name promtail-config, :file "monkey/ci/containers/promtail.clj", :line 16, :arglists ([conf]), :doc "Generates config structure that can be passed to promtail.  The structure should\nbe converted to yaml in order to be usable by promtail.", :type :var} {:name promtail-container, :file "monkey/ci/containers/promtail.clj", :line 53, :arglists ([{:keys [image-url image-tag], :as conf}]), :doc "Generates container configuration for promtail.  This is used to push logs to Loki,\nwhich can then be retrieved later by the client.", :type :var} {:name promtail-image, :file "monkey/ci/containers/promtail.clj", :line 13, :type :var} {:name promtail-version, :file "monkey/ci/containers/promtail.clj", :line 14, :type :var} {:name rt->config, :file "monkey/ci/containers/promtail.clj", :line 60, :arglists ([rt]), :doc "Extracts necessary values from the runtime to create a promtail config map, that\ncan be passed to `promtail-config`.", :type :var} {:name yaml-config, :file "monkey/ci/containers/promtail.clj", :line 51, :type :var}), :doc "Functions for configuring promtail containers.  This is not a container driver, but\na utility namespace that is in turn used when pushing build logs to Loki."} {:name monkey.ci.core, :publics ({:name -main, :file "monkey/ci/core.clj", :line 55, :arglists ([& args]), :doc "Main entry point for the application.\n", :type :var} {:name make-cli-config, :file "monkey/ci/core.clj", :line 49, :arglists ([{:keys [cmd-invoker env], :or {cmd-invoker system-invoker}}]), :type :var} {:name system-invoker, :file "monkey/ci/core.clj", :line 35, :arglists ([{:keys [command app-mode], :as cmd} env]), :doc "The event invoker starts a subsystem according to the command requirements,\nand posts the `command/invoked` event.  This event should be picked up by a\nhandler in the system.  When the command is complete, it should post a\n`command/completed` event for the same command.  By default it uses the base\nsystem, but you can specify your own for testing purposes.", :type :var}), :doc "Core namespace for the Monkey CI app.  This contains the entrypoint which\nprocesses the configuration.  This configuration determines whether the\napplication runs as a server, execute a single script, which type of runner\nis enabled, etc..."} {:name monkey.ci.events.core, :publics ({:name add-listener, :file "monkey/ci/events/core.clj", :line 14, :type :var} {:name exception-result, :file "monkey/ci/events/core.clj", :line 150, :arglists ([ex]), :type :var} {:name filter-type, :file "monkey/ci/events/core.clj", :line 60, :arglists ([t f]), :deprecated true, :type :var} {:name invoke-listeners, :file "monkey/ci/events/core.clj", :line 20, :arglists ([filter-fn listeners events]), :type :var} {:name make-event, :file "monkey/ci/events/core.clj", :line 17, :arglists ([e]), :type :var} {:name make-events, :file "monkey/ci/events/core.clj", :line 77, :type :multimethod} {:name make-result, :file "monkey/ci/events/core.clj", :line 145, :arglists ([status exit-code msg]), :type :var} {:name make-sync-events, :file "monkey/ci/events/core.clj", :line 57, :arglists ([filter-fn]), :type :var} {:name matches-event?, :file "monkey/ci/events/core.clj", :line 46, :arglists ([evt {:keys [types sid], :as ef}]), :doc "Matches events against event filters.  This checks event types and possible sid.\n", :type :var} {:name no-dispatch, :file "monkey/ci/events/core.clj", :line 65, :arglists ([f]), :deprecated true, :doc "Wraps `f` so that it always returns `nil`, to avoid events being re-dispatched.\n", :type :var} {:name post-events, :file "monkey/ci/events/core.clj", :line 13, :type :var} {:name remove-listener, :file "monkey/ci/events/core.clj", :line 15, :type :var} {:name result, :file "monkey/ci/events/core.clj", :line 157, :type :var} {:name result-exit, :file "monkey/ci/events/core.clj", :line 158, :type :var} {:name set-result, :file "monkey/ci/events/core.clj", :line 154, :arglists ([evt r]), :type :var} {:name wait-for-event, :file "monkey/ci/events/core.clj", :line 125, :arglists ([events ef & [pred]]), :doc "Utility fn that registers using an event filter and invokes the handler when one has\nbeen received.  Returns a deferred that realizes with the received event.  An additional\npredicate can do extra filtering if it's not supported by the event filter.", :type :var} {:name wrapped, :file "monkey/ci/events/core.clj", :line 95, :arglists ([f before after & [error]]), :doc "Returns a new function that wraps `f` and posts an event before \nand after.  The `before` fn just receives the same arguments as \n`f`.  The `after` fn one more, the return value of `f`.  The first \nargument is assumed to be the runtime, which is used to get the \nevent poster.  The return values of `before` and `after` are posted \nas events. Returns the return value of calling `f`.\n\nAny of the event generating functions can be `nil`, in which case\nit will be ignored.", :type :var})} {:name monkey.ci.events.jms, :publics ({:name filtering-listener, :file "monkey/ci/events/jms.clj", :line 43, :arglists ([pred l]), :type :var} {:name jms-ns, :file "monkey/ci/events/jms.clj", :line 14, :type :var} {:name make-jms-events, :file "monkey/ci/events/jms.clj", :line 106, :arglists ([config matches-event?]), :type :var} {:name with-logs, :file "monkey/ci/events/jms.clj", :line 16, :arglists ([& body]), :type :macro}), :doc "Uses JMS (with bowerick) to connect to an event broker.  Can also\nstarts its own broker server, although this is mostly meant for\ndevelopment and testing purposes."} {:name monkey.ci.events.manifold, :publics ({:name make-manifold-events, :file "monkey/ci/events/manifold.clj", :line 42, :arglists ([filter-fn]), :type :var}), :doc "Manifold-based implementation of event poster and receiver\n"} {:name monkey.ci.events.zmq, :publics ({:name filtering-listener, :file "monkey/ci/events/zmq.clj", :line 25, :arglists ([pred l]), :type :var} {:name make-context, :file "monkey/ci/events/zmq.clj", :line 15, :arglists ([]), :type :var} {:name make-zeromq-events, :file "monkey/ci/events/zmq.clj", :line 122, :arglists ([conf filter-fn]), :doc "Creates zeromq events component.  Depending on configuration, it can contain both\na client and a server.  The client connects to the server in order to post events,\nso the client functions as the event poster.  Both need to be started to work.", :type :var})} {:name monkey.ci.extensions, :publics ({:name after-job, :file "monkey/ci/extensions.clj", :line 25, :type :multimethod} {:name apply-extensions-after, :file "monkey/ci/extensions.clj", :line 48, :arglists ([rt registered] [rt]), :type :var} {:name apply-extensions-before, :file "monkey/ci/extensions.clj", :line 42, :arglists ([rt registered] [rt]), :type :var} {:name before-job, :file "monkey/ci/extensions.clj", :line 23, :type :multimethod} {:name new-register, :file "monkey/ci/extensions.clj", :line 13, :type :var} {:name register, :file "monkey/ci/extensions.clj", :line 17, :arglists ([l ext]), :type :var} {:name register!, :file "monkey/ci/extensions.clj", :line 20, :arglists ([ext]), :type :var} {:name registered-extensions, :file "monkey/ci/extensions.clj", :line 15, :type :var} {:name wrap-job, :file "monkey/ci/extensions.clj", :line 71, :arglists ([job registered-ext] [job]), :doc "Wraps job so that extensions are invoked before and after it.\n", :type :var}), :doc "Functionality for working with script extensions.  Extensions are a way\nfor third party libraries to add functionality to scripts, that is easy\nto activate and can also be used in yaml-type scripts.  You could of \ncourse also add regular functions to invoke, but this is not easy to\nuse, especially when using container jobs.  Extensions do this by registering\nthemselves under a specific namespaced keyword.  If this key is found in\njob properties, the associated extension code is executed.  Extensions can\nbe executed before or after a job (or both)."} {:name monkey.ci.git, :publics ({:name checkout, :file "monkey/ci/git.clj", :line 72, :arglists ([repo id]), :type :var} {:name clone, :file "monkey/ci/git.clj", :line 58, :arglists ([{:keys [url dir], :as opts}]), :doc "Clones the repo at given url, and checks out the given branch.  Writes the\nfiles to `dir`.  Returns a repo object that can be passed to other functions.", :type :var} {:name clone+checkout, :file "monkey/ci/git.clj", :line 76, :arglists ([{:keys [commit-id], :as opts}]), :doc "Clones the repo, then performs a checkout of the given commit id\n", :type :var} {:name delete-repo, :file "monkey/ci/git.clj", :line 84, :arglists ([repo]), :doc "Deletes the previously checked out local repo\n", :type :var} {:name opts->branch, :file "monkey/ci/git.clj", :line 56, :type :var} {:name prepare-ssh-keys, :file "monkey/ci/git.clj", :line 35, :arglists ([{:keys [ssh-keys ssh-keys-dir], :as conf}]), :doc "Writes any ssh keys in the options to a temp directory and returns their\nfile names and key dir to be used by clj-jgit.  If an `ssh-keys-dir` is\nconfigured, but no `ssh-keys`, then it is assumed the keys are already \nin place.", :type :var}), :doc "Clone and checkout git repos.  This is mostly a wrapper for `clj-jgit`\n"} {:name monkey.ci.jobs, :publics ({:name deps, :file "monkey/ci/jobs.clj", :line 19, :doc "Get job dependencies\n", :type :var} {:name execute-jobs!, :file "monkey/ci/jobs.clj", :line 216, :arglists ([jobs rt]), :doc "Executes all jobs in dependency order.  Returns a deferred that will hold\nthe results of all executed jobs.", :type :var} {:name failed?, :file "monkey/ci/jobs.clj", :line 40, :type :var} {:name filter-jobs, :file "monkey/ci/jobs.clj", :line 300, :arglists ([pred jobs]), :doc "Applies a filter to the given jobs, but includes all dependencies of jobs that\nmatch the filter, even though the dependencies themselves may not match it.", :type :var} {:name Job, :file "monkey/ci/jobs.clj", :line 24, :doc "Base job protocol that is able to execute it, taking the runtime as argument.\n", :type :protocol, :members ({:name execute!, :arglists ([job rt]), :type :var})} {:name job->event, :file "monkey/ci/jobs.clj", :line 331, :arglists ([job]), :doc "Converts job into something that can be put in an event\n", :type :var} {:name job-fn?, :file "monkey/ci/jobs.clj", :line 142, :arglists ([x]), :type :var} {:name job-id, :file "monkey/ci/jobs.clj", :line 22, :doc "Gets job id\n", :type :var} {:name job?, :file "monkey/ci/jobs.clj", :line 28, :arglists ([x]), :doc "Checks if object is a job\n", :type :var} {:name label-filter, :file "monkey/ci/jobs.clj", :line 317, :arglists ([f]), :doc "Predicate function that matches a job by its labels\n", :type :var} {:name labels, :file "monkey/ci/jobs.clj", :line 21, :doc "Get job labels\n", :type :var} {:name next-jobs, :file "monkey/ci/jobs.clj", :line 132, :arglists ([jobs]), :doc "Returns a list of next jobs that are eligible for execution.  If all jobs are\npending, returns the starting jobs, those that don't have any dependencies.  \nOtherwise returns all pending jobs that have their dependencies fulfilled.", :type :var} {:name pending?, :file "monkey/ci/jobs.clj", :line 38, :type :var} {:name resolvable?, :file "monkey/ci/jobs.clj", :line 35, :arglists ([x]), :type :var} {:name resolve-all, :file "monkey/ci/jobs.clj", :line 323, :arglists ([rt jobs]), :doc "Resolves all jobs, removes anything that's not resolvable or not a job.\n", :type :var} {:name resolve-jobs, :file "monkey/ci/jobs.clj", :line 214, :type :var} {:name running?, :file "monkey/ci/jobs.clj", :line 39, :type :var} {:name status, :file "monkey/ci/jobs.clj", :line 20, :doc "Get job status\n", :type :var} {:name success?, :file "monkey/ci/jobs.clj", :line 41, :type :var}), :doc "Handles job execution and ordering in a build\n"} {:name monkey.ci.labels, :publics ({:name apply-label-filters, :file "monkey/ci/labels.clj", :line 18, :arglists ([labels params]), :doc "Given a single set of parameters with label filters, checks if the given\nlabels match.  If there is at least one filter in the params' `:label-filters`\nfor which all labels in the conjunction match, this returns `true`.  If\nthe params don't have any labels, this assumes all labels match.", :type :var} {:name filter-by-label, :file "monkey/ci/labels.clj", :line 30, :arglists ([repo entities]), :type :var} {:name labels->map, :file "monkey/ci/labels.clj", :line 26, :arglists ([l]), :type :var} {:name matches-labels?, :file "monkey/ci/labels.clj", :line 3, :arglists ([f labels]), :doc "Predicate that checks if the given labels match filter `f`.  The filter\nis a list of a list labels and values, where the first level represents a\ndisjunction (logical 'or') and the second a conjunction (logical 'and').", :type :var})} {:name monkey.ci.listeners, :publics ({:name build-update-handler, :file "monkey/ci/listeners.clj", :line 48, :arglists ([storage events]), :doc "Handles a build update event.  Because many events may come in close proximity,\nwe need to queue them to avoid losing data.", :type :var} {:name update-build, :file "monkey/ci/listeners.clj", :line 16, :arglists ([storage {:keys [sid build]}]), :type :var} {:name update-handlers, :file "monkey/ci/listeners.clj", :line 40, :type :var} {:name update-job, :file "monkey/ci/listeners.clj", :line 33, :arglists ([storage {:keys [sid job]}]), :type :var} {:name update-script, :file "monkey/ci/listeners.clj", :line 23, :arglists ([storage {:keys [sid script]}]), :type :var})} {:name monkey.ci.logging, :publics ({:name handle-process-streams, :file "monkey/ci/logging.clj", :line 104, :arglists ([{:keys [out err], :as proc} loggers]), :doc "Given a process return value (as from `babashka.process/process`) and two\nloggers, will invoke the `handle-stream` on each logger for out and error\noutput.  Returns the process.", :type :var} {:name LogCapturer, :file "monkey/ci/logging.clj", :line 18, :doc "Used to allow processes to store log information.  Depending on the implementation,\nthis can be local on disk, or some cloud object storage.", :type :protocol, :members ({:name handle-stream, :arglists ([this in]), :type :var} {:name log-output, :arglists ([this]), :type :var})} {:name LogRetriever, :file "monkey/ci/logging.clj", :line 114, :doc "Interface for retrieving log files.  This is more or less the opposite of the `LogCapturer`.\nIt allows to list logs and fetch a log according to path.", :type :protocol, :members ({:name fetch-log, :arglists ([this build-sid path]), :doc "Retrieves log for given build id and path.  Returns a stream and its size.\n", :type :var} {:name list-logs, :arglists ([this build-sid]), :doc "Lists available logs for the build id, with name and size\n", :type :var})} {:name make-log-retriever, :file "monkey/ci/logging.clj", :line 145, :type :multimethod} {:name make-logger, :file "monkey/ci/logging.clj", :line 24, :type :multimethod} {:name normalize-logging-config, :file "monkey/ci/logging.clj", :line 198, :type :multimethod} {:name sid->path, :file "monkey/ci/logging.clj", :line 80, :arglists ([{:keys [prefix]} path sid]), :type :var}), :doc "Handles log configuration and how to process logs from a build script\n"} {:name monkey.ci.metrics, :publics ({:name add-events-metrics, :file "monkey/ci/metrics.clj", :line 24, :arglists ([r events]), :type :var} {:name make-registry, :file "monkey/ci/metrics.clj", :line 8, :arglists ([]), :type :var} {:name scrape, :file "monkey/ci/metrics.clj", :line 11, :arglists ([r]), :doc "Creates a string that can be used by Prometheus for scraping\n", :type :var})} {:name monkey.ci.oci, :publics ({:name ->oci-config, :file "monkey/ci/oci.clj", :line 49, :arglists ([{:keys [credentials], :as conf}]), :doc "Given a configuration map with credentials, turns it into a config map\nthat can be passed to OCI context creators.", :type :var} {:name base-work-dir, :file "monkey/ci/oci.clj", :line 263, :arglists ([rt]), :doc "Determines the base work dir to use inside the container\n", :type :var} {:name checkout-dir, :file "monkey/ci/oci.clj", :line 203, :type :var} {:name checkout-subdir, :file "monkey/ci/oci.clj", :line 256, :arglists ([n]), :doc "Returns the path for `n` as a subdir of the checkout dir\n", :type :var} {:name checkout-vol, :file "monkey/ci/oci.clj", :line 202, :type :var} {:name config-entry, :file "monkey/ci/oci.clj", :line 250, :arglists ([n v]), :doc "Creates an entry config for a volume, where the contents are base64 encoded.\n", :type :var} {:name find-mount, :file "monkey/ci/oci.clj", :line 238, :arglists ([c n]), :doc "Finds mount with given volume name in the container\n", :type :var} {:name find-volume, :file "monkey/ci/oci.clj", :line 244, :arglists ([ci n]), :doc "Finds volume with given name in the container instance\n", :type :var} {:name get-full-instance-details, :file "monkey/ci/oci.clj", :line 98, :arglists ([client id]), :doc "Retrieves full container instance details by retrieving the container instance \ninformation, and fetching container details as well.", :type :var} {:name group-credentials, :file "monkey/ci/oci.clj", :line 19, :arglists ([conf]), :doc "Assuming the conf is taken from env, groups all keys that start with `credentials-`\ninto the `:credentials` submap.", :type :var} {:name instance-config, :file "monkey/ci/oci.clj", :line 218, :arglists ([conf]), :doc "Generates a skeleton instance configuration, generated from the oci configuration.\n", :type :var} {:name key-dir, :file "monkey/ci/oci.clj", :line 204, :type :var} {:name normalize-config, :file "monkey/ci/oci.clj", :line 25, :arglists ([conf k]), :doc "Normalizes the given OCI config key, by grouping the credentials both in the given key\nand in the `oci` key, and merging them.", :type :var} {:name poll-for-completion, :file "monkey/ci/oci.clj", :line 72, :arglists ([{:keys [get-details poll-interval post-event instance-id], :as c, :or {poll-interval 10000, post-event (constantly true)}}]), :doc "Starts an async poll loop that waits until the container instance has completed.\nReturns a deferred that holds the last response received.", :type :var} {:name run-instance, :file "monkey/ci/oci.clj", :line 131, :arglists ([client instance-config & [{:keys [delete? exited?], :as opts}]]), :doc "Creates and starts a container instance using the given config, and then\nwaits for it to terminate.  Returns a deferred that will hold the full container\ninstance state on completion, including the container details.  \n\nThe `exited?` option should be a function that accepts the instance id and returns \na deferred with the container instance status when it exits.  If not provided, a \nbasic polling loop will be used.  Not that using extensive polling may lead to 429 \nerrors from OCI.", :type :var} {:name sid->tags, :file "monkey/ci/oci.clj", :line 233, :arglists ([sid]), :type :var} {:name stream-to-bucket, :file "monkey/ci/oci.clj", :line 58, :arglists ([conf in]), :doc "Pipes an input stream to a bucket object using multipart uploads.\nReturns a deferred that will resolve when the upload completes.\nThat is, when the input stream closes, or an error occurs.", :type :var} {:name terminated?, :file "monkey/ci/oci.clj", :line 70, :type :var} {:name work-dir, :file "monkey/ci/oci.clj", :line 261, :type :var}), :doc "Oracle cloud specific functionality\n"} {:name monkey.ci.pem, :publics ({:name private-key->pem, :file "monkey/ci/pem.clj", :line 5, :arglists ([pk]), :doc "Writes private key to PEM format\n", :type :var})} {:name monkey.ci.process, :publics ({:name default-envs, :file "monkey/ci/process.clj", :line 109, :type :var} {:name default-script-config, :file "monkey/ci/process.clj", :line 33, :doc "Default configuration for the script runner.\n", :type :var} {:name execute!, :file "monkey/ci/process.clj", :line 130, :arglists ([{{:keys [checkout-dir build-id], :as build} :build, :as rt}]), :doc "Executes the build script located in given directory.  This actually runs the\nclojure cli with a generated `build` alias.  This expects absolute directories.\nReturns a deferred that will hold the process result when it completes.", :type :var} {:name exit!, :file "monkey/ci/process.clj", :line 39, :arglists ([exit-code]), :type :var} {:name generate-deps, :file "monkey/ci/process.clj", :line 76, :arglists ([{:keys [build], :as rt}]), :doc "Generates a string that will be added as a commandline argument\nto the clojure process when running the script.  Any existing `deps.edn`\nshould be used as well.", :type :var} {:name process-env, :file "monkey/ci/process.clj", :line 112, :arglists ([rt]), :doc "Build the environment to be passed to the child process.\n", :type :var} {:name run, :file "monkey/ci/process.clj", :line 42, :arglists ([args env] [args]), :doc "Run function for when a build task is executed using clojure tools.  This function\nis run in a child process by the `execute!` function below.  This exits the VM\nwith a nonzero value on failure.", :type :var}), :doc "Process execution functions.  Executes build scripts in a separate process,\nusing clojure cli tools."} {:name monkey.ci.protocols, :publics ({:name blob-store?, :file "monkey/ci/protocols.clj", :line 36, :type :var} {:name BlobStore, :file "monkey/ci/protocols.clj", :line 30, :doc "Protocol for blob store abstraction, used to save and compress files or directories\nto some blob store, possibly remote.", :type :protocol, :members ({:name restore-blob, :arglists ([store src dest]), :doc "Restores `src` to local `dest`\n", :type :var} {:name save-blob, :arglists ([store src dest]), :doc "Saves `src` file or directory to `dest` as a blob\n", :type :var})} {:name EventBuilder, :file "monkey/ci/protocols.clj", :line 18, :doc "Used to construct an event from an object\n", :type :protocol, :members ({:name ->event, :arglists ([this event-type]), :type :var})} {:name EventPoster, :file "monkey/ci/protocols.clj", :line 22, :type :protocol, :members ({:name post-events, :arglists ([poster evt]), :doc "Posts one or more events.  Returns a deferred that realizes when the events have been posted.\n", :type :var})} {:name EventReceiver, :file "monkey/ci/protocols.clj", :line 26, :type :protocol, :members ({:name add-listener, :arglists ([recv ef l]), :doc "Add the given filter with a listener to the receiver\n", :type :var} {:name remove-listener, :arglists ([recv ef l]), :doc "Removes the listener for the filter from the receiver\n", :type :var})} {:name JobResolvable, :file "monkey/ci/protocols.clj", :line 14, :doc "Able to resolve into jobs (zero or more)\n", :type :protocol, :members ({:name resolve-jobs, :arglists ([x rt]), :type :var})} {:name Storage, :file "monkey/ci/protocols.clj", :line 5, :doc "Low level storage protocol, that basically allows to store and retrieve\ninformation by location (aka storage id or sid).", :type :protocol, :members ({:name delete-obj, :arglists ([this sid]), :doc "Deletes object at location\n", :type :var} {:name list-obj, :arglists ([this sid]), :doc "Lists objects at given location\n", :type :var} {:name obj-exists?, :arglists ([this sid]), :doc "Checks if object at location exists\n", :type :var} {:name read-obj, :arglists ([this sid]), :doc "Read object at given location\n", :type :var} {:name write-obj, :arglists ([this sid obj]), :doc "Writes object to location\n", :type :var})}), :doc "Contains all (or most of) the protocols used in the app.  This is useful\nto avoid circular dependencies."} {:name monkey.ci.reporting, :publics ({:name log-reporter, :file "monkey/ci/reporting.clj", :line 9, :arglists ([obj]), :doc "Just logs the input object\n", :type :var} {:name make-reporter, :file "monkey/ci/reporting.clj", :line 14, :type :multimethod}), :doc "Provides functions for reporting output.  This can be logging, or printing\nto stdout, or formatting as json, etc..."} {:name monkey.ci.reporting.print, :publics ({:name bad, :file "monkey/ci/reporting/print.clj", :line 18, :type :var} {:name build-list, :file "monkey/ci/reporting/print.clj", :line 94, :arglists ([builds]), :doc "Generates list of strings to print to output for build list\n", :type :var} {:name col-sep, :file "monkey/ci/reporting/print.clj", :line 80, :type :var} {:name col-space, :file "monkey/ci/reporting/print.clj", :line 79, :type :var} {:name good, :file "monkey/ci/reporting/print.clj", :line 17, :type :var} {:name prev-line, :file "monkey/ci/reporting/print.clj", :line 19, :type :var} {:name print-reporter, :file "monkey/ci/reporting/print.clj", :line 143, :arglists ([obj]), :doc "Nicely prints to stdout, using coloring\n", :type :var} {:name printer, :file "monkey/ci/reporting/print.clj", :line 29, :type :multimethod}), :doc "Reporter that prints to the console using coloring.\n"} {:name monkey.ci.runners, :publics ({:name build-local, :file "monkey/ci/runners.clj", :line 55, :arglists ([rt]), :doc "Locates the build script locally and starts a child process that actually\nruns the build.  Returns a deferred that resolves when the child process has\nexited.", :type :var} {:name create-workspace, :file "monkey/ci/runners.clj", :line 98, :arglists ([rt]), :type :var} {:name download-git, :file "monkey/ci/runners.clj", :line 76, :arglists ([rt]), :doc "Downloads from git into a temp dir, and designates that as the working dir.\n", :type :var} {:name download-src, :file "monkey/ci/runners.clj", :line 91, :arglists ([rt]), :doc "Downloads the code from the remote source, if there is one.  If the source\nis already local, does nothing.  Returns an updated context.", :type :var} {:name make-runner, :file "monkey/ci/runners.clj", :line 118, :type :multimethod} {:name normalize-runner-config, :file "monkey/ci/runners.clj", :line 144, :type :multimethod} {:name store-src, :file "monkey/ci/runners.clj", :line 109, :arglists ([rt]), :doc "If a workspace configuration is present, uses it to store the source in\nthe workspace.  This can then be used by other processes to download the\ncached files as needed.", :type :var}), :doc "Defines runner functionality.  These depend on the application configuration.\nA runner is able to execute a build script."} {:name monkey.ci.runners.oci, :publics ({:name build-container, :file "monkey/ci/runners/oci.clj", :line 18, :type :var} {:name build-ssh-keys, :file "monkey/ci/runners/oci.clj", :line 26, :type :var} {:name format-sid, :file "monkey/ci/runners/oci.clj", :line 19, :type :var} {:name instance-config, :file "monkey/ci/runners/oci.clj", :line 129, :arglists ([conf rt]), :doc "Creates container instance configuration using the context and the\nskeleton config.", :type :var} {:name log-config, :file "monkey/ci/runners/oci.clj", :line 27, :type :var} {:name log-config-dir, :file "monkey/ci/runners/oci.clj", :line 23, :type :var} {:name log-config-file, :file "monkey/ci/runners/oci.clj", :line 24, :type :var} {:name log-config-volume, :file "monkey/ci/runners/oci.clj", :line 22, :type :var} {:name max-script-timeout, :file "monkey/ci/runners/oci.clj", :line 152, :doc "Max msecs a build script can run before we terminate it\n", :type :var} {:name oci-runner, :file "monkey/ci/runners/oci.clj", :line 157, :arglists ([client conf rt]), :doc "Runs the build script as an OCI container instance.  Returns a deferred with\nthe container exit code.", :type :var} {:name ssh-keys-dir, :file "monkey/ci/runners/oci.clj", :line 21, :type :var} {:name ssh-keys-volume, :file "monkey/ci/runners/oci.clj", :line 20, :type :var} {:name wait-for-script-end-event, :file "monkey/ci/runners/oci.clj", :line 145, :arglists ([events sid]), :doc "Returns a deferred that realizes when the script/end event has been received.\n", :type :var})} {:name monkey.ci.runtime, :publics ({:name account, :file "monkey/ci/runtime.clj", :line 70, :type :var} {:name api-url, :file "monkey/ci/runtime.clj", :line 73, :type :var} {:name app-mode, :file "monkey/ci/runtime.clj", :line 66, :type :var} {:name args, :file "monkey/ci/runtime.clj", :line 71, :type :var} {:name build, :file "monkey/ci/runtime.clj", :line 80, :doc "Gets build info from runtime\n", :type :var} {:name cli-mode?, :file "monkey/ci/runtime.clj", :line 67, :type :var} {:name config, :file "monkey/ci/runtime.clj", :line 61, :type :var} {:name config->runtime, :file "monkey/ci/runtime.clj", :line 26, :arglists ([conf]), :doc "Creates the runtime from the normalized config map\n", :type :var} {:name dev-mode?, :file "monkey/ci/runtime.clj", :line 77, :type :var} {:name events-receiver, :file "monkey/ci/runtime.clj", :line 82, :arglists ([{:keys [events]}]), :type :var} {:name from-config, :file "monkey/ci/runtime.clj", :line 63, :arglists ([k]), :type :var} {:name get-arg, :file "monkey/ci/runtime.clj", :line 88, :arglists ([rt k]), :type :var} {:name log-maker, :file "monkey/ci/runtime.clj", :line 74, :type :var} {:name log-retriever, :file "monkey/ci/runtime.clj", :line 75, :type :var} {:name post-events, :file "monkey/ci/runtime.clj", :line 125, :arglists ([{:keys [events]} evt]), :doc "Posts one or more events using the event poster in the runtime\n", :type :var} {:name report, :file "monkey/ci/runtime.clj", :line 91, :arglists ([rt obj]), :doc "Reports `obj` to the user with the reporter from the runtime.\n", :type :var} {:name reporter, :file "monkey/ci/runtime.clj", :line 72, :type :var} {:name rt->env, :file "monkey/ci/runtime.clj", :line 138, :arglists ([rt]), :doc "Returns a map that can be serialized back into env vars.  This is used\nto pass application configuration to child processes or containers.", :type :var} {:name runner, :file "monkey/ci/runtime.clj", :line 79, :type :var} {:name server-mode?, :file "monkey/ci/runtime.clj", :line 68, :type :var} {:name setup-runtime, :file "monkey/ci/runtime.clj", :line 21, :type :multimethod} {:name ssh-keys-dir, :file "monkey/ci/runtime.clj", :line 78, :type :var} {:name start, :file "monkey/ci/runtime.clj", :line 42, :arglists ([rt]), :doc "Starts the runtime by starting all parts as a component tree.  Returns a\ncomponent system that can be passed to `stop`.", :type :var} {:name stop, :file "monkey/ci/runtime.clj", :line 53, :arglists ([rt]), :doc "Stops a previously started runtime\n", :type :var} {:name update-build, :file "monkey/ci/runtime.clj", :line 150, :arglists ([rt f & args]), :doc "Updates the build in the runtime by applying `f` with given args.\n", :type :var} {:name with-runtime, :file "monkey/ci/runtime.clj", :line 111, :arglists ([conf mode r & body]), :doc "Convenience macro that wraps `with-runtime-fn` by binding runtime to `r` and \ninvoking the body.", :type :macro} {:name with-runtime-fn, :file "monkey/ci/runtime.clj", :line 97, :arglists ([conf mode f]), :doc "Creates a runtime for the given mode (server, cli, script) from the specified \nconfiguration and passes it to `f`.", :type :var} {:name work-dir, :file "monkey/ci/runtime.clj", :line 76, :type :var}), :doc "The runtime can be considered the 'live configuration'.  It is created\nfrom the configuration, and is passed on to the application modules.  The\nruntime provides the information (often in the form of functions) needed\nby the modules to perform work.  This allows us to change application \nbehaviour depending on configuration, but also when testing.\n\nThie namespace also provides some utility functions for working with the\ncontext.  This is more stable than reading properties from the runtime \ndirectly."} {:name monkey.ci.script, :publics ({:name exec-script!, :file "monkey/ci/script.clj", :line 243, :arglists ([rt]), :doc "Loads a script from a directory and executes it.  The script is executed in \nthis same process.", :type :var} {:name load-jobs, :file "monkey/ci/script.clj", :line 237, :arglists ([rt]), :doc "Loads the script and resolves the jobs\n", :type :var} {:name make-client, :file "monkey/ci/script.clj", :line 121, :arglists ([{{:keys [url token]} :api}]), :doc "Creates an API client function, that can be invoked by build scripts to \nperform certain operations, like retrieve build parameters.  The client\nuses the token passed by the spawning process to gain access to those\nresources.", :type :var} {:name resolve-jobs, :file "monkey/ci/script.clj", :line 229, :arglists ([p rt]), :doc "The build script either returns a list of pipelines, a set of jobs or a function \nthat returns either.  This function resolves the jobs by processing the script\nreturn value.", :type :var} {:name run-all-jobs, :file "monkey/ci/script.clj", :line 106, :arglists ([{:keys [pipeline], :as rt} jobs]), :doc "Executes all jobs in the set, in dependency order.\n", :type :var} {:name run-all-jobs*, :file "monkey/ci/script.clj", :line 212, :type :var} {:name valid-config?, :file "monkey/ci/script.clj", :line 145, :type :var} {:name with-extensions, :file "monkey/ci/script.clj", :line 98, :doc "Wraps the job so any registered extensions get executed.\n", :type :var})} {:name monkey.ci.sidecar, :publics ({:name mark-abort, :file "monkey/ci/sidecar.clj", :line 59, :arglists ([rt]), :type :var} {:name mark-start, :file "monkey/ci/sidecar.clj", :line 56, :arglists ([rt]), :type :var} {:name poll-events, :file "monkey/ci/sidecar.clj", :line 86, :arglists ([{:keys [job], :as rt}]), :doc "Reads events from the job container events file and posts them to the event service.\n", :type :var} {:name restore-src, :file "monkey/ci/sidecar.clj", :line 18, :arglists ([{:keys [build], :as rt}]), :type :var} {:name run, :file "monkey/ci/sidecar.clj", :line 131, :arglists ([rt]), :doc "Runs sidecar by restoring workspace, artifacts and caches, and then polling for events.\nAfter the event loop has terminated, saves artifacts and caches and returns a deferred\ncontaining the runtime with an `:exit-code` added.", :type :var} {:name upload-logs, :file "monkey/ci/sidecar.clj", :line 78, :arglists ([evt logger]), :doc "Uploads log files referenced in the event, if any\n", :type :var}), :doc "Sidecar specific functions\n"} {:name monkey.ci.spec, :publics ({:name blob-type, :file "monkey/ci/spec.clj", :line 70, :type :multimethod} {:name logging-type, :file "monkey/ci/spec.clj", :line 157, :type :multimethod} {:name storage-type, :file "monkey/ci/spec.clj", :line 56, :type :multimethod} {:name url?, :file "monkey/ci/spec.clj", :line 18, :type :var} {:name valid?, :file "monkey/ci/spec.clj", :line 9, :arglists ([spec x]), :doc "Checks if the object is conform to the spec, and also prints a handy warning\nif not.", :type :var})} {:name monkey.ci.spec.build, :publics ({:name build-states, :file "monkey/ci/spec/build.clj", :line 49, :type :var} {:name id?, :file "monkey/ci/spec/build.clj", :line 7, :type :var} {:name path?, :file "monkey/ci/spec/build.clj", :line 9, :type :var} {:name ts?, :file "monkey/ci/spec/build.clj", :line 8, :type :var}), :doc "Spec definitions for build.  The build object in the runtime and events that contain\nbuilds, scripts or jobs should conform to these specs."} {:name monkey.ci.spec.common, :publics ({:name url-regex, :file "monkey/ci/spec/common.clj", :line 3, :type :var} {:name url?, :file "monkey/ci/spec/common.clj", :line 5, :arglists ([x]), :type :var})} {:name monkey.ci.spec.events, :publics (), :doc "Spec definitions for events\n"} {:name monkey.ci.spec.extensions, :publics ()} {:name monkey.ci.storage, :publics ({:name ->sid, :file "monkey/ci/storage.clj", :line 17, :type :var} {:name build-exists?, :file "monkey/ci/storage.clj", :line 195, :arglists ([s sid]), :doc "Checks efficiently if the build exists.  This is cheaper than trying to fetch it\nand checking if the result is `nil`.", :type :var} {:name build-metadata-sid, :file "monkey/ci/storage.clj", :line 165, :deprecated true, :type :var} {:name build-results-sid, :file "monkey/ci/storage.clj", :line 166, :deprecated true, :type :var} {:name build-sid, :file "monkey/ci/storage.clj", :line 149, :type :var} {:name build-sid-keys, :file "monkey/ci/storage.clj", :line 146, :type :var} {:name builds, :file "monkey/ci/storage.clj", :line 145, :type :var} {:name create-build-metadata, :file "monkey/ci/storage.clj", :line 168, :arglists ([s sid md] [s md]), :deprecated true, :type :var} {:name customer-sid, :file "monkey/ci/storage.clj", :line 81, :type :var} {:name ext-build-sid, :file "monkey/ci/storage.clj", :line 148, :type :var} {:name ext-repo-sid, :file "monkey/ci/storage.clj", :line 107, :type :var} {:name find-build, :file "monkey/ci/storage.clj", :line 212, :arglists ([s sid]), :doc "Finds build by sid\n", :type :var} {:name find-build-metadata, :file "monkey/ci/storage.clj", :line 174, :arglists ([s sid]), :deprecated true, :doc "Reads the build metadata given the build coordinates (required to build the path)\n", :type :var} {:name find-build-results, :file "monkey/ci/storage.clj", :line 182, :arglists ([s sid]), :deprecated true, :doc "Reads the build results given the build coordinates\n", :type :var} {:name find-customer, :file "monkey/ci/storage.clj", :line 86, :arglists ([s id]), :type :var} {:name find-details-for-webhook, :file "monkey/ci/storage.clj", :line 142, :arglists ([s id]), :type :var} {:name find-params, :file "monkey/ci/storage.clj", :line 226, :arglists ([s cust-id]), :type :var} {:name find-repo, :file "monkey/ci/storage.clj", :line 96, :arglists ([s [cust-id id]]), :doc "Reads the repo, as part of the customer object's projects\n", :type :var} {:name find-ssh-keys, :file "monkey/ci/storage.clj", :line 238, :arglists ([s cust-id]), :type :var} {:name find-user, :file "monkey/ci/storage.clj", :line 251, :arglists ([s id]), :type :var} {:name find-watched-github-repos, :file "monkey/ci/storage.clj", :line 110, :arglists ([s github-id]), :doc "Looks up all watched repos with the given github id\n", :type :var} {:name global, :file "monkey/ci/storage.clj", :line 77, :type :var} {:name global-sid, :file "monkey/ci/storage.clj", :line 78, :arglists ([type id]), :type :var} {:name legacy-build-exists?, :file "monkey/ci/storage.clj", :line 201, :arglists ([s sid]), :doc "Similar to `build-exists?` but for legacy builds that consist of metadata and \nresult entities.", :type :var} {:name list-builds, :file "monkey/ci/storage.clj", :line 217, :arglists ([s sid]), :doc "Lists the ids of the builds for given repo sid\n", :type :var} {:name make-memory-storage, :file "monkey/ci/storage.clj", :line 47, :arglists ([]), :type :var} {:name make-storage, :file "monkey/ci/storage.clj", :line 50, :type :multimethod} {:name new-id, :file "monkey/ci/storage.clj", :line 19, :doc "Generates a new random id\n", :type :var} {:name normalize-storage-config, :file "monkey/ci/storage.clj", :line 56, :type :multimethod} {:name params-sid, :file "monkey/ci/storage.clj", :line 222, :arglists ([customer-id]), :type :var} {:name patch-build-results, :file "monkey/ci/storage.clj", :line 187, :arglists ([st sid f & args]), :deprecated true, :doc "Finds the build result with given sid, then applies `f` to it with arguments\nand saves the return value back into the result.", :type :var} {:name save-build, :file "monkey/ci/storage.clj", :line 207, :arglists ([s build]), :doc "Creates or updates the build entity\n", :type :var} {:name save-build-results, :file "monkey/ci/storage.clj", :line 179, :arglists ([s sid r]), :deprecated true, :type :var} {:name save-customer, :file "monkey/ci/storage.clj", :line 83, :arglists ([s cust]), :type :var} {:name save-params, :file "monkey/ci/storage.clj", :line 229, :arglists ([s cust-id p]), :type :var} {:name save-repo, :file "monkey/ci/storage.clj", :line 89, :arglists ([s {:keys [customer-id id], :as r}]), :doc "Saves the repository by updating the customer it belongs to\n", :type :var} {:name save-ssh-keys, :file "monkey/ci/storage.clj", :line 235, :arglists ([s cust-id key]), :type :var} {:name save-user, :file "monkey/ci/storage.clj", :line 248, :arglists ([s u]), :type :var} {:name save-webhook-details, :file "monkey/ci/storage.clj", :line 139, :arglists ([s details]), :type :var} {:name sid?, :file "monkey/ci/storage.clj", :line 16, :type :var} {:name ssh-keys-sid, :file "monkey/ci/storage.clj", :line 232, :arglists ([cust-id]), :type :var} {:name unwatch-github-repo, :file "monkey/ci/storage.clj", :line 125, :arglists ([s sid]), :doc "Removes the records to stop watching the repo.  The entity will still \nexist, so any past builds can be looked up.", :type :var} {:name update-repo, :file "monkey/ci/storage.clj", :line 102, :arglists ([s [cust-id repo-id] f & args]), :doc "Applies `f` to the repo with given sid\n", :type :var} {:name user->sid, :file "monkey/ci/storage.clj", :line 246, :type :var} {:name user-sid, :file "monkey/ci/storage.clj", :line 243, :arglists ([[type id]]), :type :var} {:name users, :file "monkey/ci/storage.clj", :line 241, :type :var} {:name watch-github-repo, :file "monkey/ci/storage.clj", :line 116, :arglists ([s {:keys [customer-id id github-id], :as r}]), :doc "Creates necessary records to start watching a github repo.  Creates the\nrepo entity and returns it.", :type :var} {:name watched-sid, :file "monkey/ci/storage.clj", :line 108, :type :var} {:name webhook-sid, :file "monkey/ci/storage.clj", :line 137, :type :var}), :doc "Data storage functionality\n"} {:name monkey.ci.storage.cached, :publics (), :doc "Cached storage implementation.  It wraps another storage and adds caching to it.\nThis currently is a very naive implementation.  It should be expanded with event processing,\nin case there are multiple replicas.  Or we should replace it with a 'real' database."} {:name monkey.ci.storage.file, :publics ({:name ext, :file "monkey/ci/storage/file.clj", :line 23, :type :var} {:name make-file-storage, :file "monkey/ci/storage/file.clj", :line 62, :arglists ([dir]), :type :var}), :doc "File storage implementation.  Useful for local or develop runs.  It stores all\ninformation in local .edn files."} {:name monkey.ci.storage.oci, :publics ({:name ->edn, :file "monkey/ci/storage/oci.clj", :line 18, :type :var} {:name delim, :file "monkey/ci/storage/oci.clj", :line 20, :type :var} {:name ext, :file "monkey/ci/storage/oci.clj", :line 17, :type :var} {:name get-ns, :file "monkey/ci/storage/oci.clj", :line 14, :type :var} {:name make-oci-storage, :file "monkey/ci/storage/oci.clj", :line 95, :arglists ([conf]), :doc "Creates storage object for OCI buckets, using the configuration specified.\nThis configuration should also include OCI credentials.", :type :var} {:name make-path, :file "monkey/ci/storage/oci.clj", :line 22, :arglists ([sid]), :type :var} {:name parse-edn, :file "monkey/ci/storage/oci.clj", :line 19, :type :var} {:name stream?, :file "monkey/ci/storage/oci.clj", :line 34, :type :var})} {:name monkey.ci.utils, :publics ({:name ->base64, :file "monkey/ci/utils.clj", :line 130, :arglists ([s]), :type :var} {:name ->seq, :file "monkey/ci/utils.clj", :line 159, :arglists ([x]), :doc "Converts `x` into a sequential\n", :type :var} {:name abs-path, :file "monkey/ci/utils.clj", :line 18, :arglists ([a b] [p]), :doc "If `b` is a relative path, will combine it with `a`, otherwise\nwill just return `b`.", :type :var} {:name add-shutdown-hook!, :file "monkey/ci/utils.clj", :line 46, :arglists ([h]), :doc "Executes `h` when the JVM shuts down.  Returns the thread that will\nexecute the hook.", :type :var} {:name combine, :file "monkey/ci/utils.clj", :line 32, :arglists ([a b]), :doc "Returns the canonical path of combining `a` and `b`\n", :type :var} {:name cwd, :file "monkey/ci/utils.clj", :line 13, :arglists ([]), :doc "Returns current directory\n", :type :var} {:name deep-merge, :file "monkey/ci/utils.clj", :line 128, :type :var} {:name delete-dir, :file "monkey/ci/utils.clj", :line 66, :arglists ([dir]), :doc "Deletes directory recursively\n", :type :var} {:name fn-name, :file "monkey/ci/utils.clj", :line 96, :arglists ([x]), :doc "If x points to a fn, returns its name without namespace\n", :type :var} {:name load-privkey, :file "monkey/ci/utils.clj", :line 75, :arglists ([f]), :doc "Load private key from file or from string\n", :type :var} {:name new-build-id, :file "monkey/ci/utils.clj", :line 71, :arglists ([]), :type :var} {:name now, :file "monkey/ci/utils.clj", :line 156, :arglists ([]), :type :var} {:name parse-edn, :file "monkey/ci/utils.clj", :line 87, :arglists ([r & [opts]]), :doc "Parses edn from the reader\n", :type :var} {:name parse-edn-str, :file "monkey/ci/utils.clj", :line 92, :arglists ([s]), :type :var} {:name parse-sid, :file "monkey/ci/utils.clj", :line 134, :arglists ([s]), :type :var} {:name prop-pred, :file "monkey/ci/utils.clj", :line 143, :arglists ([p v]), :doc "Returns a fn that is a predicate to match property `p` with value `v`\n", :type :var} {:name prune-tree, :file "monkey/ci/utils.clj", :line 117, :arglists ([t]), :type :var} {:name rebase-path, :file "monkey/ci/utils.clj", :line 37, :arglists ([p from to]), :doc "Given two absolute paths, recalculates p so that it becomes relative to `to` instead\nof `from`.", :type :var} {:name serialize-sid, :file "monkey/ci/utils.clj", :line 141, :type :var} {:name sid->repo-sid, :file "monkey/ci/utils.clj", :line 138, :arglists ([s]), :type :var} {:name stack-trace, :file "monkey/ci/utils.clj", :line 104, :arglists ([ex]), :doc "Prints stack trace to a string\n", :type :var} {:name tmp-dir, :file "monkey/ci/utils.clj", :line 55, :arglists ([]), :type :var} {:name tmp-file, :file "monkey/ci/utils.clj", :line 58, :arglists ([prefix suffix] [name]), :doc "Generates a new temporary path\n", :type :var} {:name try-slurp, :file "monkey/ci/utils.clj", :line 148, :arglists ([x]), :doc "Reads the file if it exists, or just returns x\n", :type :var})} {:name monkey.ci.web.api, :publics ({:name allowed-events, :file "monkey/ci/web/api.clj", :line 356, :type :var} {:name body, :file "monkey/ci/web/api.clj", :line 20, :type :var} {:name build->out, :file "monkey/ci/web/api.clj", :line 225, :arglists ([b]), :doc "Converts build to output format.  This means converting legacy builds with pipelines,\njobs and regular builds with jobs.", :type :var} {:name create-customer, :type :var} {:name create-repo, :type :var} {:name create-user, :type :var} {:name create-webhook, :file "monkey/ci/web/api.clj", :line 131, :type :var} {:name customer-id, :file "monkey/ci/web/api.clj", :line 139, :type :var} {:name download-build-log, :file "monkey/ci/web/api.clj", :line 347, :arglists ([req]), :type :var} {:name event-stream, :file "monkey/ci/web/api.clj", :line 364, :arglists ([req]), :doc "Sets up an event stream for the specified filter.\n", :type :var} {:name fetch-build-details, :file "monkey/ci/web/api.clj", :line 189, :arglists ([s sid]), :type :var} {:name get-build, :file "monkey/ci/web/api.clj", :line 278, :arglists ([req]), :doc "Retrieves build by id\n", :type :var} {:name get-builds, :file "monkey/ci/web/api.clj", :line 261, :arglists ([req]), :doc "Lists all builds for the repository\n", :type :var} {:name get-customer, :type :var} {:name get-customer-params, :file "monkey/ci/web/api.clj", :line 168, :doc "Retrieves all parameters configured on the customer.  This is for administration purposes.\n", :type :var} {:name get-customer-ssh-keys, :file "monkey/ci/web/api.clj", :line 180, :type :var} {:name get-latest-build, :file "monkey/ci/web/api.clj", :line 268, :arglists ([req]), :doc "Retrieves the latest build for the repository.\n", :type :var} {:name get-repo, :type :var} {:name get-repo-params, :file "monkey/ci/web/api.clj", :line 172, :doc "Retrieves the parameters that are available for the given repository.  This depends\non the parameter label filters and the repository labels.", :type :var} {:name get-repo-ssh-keys, :file "monkey/ci/web/api.clj", :line 183, :type :var} {:name get-user, :type :var} {:name get-webhook, :type :var} {:name list-build-logs, :file "monkey/ci/web/api.clj", :line 342, :arglists ([req]), :type :var} {:name make-build-ctx, :file "monkey/ci/web/api.clj", :line 298, :arglists ([{p :parameters, :as req} bid]), :doc "Creates a build object from the request\n", :type :var} {:name params-sid, :file "monkey/ci/web/api.clj", :line 137, :type :var} {:name repo-id, :file "monkey/ci/web/api.clj", :line 90, :type :var} {:name repo-sid, :file "monkey/ci/web/api.clj", :line 134, :type :var} {:name trigger-build, :file "monkey/ci/web/api.clj", :line 324, :arglists ([req]), :type :var} {:name update-customer, :type :var} {:name update-params, :file "monkey/ci/web/api.clj", :line 177, :type :var} {:name update-repo, :type :var} {:name update-ssh-keys, :file "monkey/ci/web/api.clj", :line 186, :type :var} {:name update-user, :type :var} {:name update-webhook, :type :var})} {:name monkey.ci.web.auth, :publics ({:name augment-payload, :file "monkey/ci/web/auth.clj", :line 49, :arglists ([payload]), :type :var} {:name build-token, :file "monkey/ci/web/auth.clj", :line 32, :arglists ([build-sid]), :doc "Creates token contents for a build, to be used by a build script.\n", :type :var} {:name config->keypair, :file "monkey/ci/web/auth.clj", :line 84, :arglists ([conf]), :doc "Loads private and public keys from the app config, returns a map that can be\nused in the context `:jwk`.", :type :var} {:name customer-authorization, :file "monkey/ci/web/auth.clj", :line 182, :arglists ([h]), :doc "Middleware that verifies the identity token to check if the user or build has\naccess to the given customer.", :type :var} {:name default-token-expiration, :file "monkey/ci/web/auth.clj", :line 47, :type :var} {:name expired?, :file "monkey/ci/web/auth.clj", :line 118, :arglists ([{:keys [exp]}]), :doc "Returns true if token has expired\n", :type :var} {:name generate-jwt, :file "monkey/ci/web/auth.clj", :line 66, :arglists ([req payload]), :doc "Signs a JWT using the keypair from the request context.\n", :type :var} {:name generate-jwt-from-rt, :file "monkey/ci/web/auth.clj", :line 58, :arglists ([rt payload]), :doc "Generates a JWT from the private key in the runtime\n", :type :var} {:name generate-keypair, :file "monkey/ci/web/auth.clj", :line 73, :arglists ([]), :doc "Generates a new RSA keypair\n", :type :var} {:name generate-secret-key, :file "monkey/ci/web/auth.clj", :line 38, :arglists ([]), :doc "Generates a random secret key object\n", :type :var} {:name jwks, :file "monkey/ci/web/auth.clj", :line 111, :arglists ([req]), :doc "JWKS endpoint handler\n", :type :var} {:name keypair->rt, :file "monkey/ci/web/auth.clj", :line 80, :arglists ([kp]), :type :var} {:name kid, :file "monkey/ci/web/auth.clj", :line 22, :type :var} {:name make-jwk, :file "monkey/ci/web/auth.clj", :line 98, :arglists ([pub]), :doc "Creates a JWK object from a public key that can be exposed for external \nverification.", :type :var} {:name resolve-token, :file "monkey/ci/web/auth.clj", :line 123, :type :multimethod} {:name role-build, :file "monkey/ci/web/auth.clj", :line 24, :type :var} {:name role-user, :file "monkey/ci/web/auth.clj", :line 23, :type :var} {:name rt->pub-key, :file "monkey/ci/web/auth.clj", :line 109, :type :var} {:name secure-ring-app, :file "monkey/ci/web/auth.clj", :line 156, :arglists ([app rt]), :doc "Wraps the ring handler so it verifies the JWT authorization header\n", :type :var} {:name sign-jwt, :file "monkey/ci/web/auth.clj", :line 44, :arglists ([payload pk]), :type :var} {:name user-token, :file "monkey/ci/web/auth.clj", :line 26, :arglists ([user-sid]), :doc "Creates token contents for an authenticated user\n", :type :var}), :doc "Authentication and authorization functions\n"} {:name monkey.ci.web.common, :publics ({:name default-middleware, :file "monkey/ci/web/common.clj", :line 72, :type :var} {:name exception-middleware, :file "monkey/ci/web/common.clj", :line 62, :type :var} {:name from-rt, :file "monkey/ci/web/common.clj", :line 30, :arglists ([req f]), :doc "Applies `f` to the request runtime\n", :type :var} {:name make-app, :file "monkey/ci/web/common.clj", :line 81, :arglists ([router]), :type :var} {:name make-muuntaja, :file "monkey/ci/web/common.clj", :line 40, :arglists ([]), :doc "Creates muuntaja instance with custom settings\n", :type :var} {:name parse-json, :file "monkey/ci/web/common.clj", :line 88, :arglists ([s]), :type :var} {:name req->rt, :file "monkey/ci/web/common.clj", :line 24, :arglists ([req]), :doc "Gets the runtime from the request\n", :type :var} {:name req->storage, :file "monkey/ci/web/common.clj", :line 35, :arglists ([req]), :doc "Retrieves storage object from the request context\n", :type :var} {:name run-build-async, :file "monkey/ci/web/common.clj", :line 94, :arglists ([rt]), :doc "Starts the build in a new thread\n", :type :var})} {:name monkey.ci.web.github, :publics ({:name app-webhook, :file "monkey/ci/web/github.clj", :line 146, :arglists ([req]), :type :var} {:name body, :file "monkey/ci/web/github.clj", :line 122, :type :var} {:name create-app-build, :file "monkey/ci/web/github.clj", :line 112, :arglists ([rt {:keys [customer-id id]} payload]), :doc "Creates a build as triggered from an app call.  This does not originate from a\nwebhook, but rather from a watched repo.", :type :var} {:name create-build, :file "monkey/ci/web/github.clj", :line 72, :arglists ([{st :storage, :as rt} init-build payload]), :doc "Looks up details for the given github webhook.  If the webhook refers to a valid \nconfiguration, a build entity is created and a build structure is returned, which\neventually will be passed on to the runner.", :type :var} {:name create-webhook-build, :file "monkey/ci/web/github.clj", :line 101, :arglists ([{st :storage, :as rt} id payload]), :type :var} {:name extract-signature, :file "monkey/ci/web/github.clj", :line 24, :arglists ([s]), :type :var} {:name get-config, :file "monkey/ci/web/github.clj", :line 251, :arglists ([req]), :doc "Lists public github configuration to use\n", :type :var} {:name github-event, :file "monkey/ci/web/github.clj", :line 59, :arglists ([req]), :type :var} {:name github-push?, :file "monkey/ci/web/github.clj", :line 62, :doc "Checks if the incoming request is actually a push.  Github can also\nsend other types of requests.", :type :var} {:name login, :file "monkey/ci/web/github.clj", :line 236, :arglists ([req]), :doc "Invoked by the frontend during OAuth2 login flow.  It requests a Github\nuser access token using the given authorization code.", :type :var} {:name req->repo-sid, :file "monkey/ci/web/github.clj", :line 39, :type :var} {:name req->webhook-id, :file "monkey/ci/web/github.clj", :line 38, :type :var} {:name should-trigger-build?, :file "monkey/ci/web/github.clj", :line 124, :type :var} {:name unwatch-repo, :file "monkey/ci/web/github.clj", :line 182, :arglists ([req]), :type :var} {:name valid-security?, :file "monkey/ci/web/github.clj", :line 30, :arglists ([{:keys [secret payload x-hub-signature]}]), :doc "Validates security header\n", :type :var} {:name validate-security, :file "monkey/ci/web/github.clj", :line 41, :arglists ([h get-secret] [h]), :doc "Middleware that validates the github security header using a fn that retrieves\nthe secret for the request.", :type :var} {:name watch-repo, :file "monkey/ci/web/github.clj", :line 167, :arglists ([req]), :doc "Adds the repository to the watch list for github webhooks.  If the repo\ndoes not exist, it will be created.", :type :var} {:name webhook, :file "monkey/ci/web/github.clj", :line 127, :arglists ([{p :parameters, :as req}]), :doc "Receives an incoming webhook from Github.  This starts the build\nrunner async and returns a 202 accepted.", :type :var}), :doc "Functionality specific for Github\n"} {:name monkey.ci.web.handler, :publics ({:name auth-routes, :file "monkey/ci/web/handler.clj", :line 234, :type :var} {:name build-routes, :file "monkey/ci/web/handler.clj", :line 162, :type :var} {:name customer-parameter-routes, :file "monkey/ci/web/handler.clj", :line 146, :type :var} {:name customer-routes, :file "monkey/ci/web/handler.clj", :line 212, :type :var} {:name customer-ssh-keys-routes, :file "monkey/ci/web/handler.clj", :line 154, :type :var} {:name default-http-opts, :file "monkey/ci/web/handler.clj", :line 341, :type :var} {:name event-stream-routes, :file "monkey/ci/web/handler.clj", :line 208, :type :var} {:name github-routes, :file "monkey/ci/web/handler.clj", :line 227, :type :var} {:name github-unwatch-route, :file "monkey/ci/web/handler.clj", :line 189, :type :var} {:name github-watch-route, :file "monkey/ci/web/handler.clj", :line 184, :type :var} {:name health, :file "monkey/ci/web/handler.clj", :line 26, :arglists ([_]), :type :var} {:name Id, :file "monkey/ci/web/handler.clj", :line 43, :type :var} {:name Label, :file "monkey/ci/web/handler.clj", :line 49, :type :var} {:name LabelFilter, :file "monkey/ci/web/handler.clj", :line 91, :type :var} {:name LabelFilterConjunction, :file "monkey/ci/web/handler.clj", :line 87, :type :var} {:name make-app, :file "monkey/ci/web/handler.clj", :line 336, :arglists ([rt]), :type :var} {:name make-router, :file "monkey/ci/web/handler.clj", :line 299, :arglists ([rt routes] [rt]), :type :var} {:name metrics, :file "monkey/ci/web/handler.clj", :line 35, :arglists ([req]), :type :var} {:name Name, :file "monkey/ci/web/handler.clj", :line 44, :type :var} {:name NewCustomer, :file "monkey/ci/web/handler.clj", :line 53, :type :var} {:name NewRepo, :file "monkey/ci/web/handler.clj", :line 66, :type :var} {:name NewWebhook, :file "monkey/ci/web/handler.clj", :line 59, :type :var} {:name not-empty-str, :file "monkey/ci/web/handler.clj", :line 42, :type :var} {:name on-server-close, :file "monkey/ci/web/handler.clj", :line 383, :arglists ([server]), :doc "Returns a deferred that resolves when the server shuts down.\n", :type :var} {:name Parameters, :file "monkey/ci/web/handler.clj", :line 94, :type :var} {:name ParameterValue, :file "monkey/ci/web/handler.clj", :line 83, :type :var} {:name repo-parameter-routes, :file "monkey/ci/web/handler.clj", :line 151, :type :var} {:name repo-routes, :file "monkey/ci/web/handler.clj", :line 193, :type :var} {:name repo-ssh-keys-routes, :file "monkey/ci/web/handler.clj", :line 159, :type :var} {:name routes, :file "monkey/ci/web/handler.clj", :line 255, :type :var} {:name SshKeys, :file "monkey/ci/web/handler.clj", :line 99, :type :var} {:name start-server, :file "monkey/ci/web/handler.clj", :line 346, :arglists ([rt]), :doc "Starts http server.  Returns a server object that can be passed to\n`stop-server`.", :type :var} {:name stop-server, :file "monkey/ci/web/handler.clj", :line 355, :arglists ([s]), :type :var} {:name UpdateCustomer, :file "monkey/ci/web/handler.clj", :line 56, :type :var} {:name UpdateRepo, :file "monkey/ci/web/handler.clj", :line 73, :type :var} {:name UpdateWebhook, :file "monkey/ci/web/handler.clj", :line 63, :type :var} {:name User, :file "monkey/ci/web/handler.clj", :line 105, :type :var} {:name user-routes, :file "monkey/ci/web/handler.clj", :line 239, :type :var} {:name version, :file "monkey/ci/web/handler.clj", :line 31, :arglists ([_]), :type :var} {:name WatchGithubRepo, :file "monkey/ci/web/handler.clj", :line 78, :type :var} {:name webhook-routes, :file "monkey/ci/web/handler.clj", :line 125, :type :var}), :doc "Handler for the web server\n"} {:name monkey.ci.web.script-api, :publics ({:name edn, :file "monkey/ci/web/script_api.clj", :line 45, :type :var} {:name get-params, :file "monkey/ci/web/script_api.clj", :line 31, :arglists ([req]), :type :var} {:name listen-at-socket, :file "monkey/ci/web/script_api.clj", :line 95, :arglists ([path ctx]), :doc "Starts a script api that is listening at given socket path\n", :type :var} {:name local-api, :file "monkey/ci/web/script_api.clj", :line 111, :arglists ([{:keys [storage], :as rt}]), :doc "Local api implementation.  This is used as a backend for the script API server\nwhen it is run locally.  It retrieves all information directly from local storage.", :type :var} {:name make-app, :file "monkey/ci/web/script_api.clj", :line 82, :arglists ([opts]), :type :var} {:name make-router, :file "monkey/ci/web/script_api.clj", :line 71, :arglists ([opts routes] [opts]), :type :var} {:name post-event, :file "monkey/ci/web/script_api.clj", :line 34, :arglists ([req]), :type :var} {:name routes, :file "monkey/ci/web/script_api.clj", :line 47, :type :var} {:name start-server, :file "monkey/ci/web/script_api.clj", :line 85, :arglists ([{:keys [http], :as opts}]), :doc "Starts a http server using the given options to configure the routes and the server.\nReturns an `org.httpkit.server.IHttpServer` object.", :type :var} {:name stop-server, :file "monkey/ci/web/script_api.clj", :line 93, :type :var}), :doc "API functionality that can be accessed by the build script.  This can either\nbe part of the public API, or exposed through a UDS from the build runner.  The\nscript API does not have security on its own, since the implementation will\ntake care of this.  The script API exposes an OpenAPI spec, which is then\nfetched by the script, so it knows which services are available."} {:name monkey.ci.workspace, :publics ()})}, :pom-str "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project xmlns=\"http://maven.apache.org/POM/4.0.0\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd\">\n  <modelVersion>4.0.0</modelVersion>\n  <packaging>jar</packaging>\n  <groupId>com.monkeyci</groupId>\n  <artifactId>app</artifactId>\n  <version>0.4.9.1</version>\n  <name>app</name>\n  <repositories>\n    <repository>\n      <id>clojars</id>\n      <url>https://repo.clojars.org/</url>\n    </repository>\n  </repositories>\n  <licenses>\n    <license>\n      <name>GPL 3</name>\n      <url>https://www.gnu.org/licenses/gpl-3.0.en.html#license-text</url>\n    </license>\n  </licenses>\n  <scm>\n    <url>https://github.com/monkey-projects/monkeyci</url>\n  </scm>\n  <dependencies>\n    <dependency>\n      <groupId>metosin</groupId>\n      <artifactId>reitit-middleware</artifactId>\n      <version>0.7.0-alpha5</version>\n    </dependency>\n    <dependency>\n      <groupId>io.resonant</groupId>\n      <artifactId>micrometer-clj</artifactId>\n      <version>0.0.4</version>\n    </dependency>\n    <dependency>\n      <groupId>buddy</groupId>\n      <artifactId>buddy-core</artifactId>\n      <version>1.11.423</version>\n    </dependency>\n    <dependency>\n      <groupId>org.clojure</groupId>\n      <artifactId>clojure</artifactId>\n      <version>1.11.1</version>\n    </dependency>\n    <dependency>\n      <groupId>org.clojure</groupId>\n      <artifactId>tools.logging</artifactId>\n      <version>1.2.4</version>\n    </dependency>\n    <dependency>\n      <groupId>org.zeromq</groupId>\n      <artifactId>jeromq</artifactId>\n      <version>0.5.4</version>\n    </dependency>\n    <dependency>\n      <groupId>cli-matic</groupId>\n      <artifactId>cli-matic</artifactId>\n      <version>0.5.4</version>\n    </dependency>\n    <dependency>\n      <groupId>com.github.loki4j</groupId>\n      <artifactId>loki-logback-appender</artifactId>\n      <version>1.5.0-m1</version>\n    </dependency>\n    <dependency>\n      <groupId>com.github.oliyh</groupId>\n      <artifactId>martian-httpkit</artifactId>\n      <version>0.1.25</version>\n    </dependency>\n    <dependency>\n      <groupId>org.clojars.lispyclouds</groupId>\n      <artifactId>contajners</artifactId>\n      <version>1.0.1</version>\n    </dependency>\n    <dependency>\n      <groupId>bowerick</groupId>\n      <artifactId>bowerick</artifactId>\n      <version>2.9.8</version>\n      <exclusions>\n        <exclusion>\n          <groupId>org.slf4j</groupId>\n          <artifactId>slf4j-simple</artifactId>\n        </exclusion>\n      </exclusions>\n    </dependency>\n    <dependency>\n      <groupId>io.micrometer</groupId>\n      <artifactId>micrometer-registry-prometheus</artifactId>\n      <version>1.12.4</version>\n    </dependency>\n    <dependency>\n      <groupId>clansi</groupId>\n      <artifactId>clansi</artifactId>\n      <version>1.0.0</version>\n    </dependency>\n    <dependency>\n      <groupId>ring-cors</groupId>\n      <artifactId>ring-cors</artifactId>\n      <version>0.1.13</version>\n    </dependency>\n    <dependency>\n      <groupId>com.stuartsierra</groupId>\n      <artifactId>component</artifactId>\n      <version>1.1.0</version>\n    </dependency>\n    <dependency>\n      <groupId>commons-io</groupId>\n      <artifactId>commons-io</artifactId>\n      <version>2.15.1</version>\n    </dependency>\n    <dependency>\n      <groupId>metosin</groupId>\n      <artifactId>reitit-swagger</artifactId>\n      <version>0.7.0-alpha5</version>\n    </dependency>\n    <dependency>\n      <groupId>aleph</groupId>\n      <artifactId>aleph</artifactId>\n      <version>0.7.0-alpha2</version>\n    </dependency>\n    <dependency>\n      <groupId>metosin</groupId>\n      <artifactId>reitit-ring</artifactId>\n      <version>0.7.0-alpha5</version>\n    </dependency>\n    <dependency>\n      <groupId>com.monkeyprojects</groupId>\n      <artifactId>oci-container-instance</artifactId>\n      <version>0.1.0</version>\n    </dependency>\n    <dependency>\n      <groupId>com.monkeyprojects</groupId>\n      <artifactId>oci-os</artifactId>\n      <version>0.2.2</version>\n    </dependency>\n    <dependency>\n      <groupId>clojure.java-time</groupId>\n      <artifactId>clojure.java-time</artifactId>\n      <version>1.4.2</version>\n    </dependency>\n    <dependency>\n      <groupId>metosin</groupId>\n      <artifactId>reitit-schema</artifactId>\n      <version>0.7.0-alpha5</version>\n    </dependency>\n    <dependency>\n      <groupId>io.micrometer</groupId>\n      <artifactId>micrometer-core</artifactId>\n      <version>1.12.4</version>\n    </dependency>\n    <dependency>\n      <groupId>com.monkeyprojects</groupId>\n      <artifactId>clompress</artifactId>\n      <version>0.1.1</version>\n    </dependency>\n    <dependency>\n      <groupId>clj-commons</groupId>\n      <artifactId>clj-yaml</artifactId>\n      <version>1.0.27</version>\n    </dependency>\n    <dependency>\n      <groupId>yogthos</groupId>\n      <artifactId>config</artifactId>\n      <version>1.2.0</version>\n    </dependency>\n    <dependency>\n      <groupId>babashka</groupId>\n      <artifactId>process</artifactId>\n      <version>0.5.21</version>\n    </dependency>\n    <dependency>\n      <groupId>buddy</groupId>\n      <artifactId>buddy-auth</artifactId>\n      <version>3.0.323</version>\n    </dependency>\n    <dependency>\n      <groupId>clj-jgit</groupId>\n      <artifactId>clj-jgit</artifactId>\n      <version>1.0.2</version>\n      <exclusions>\n        <exclusion>\n          <groupId>org.bouncycastle</groupId>\n          <artifactId>bcpg-jdk15on</artifactId>\n        </exclusion>\n        <exclusion>\n          <groupId>org.bouncycastle</groupId>\n          <artifactId>bcprov-jdk15on</artifactId>\n        </exclusion>\n        <exclusion>\n          <groupId>org.bouncycastle</groupId>\n          <artifactId>bcpkix-jdk15on</artifactId>\n        </exclusion>\n        <exclusion>\n          <groupId>org.bouncycastle</groupId>\n          <artifactId>bcutil-jdk15on</artifactId>\n        </exclusion>\n      </exclusions>\n    </dependency>\n    <dependency>\n      <groupId>com.monkeyprojects</groupId>\n      <artifactId>zmq</artifactId>\n      <version>0.3.2</version>\n      <exclusions>\n        <exclusion>\n          <groupId>org.zeromq</groupId>\n          <artifactId>jzmq</artifactId>\n        </exclusion>\n      </exclusions>\n    </dependency>\n    <dependency>\n      <groupId>ch.qos.logback</groupId>\n      <artifactId>logback-classic</artifactId>\n      <version>1.5.1</version>\n    </dependency>\n    <dependency>\n      <groupId>camel-snake-kebab</groupId>\n      <artifactId>camel-snake-kebab</artifactId>\n      <version>0.4.3</version>\n    </dependency>\n    <dependency>\n      <groupId>com.monkeyprojects</groupId>\n      <artifactId>socket-async</artifactId>\n      <version>0.1.0</version>\n    </dependency>\n    <dependency>\n      <groupId>medley</groupId>\n      <artifactId>medley</artifactId>\n      <version>1.4.0</version>\n    </dependency>\n    <dependency>\n      <groupId>com.monkeyprojects</groupId>\n      <artifactId>oci-sign</artifactId>\n      <version>0.1.3</version>\n    </dependency>\n    <dependency>\n      <groupId>org.clojure</groupId>\n      <artifactId>core.async</artifactId>\n      <version>1.6.681</version>\n    </dependency>\n    <dependency>\n      <groupId>http-kit</groupId>\n      <artifactId>http-kit</artifactId>\n      <version>2.7.0</version>\n    </dependency>\n  </dependencies>\n</project>\n"}