@atomist/sdm-core

@atomist/sdm-core

Version 1.9.0
Published 4 years ago
5.51 MB
28 dependencies
Apache-2.0 license

Install

npm i @atomist/sdm-core

yarn add @atomist/sdm-core

pnpm add @atomist/sdm-core

Overview

Atomist Software Delivery Machine - Implementation

Index

Variables

variable ContainerProjectHome

const ContainerProjectHome: string;

File system location of goal project in containers.

variable DisableDeploy

const DisableDeploy: CommandHandlerRegistration<SetDeployEnablementParameters>;

variable DisplayDeployEnablement

const DisplayDeployEnablement: CommandHandlerRegistration<SetDeployEnablementParameters>;

variable EnableDeploy

const EnableDeploy: CommandHandlerRegistration<SetDeployEnablementParameters>;

variable hasRepositoryGoals

const hasRepositoryGoals: PushTest;

variable IsGitHubAction

const IsGitHubAction: PushTest;

Is this SDM running as a GitHub action?

variable IsInLocalMode

const IsInLocalMode: PushTest;

Is this SDM running in local mode?

variable K8sContainerFulfiller

const K8sContainerFulfiller: any;

Goal that fulfills requested container goals by scheduling them as Kubernetes jobs.

variable ToPublicRepo

const ToPublicRepo: PushTest;

Match only pushes on a public repo
Parameter p
{Promise}

Functions

function assertUniversalGenerator

assertUniversalGenerator: (
    generatorUnderTest: GeneratorRegistration<any>,
    transformsUnderTest: UniversalTransform<any> | Array<UniversalTransform<any>>,
    initialParams: Record<string, any>,
    promptForParams?: Record<string, any>
) => Promise<AssertGeneratorResult>;

function cachePut

cachePut: (
    options: GoalCacheOptions,
    classifier?: string,
    ...classifiers: string[]
) => GoalProjectListenerRegistration;

Goal listener that performs caching after a goal has been run.
Parameter options
The options for caching
Parameter classifier
Whether only a specific classifier, as defined in the options, needs to be cached. If omitted, all classifiers are cached.
Parameter classifiers
Additional classifiers that need to be created.

function cacheRemove

cacheRemove: (
    options: GoalCacheOptions,
    classifier?: string,
    ...classifiers: string[]
) => GoalProjectListenerRegistration;

Goal listener that cleans up the cache restores after a goal has been run.
Parameter options
The options for caching
Parameter classifier
Whether only a specific classifier, as defined in the options, needs to be removed. If omitted, all classifiers are removed.
Parameter classifiers
Additional classifiers that need to be removed.

function cacheRestore

cacheRestore: (
    options: GoalCacheRestoreOptions,
    classifier?: string,
    ...classifiers: string[]
) => GoalProjectListenerRegistration;

Goal listener that performs cache restores before a goal has been run.
Parameter options
The options for caching
Parameter classifier
Whether only a specific classifier, as defined in the options, needs to be restored. If omitted, all classifiers defined in the options are restored.
Parameter classifiers
Additional classifiers that need to be restored.

function configure

configure: <
    G extends DeliveryGoals,
    T extends SdmContext = PushListenerInvocation
>(
    configurer: Configurer<G, T>,
    options?: ConfigureMachineOptions
) => Configuration;

Function to create an SDM configuration constant to be exported from an index.ts/js.

function configureSdm

configureSdm: (
    machineMaker: SoftwareDeliveryMachineMaker,
    options?: ConfigureOptions
) => ConfigurationPostProcessor<LocalSoftwareDeliveryMachineConfiguration>;

Configure and set up a Software Delivery Machine instance with the automation-client framework for standalone or single goal based execution
Parameter machineMaker
Parameter options
Returns
{ConfigurationPostProcessor}

function configureYaml

configureYaml: <G extends DeliveryGoals>(
    patterns: string | string[],
    options?: ConfigureYamlOptions<G>
) => Promise<Configuration>;

Load one or more yaml files to create goal sets
When providing more than one yaml file, files are being loaded in provided order with later files overwriting earlier ones.

function constructLogPath

constructLogPath: (context: HandlerContext, sdmGoal: SdmGoalEvent) => string[];

function container

container: <T extends ContainerRegistration>(
    displayName: string,
    registration: T
) => FulfillableGoal;

Create and return a container goal with the provided container specification.
Parameter displayName
Goal display name
Parameter registration
Goal containers, volumes, cache details, etc. SDM container goal

function createGitTag

createGitTag: (opts: CreateGitTagOptions) => Promise<void>;

Create and push a Git tag with optional message.
Parameter opts
Options for creating a Git tag.

function createSoftwareDeliveryMachine

createSoftwareDeliveryMachine: (
    config: MachineConfiguration<SoftwareDeliveryMachineConfiguration>,
    ...goalSetters: Array<GoalSetter | GoalSetter[]>
) => SoftwareDeliveryMachine<SoftwareDeliveryMachineConfiguration>;

Create a **Software Delivery MachineConfiguration** with default predefined goals. Combines commands and delivery event handling using _goals_.
Goals and goal "implementations" can be defined by users. However, certain well known goals are built into the DefaultSoftwareDeliveryMachine for convenience, with their own associated listeners.
Well known goal support is based around a delivery process spanning common goals of fingerprinting, reacting to fingerprint diffs, code review, build, deployment, endpoint verification and promotion to a production environment.
The most important element of a software delivery machine is setting zero or more _push rules_ in the constructor. This is normally done using the internal DSL as follows:
const sdm = createSoftwareDeliveryMachine( "MyMachine", options, whenPushSatisfies(IsMaven, HasSpringBootApplicationClass, not(MaterialChangeToJavaRepo)) .itMeans("No material change to Java") .setGoals(NoGoals), whenPushSatisfies(ToDefaultBranch, IsMaven, HasSpringBootApplicationClass, HasCloudFoundryManifest) .itMeans("Spring Boot service to deploy") .setGoals(HttpServiceGoals));
Uses the builder pattern to allow fluent construction. For example:
softwareDeliveryMachine .addPushReaction(async pu => ...) .addNewIssueListener(async i => ...) .add...;

function createTagForStatus

createTagForStatus: (
    id: RemoteRepoRef,
    sha: string,
    message: string,
    version: string,
    credentials: ProjectOperationCredentials
) => Promise<void>;

Create a GitHub tag using the GitHub API.
Parameter id
GitHub remote repository reference
Parameter sha
Commit SHA to tag
Parameter message
Tag message
Parameter version
Name of tag
Parameter credentials
GitHub token object
Deprecated
use createGitTag

function executeTag

executeTag: (opts?: ExecuteTagOptions) => ExecuteGoal;

Create and return an execute goal object that creates a Git tag, suitable for use with the [[Tag]] goal.
Parameter opts
Options that determine the tag created Success if successful, Failure otherwise

function executeVersioner

executeVersioner: (projectVersioner: ProjectVersioner) => ExecuteGoal;

Version the project with a build specific version number
Parameter projectLoader
used to load projects
Parameter projectVersioner
decides on the version string

function exposeInfo

exposeInfo: () => ExtensionPack;

Deprecated
use infoSupport

function fetchBranchTips

fetchBranchTips: (
    ctx: HandlerContext,
    repositoryId: { repo: string; owner: string; providerId: string }
) => Promise<RepoBranchTips.Repo>;

function FilePreferenceStoreFactory

FilePreferenceStoreFactory: PreferenceStoreFactory;

Factory to create a new FilePreferenceStore instance

function getGoalVersion

getGoalVersion: (args: GetGoalVersionArguments) => Promise<string | undefined>;

Read and return prerelease version for the goal set associated with the provided commit.
Parameter args
Properties determining which version to retrieve Prerelease semantic version string

function gitHubGoalStatus

gitHubGoalStatus: () => ExtensionPack;

Deprecated
use githubGoalStatusSupport

function githubGoalStatusSupport

githubGoalStatusSupport: () => ExtensionPack;

Manage a GitHub status per SDM

function goalInvocationVersion

goalInvocationVersion: (gi: GoalInvocation) => Promise<string | undefined>;

Get prerelease, i.e., timestamped, version associated with the goal set for the provided goal invocation. The Version goal must be executed within the goal set prior to calling this function.
Parameter gi
Goal invocation Prerelease semantic version string

function goalScheduling

goalScheduling: () => ExtensionPack;

Deprecated
use k8sGoalSchedulingSupport

function goalState

goalState: () => ExtensionPack;

Deprecated
use goalStateSupport

function goalStateSupport

goalStateSupport: (options?: GoalStateOptions) => ExtensionPack;

Allow goal setting

function GraphQLPreferenceStoreFactory

GraphQLPreferenceStoreFactory: PreferenceStoreFactory;

Factory to create a new GraphQLPreferenceStore instance
Deprecated
use TeamConfigurationPreferenceStoreFactory

function infoSupport

infoSupport: () => ExtensionPack;

Expose information about this machine

function invokeCommand

invokeCommand: <T extends ParameterType>(
    command: string | CommandRegistration<T>,
    parameters: T,
    ctx: HandlerContext
) => Promise<HandlerResult>;

Invoke any registered command programmatically in this SDM instance
Parameter command
name of the CommandRegistration or actual CommandRegistration instance to run
Parameter parameters
parameters to be passed to the command
Parameter ctx
HandlerContext instance

function isConfiguredInEnv

isConfiguredInEnv: (...values: string[]) => boolean;

Checks if one of the provided values is configured in ATOMIST_GOAL_SCHEDULER or - for backwards compatibility reasons - ATOMIST_GOAL_LAUNCHER.
Parameter values

function isGitHubAction

isGitHubAction: () => boolean;

Is this SDM running as a GitHub action? Invoked on client startup.

function isInLocalMode

isInLocalMode: () => boolean;

Is this SDM in local mode? Invoked on client startup.

function jobSupport

jobSupport: () => ExtensionPack;

Extension pack installing job execution support into the SDM
This extension pack is installed by default.

function k8sGoalSchedulingSupport

k8sGoalSchedulingSupport: () => ExtensionPack;

Extension pack to schedule goals as k8s jobs when marked as isolated = true.

function notificationSupport

notificationSupport: (options?: NotificationOptions) => ExtensionPack;

Extension pack to send notifications on certain conditions. Recipients and notification messages can be customized by providing options with DestinationFactory and NotificationFactory.
Parameter options

function postBuildWebhook

postBuildWebhook: (
    owner: string,
    repo: string,
    branch: string,
    commit: string,
    status: AtomistBuildStatus,
    teamId: string,
    retryOptions?: RetryOptions
) => Promise<boolean>;

Post to the Atomist generic build webhook URL. It creates the payload then uses postWebhook.
Parameter owner
repository owner, i.e., user or organization
Parameter repo
name of repository
Parameter branch
commit branch
Parameter commit
commit SHA
Parameter status
"start", "success", or "fail"
Parameter teamId
Atomist team ID
Parameter retryOptions
change default retry options true if successful, false on failure after retries

function postLinkImageWebhook

postLinkImageWebhook: (
    owner: string,
    repo: string,
    commit: string,
    image: string,
    teamId: string,
    retryOptions?: RetryOptions
) => Promise<boolean>;

Post to the Atomist link-image webhook URL. It creates the payload then uses postWebhook.
Parameter owner
repository owner, i.e., user or organization
Parameter repo
name of repository
Parameter commit
commit SHA
Parameter image
Docker image tag, e.g., registry.com/owner/repo:version
Parameter teamId
Atomist team ID
Parameter retryOptions
change default retry options true if successful, false on failure after retries

function postWebhook

postWebhook: (
    webhook: AtomistWebhookType,
    payload: any,
    teamId: string,
    retryOptions?: RetryOptions
) => Promise<boolean>;

Post payload to the Atomist webhook URL. It will retry several times.
Parameter webhook
type of webhook
Parameter payload
object to post
Parameter teamId
Atomist team ID
Parameter retryOptions
change default retry options true if successful, false on failure after retries

function readSdmVersion

readSdmVersion: (
    owner: string,
    repo: string,
    providerId: string,
    sha: string,
    branch: string,
    context: HandlerContext
) => Promise<string | undefined>;

See getGoalVersion.

function renderCommitMessage

renderCommitMessage: (repo: RepoInfo, commitNode: CommitForRendering) => string;

function repositoryDrivenContainer

repositoryDrivenContainer: (options?: {
    tests?: Record<string, PushTest>;
}) => Goal;

function sanitizeName

sanitizeName: (name: string) => string;

Strip out any characters that aren't allowed a k8s label value
Parameter name

function setDeployEnablement

setDeployEnablement: (
    cli: CommandListenerInvocation<SetDeployEnablementParameters>,
    enable: boolean
) => Promise<HandlerResult | HandlerError>;

Command to set deploy enablement on the currently mapped repo
Parameter cli
Parameter enable
Returns
{Promise<HandlerResult | HandlerError>}

function tagRepo

tagRepo: (tagger: Tagger) => PushListener;

Tag the repo using the given tagger
Parameter tagger

function TeamConfigurationPreferenceStoreFactory

TeamConfigurationPreferenceStoreFactory: PreferenceStoreFactory;

Factory to create a new TeamConfigurationPreferenceStore instance

function tipOfBranch

tipOfBranch: (repo: RepoBranchTips.Repo, branchName: string) => string;

function toArray

toArray: <T>(value: T | T[]) => T[];

function truncateCommitMessage

truncateCommitMessage: (message: string, repo: any) => string;

Safely truncate the first line of a commit message to 50 characters or less. Only count printable characters, i.e., not link URLs or markup.

function universalGenerator

universalGenerator: <P extends SeedDrivenGeneratorParameters = any>(
    sdm: SoftwareDeliveryMachine,
    generator: GeneratorRegistration<any>,
    transforms: Array<UniversalTransform<any>>
) => GeneratorRegistration<P>;

Wrap provided generator to execute additional transformsAndParameters

function universalGeneratorSupport

universalGeneratorSupport: (
    options: UniversalGeneratorSupportOptions
) => ExtensionPack;

Configure generators in the form GeneratorRegistrations to run additional CodeTransforms
The CodeTransforms are getting registered with an optional test which can be used to interrogate the seed project and determine if the CodeTransform should be executed against the seed. CodeTransforms can also register parameter definitions to ask for more parameters via a promptFor question flow.

Classes

class AbstractPreferenceStore

abstract class AbstractPreferenceStore implements PreferenceStore {}

Abstract PreferenceStore implementation to handle ttl and key scoping

constructor

protected constructor(ctx: HandlerContext);

method delete

delete: (
    key: string,
    options?: { scope?: PreferenceScope | string }
) => Promise<void>;

method doDelete

protected abstract doDelete: (key: string, namespace: string) => Promise<void>;

method doGet

protected abstract doGet: (
    key: string,
    namespace: string
) => Promise<Preference | undefined>;

method doList

protected abstract doList: (namespace: string) => Promise<Preference[]>;

method doPut

protected abstract doPut: (pref: Preference) => Promise<void>;

method get

get: <V>(
    key: string,
    options?: { scope?: PreferenceScope | string; defaultValue?: V }
) => Promise<V | undefined>;

method list

list: <V>(
    scope: PreferenceScope | string
) => Promise<Array<{ key: string; value: V }>>;

method put

put: <V>(
    key: string,
    value: V,
    options?: { scope?: PreferenceScope | string; ttl?: number }
) => Promise<V>;

method scope

protected scope: (scope: PreferenceScope | string) => string;

method scopeKey

protected scopeKey: (key: string, scope?: string) => string;

class CompressingGoalCache

class CompressingGoalCache implements GoalCache {}

Cache implementation that caches files produced by goals to an archive that can then be stored, using tar and gzip to create the archives per goal invocation (and classifier if present).

constructor

public constructor(store?: GoalCacheArchiveStore);

method put

put: (
    gi: GoalInvocation,
    project: GitProject,
    files: string[],
    classifier?: string
) => Promise<void>;

method remove

remove: (gi: GoalInvocation, classifier?: string) => Promise<void>;

method retrieve

retrieve: (
    gi: GoalInvocation,
    project: GitProject,
    classifier?: string
) => Promise<void>;

class ConfigurationBasedBasicCredentialsResolver

@Parameters()
export class ConfigurationBasedBasicCredentialsResolver
    implements CredentialsResolver {}

Resolves to single credentials from the configuration

constructor

constructor(paths?: { username: string; password: string });

method commandHandlerCredentials

commandHandlerCredentials: (
    context: HandlerContext,
    id: RemoteRepoRef
) => ProjectOperationCredentials;

method eventHandlerCredentials

eventHandlerCredentials: (
    context: HandlerContext
) => ProjectOperationCredentials;

class Container

class Container extends FulfillableGoalWithRegistrations<ContainerRegistration> {}

Goal run as a container, as seen on TV.

constructor

constructor(details?: ContainerGoalDetails, ...dependsOn: Goal[]);

property details

readonly details: ContainerGoalDetails;

method addFulfillment

addFulfillment: (fulfillment: Fulfillment) => this;

method addFulfillmentCallback

addFulfillmentCallback: (cb: GoalFulfillmentCallback) => this;

method register

register: (sdm: SoftwareDeliveryMachine) => void;

method with

with: (registration: ContainerRegistration) => this;

class DefaultRepoRefResolver

class DefaultRepoRefResolver implements RepoRefResolver {}

method providerIdFromPush

providerIdFromPush: (push: OnPushToAnyBranch.Push) => string;

method repoRefFromPush

repoRefFromPush: (push: OnPushToAnyBranch.Push) => RemoteRepoRef;

Obtain a RemoteRepoRef from the given push, correctly resolving provider.
Parameter push
{any}

method repoRefFromSdmGoal

repoRefFromSdmGoal: (sdmGoal: SdmGoalEvent) => RemoteRepoRef;

method toBitBucketServerRepoRef

toBitBucketServerRepoRef: (params: {
    providerUrl: string;
    owner: string;
    name: string;
    sha: string;
    branch?: string;
}) => BitBucketServerRepoRef;

method toRemoteRepoRef

toRemoteRepoRef: (
    repo: CoreRepoFieldsAndChannels.Fragment,
    opts?: { sha?: string; branch?: string }
) => RemoteRepoRef;

Convert GraphQL return to our remote repo ref, instantiating the correct type based on provider
Parameter repo
Parameter opts
options - sha or branch {RemoteRepoRef}

class EphemeralLocalArtifactStore

class EphemeralLocalArtifactStore implements ArtifactStore {}

Store the artifact on local disk, relying on in memory cache. **This is purely for demo and test use. It is NOT a production quality implementation. It uses fake artifact links in GitHub statuses that may not be honored after the present automation client is shut down.
Deprecated
Artifact storage should be done using project listeners.

method checkout

checkout: (url: string) => Promise<DeployableArtifact>;

method retrieve

protected retrieve: (url: string) => Promise<StoredArtifact>;

method storeFile

storeFile: (appInfo: AppInfo, what: string) => Promise<string>;

class FileSystemGoalCacheArchiveStore

class FileSystemGoalCacheArchiveStore implements GoalCacheArchiveStore {}

Goal archive store that stores the compressed archives into the SDM cache directory.

method delete

delete: (gi: GoalInvocation, classifier: string) => Promise<void>;

method retrieve

retrieve: (
    gi: GoalInvocation,
    classifier: string,
    targetArchivePath: string
) => Promise<void>;

method store

store: (
    gi: GoalInvocation,
    classifier: string,
    archivePath: string
) => Promise<void>;

class GitHubCredentialsResolver

@Parameters()
export class GitHubCredentialsResolver implements CredentialsResolver {}

property orgToken

readonly orgToken: string;

method commandHandlerCredentials

commandHandlerCredentials: (
    context: HandlerContext,
    id?: RemoteRepoRef
) => Promise<ProjectOperationCredentials>;

method eventHandlerCredentials

eventHandlerCredentials: (
    context: HandlerContext,
    id?: RemoteRepoRef
) => Promise<ProjectOperationCredentials>;

class KubernetesGoalScheduler

class KubernetesGoalScheduler implements GoalScheduler {}

GoalScheduler implementation that schedules SDM goals inside k8s jobs.
It reuses the podSpec of the deployed SDM to create a new jobSpec from. Subclasses may change the spec and job creation behavior by overwriting beforeCreation and/or afterCreation methods.

constructor

constructor(options?: KubernetesGoalSchedulerOptions);

property podSpec

podSpec: k8s.V1Pod;

method afterCreation

protected afterCreation: (
    gi: GoalInvocation,
    jobSpec: k8s.V1Job
) => Promise<void>;

Extension point for sub classes to modify k8s resources after the job has been created. The provided jobSpec contains the result of the job creation API call.
Parameter gi
Parameter jobSpec

method beforeCreation

protected beforeCreation: (
    gi: GoalInvocation,
    jobSpec: k8s.V1Job
) => Promise<void>;

Extension point for sub classes to modify k8s resources or provided jobSpec before the Job gets created in k8s. Note: A potentially existing job with the same name has already been deleted at this point.
Parameter gi
Parameter jobSpec

method cleanUp

protected cleanUp: () => Promise<void>;

Extension point to allow for custom clean up logic.

method initialize

initialize: (configuration: Configuration) => Promise<void>;

method schedule

schedule: (gi: GoalInvocation) => Promise<ExecuteGoalResult>;

method supports

supports: (gi: GoalInvocation) => Promise<boolean>;

class KubernetesJobDeletingGoalCompletionListenerFactory

class KubernetesJobDeletingGoalCompletionListenerFactory {}

GoalCompletionListener factory that puts completed goal jobs into a ttl cache for later deletion.

constructor

constructor(sdm: SoftwareDeliveryMachine);

method create

create: () => GoalCompletionListener;

class NoOpGoalCache

class NoOpGoalCache implements GoalCache {}

Cache implementation that doesn't cache anything and will always trigger the fallback.

method put

put: (
    gi: GoalInvocation,
    project: GitProject,
    files: string[],
    classifier?: string
) => Promise<void>;

method remove

remove: (gi: GoalInvocation, classifier?: string) => Promise<void>;

method retrieve

retrieve: (
    gi: GoalInvocation,
    project: Project,
    classifier?: string
) => Promise<void>;

class RolarProgressLog

class RolarProgressLog implements ProgressLog {}

Post log to Atomist Rolar service for it to persist

constructor

constructor(
    logPath: string[],
    configuration: Configuration,
    logLevel?: string,
    timestamper?: Iterator<Date, any, undefined>
);

property name

readonly name: string;

property url

readonly url: string;

method close

close: () => Promise<any>;

method flush

flush: () => Promise<any>;

method isAvailable

isAvailable: () => Promise<boolean>;

method write

write: (msg?: string, ...args: string[]) => void;

class SetDeployEnablementParameters

@Parameters()
export class SetDeployEnablementParameters {}

property msgId

msgId?: string;

property name

name: string;

property owner

owner: string;

property providerId

providerId: string;

property repo

repo: string;

property version

version: string;

class Tag

class Tag extends FulfillableGoal {}

Goal that performs project tagging using Git. If no fulfillment is added to the goal, one is added during registration that tags using the goal set pre-release version as created by the [[Version]] goal.

constructor

constructor(goalDetailsOrUniqueName?: any, ...dependsOn: Goal[]);

method register

register: (sdm: SoftwareDeliveryMachine) => void;

Called by the SDM on initialization. This function calls super.register and adds a startup listener to the SDM.
The startup listener registers a default goal fulfillment that calles [[executeTag]] with no arguments.

method with

with: (registration?: TagRegistration) => this;

Add fulfillment to this goal.

class Version

class Version extends FulfillableGoalWithRegistrations<ProjectVersionerRegistration> {}

Goal that performs project visioning: For example using Maven to increment the project version number

constructor

constructor(goalDetailsOrUniqueName?: any, ...dependsOn: Goal[]);

method with

with: (registration: ProjectVersionerRegistration) => this;

method withVersioner

withVersioner: (versioner: ProjectVersioner) => this;

Interfaces

interface AtomistBuild

interface AtomistBuild {}

property branch

branch?: string;

property build_url

build_url?: string;

property commit

commit: string;

property compare_url

compare_url?: string;

property id

id?: string;

property name

name?: string;

property number

number?: number;

property provider

provider?: string;

property pull_request_number

pull_request_number?: number;

property repository

repository: AtomistBuildRepository;

property status

status: AtomistBuildStatus;

property tag

tag?: string;

property type

type: AtomistBuildType;

interface AtomistBuildRepository

interface AtomistBuildRepository {}

property name

name: string;

property owner_name

owner_name: string;

interface AtomistLinkImage

interface AtomistLinkImage {}

property docker

docker: AtomistLinkImageDocker;

property git

git: AtomistLinkImageGit;

property type

type: 'link-image';

interface AtomistLinkImageDocker

interface AtomistLinkImageDocker {}

property image

image: string;

interface AtomistLinkImageGit

interface AtomistLinkImageGit {}

property owner

owner: string;

property repo

repo: string;

property sha

sha: string;

interface ConfigureMachineOptions

interface ConfigureMachineOptions extends ConfigureOptions {}

property name

name?: string;

SDM name if you want to override the default which uses the package name.

property postProcessors

postProcessors?: ConfigurationPostProcessor | ConfigurationPostProcessor[];

These functions are called after the [[configureSdm]] post-processor.

property preProcessors

preProcessors?: ConfigurationPreProcessor | ConfigurationPreProcessor[];

These functions are called in the first postProcessor. Specifically, the first post-processor is [[configureSdm]] these functions are called in its [[SoftwareDeliveryMachineMaker]] function prior to it calling the [[createSoftwareDeliveryMachine]].

interface ConfigureOptions

interface ConfigureOptions extends ConfigurationValues {}

Options passed to the set up of the SDM.

interface ConfigureYamlOptions

interface ConfigureYamlOptions<G extends DeliveryGoals> {}

Configuration options for the yaml support

property configurers

configurers?: GoalConfigurer<G> | Array<GoalConfigurer<G>>;

property cwd

cwd?: string;

property goals

goals?: GoalCreator<G>;

property options

options?: ConfigureMachineOptions;

property tests

tests?: Record<string, PushTest>;

interface ContainerPort

interface ContainerPort {}

Ports to expose from container.

property containerPort

containerPort: number;

Number of port to expose from the container. This must be a valid port number, 0 < x < 65536.

interface ContainerRegistration

interface ContainerRegistration
    extends Partial<ImplementationRegistration>,
        GoalContainerSpec {}

Container goal artifacts and implementations information.

property callback

callback?: ContainerSpecCallback;

Callback function to dynamically modify the goal container spec when goal is executed.

property input

input?: Array<{ classifier: string }>;

Cache classifiers to retrieve from cache before starting goal execution. The values must correspond to output classifiers from previously executed container goals in the same goal set.

property output

output?: CacheEntry[];

File path globs to store in cache after goal execution. They values should be glob paths relative to the root of the project directory.

interface ContainerVolumeMount

interface ContainerVolumeMount {}

Volumes to mount in container.

property mountPath

mountPath: string;

Path to mount point of volume.

property name

name: string;

Name of volume from [[GoalContainer.volumes]].

interface CreateGitTagOptions

interface CreateGitTagOptions {}

[[createTag]] function arguments.

property log

log?: ProgressLog;

Optional progress log to write updates to.

property message

message?: string;

Optional message to associate with Git tag.

property project

project: GitProject;

Git repository project to operate on.

property tag

tag: string;

Name of tag to create and push.

interface DockerContainerRegistration

interface DockerContainerRegistration extends ContainerRegistration {}

Additional options for Docker CLI implementation of container goals.

property containers

containers: DockerGoalContainer[];

Containers to run for this goal. The goal result is based on the exit status of the first element of the containers array. The other containers are considered "sidecar" containers provided functionality that the main container needs to function. The working directory of the first container is set to [[ContainerProjectHome]], which contains the project upon which the goal should operate.
This extends the base containers property to be able to pass additional dockerOptions to a single container, eg. '--link=mongo:mongo'.

property dockerOptions

dockerOptions?: string[];

Additional Docker CLI command-line options. Command-line options provided here will be appended to the default set of options used when executing docker run. For example, if your main container must run in its default working directory, you can include "--workdir=" in the dockerOptions array.

interface ExecuteTagOptions

interface ExecuteTagOptions {}

Options for creating a tag. If neither name or release are truthy, a prerelease, i.e., timestamped, version tag is created. If both name and release are truthy, name takes precedence.

property build

build?: string;

Semantic version build metadata to append to tag, e.g., "sdm.BUILD_NUMBER".

property message

message?: string;

Message to add to tag. If not provided, the push after commit message title is used.

property name

name?: string;

Name of tag to create.

property release

release?: boolean;

If true, create a release semantic version tag, not a prerelease version tag.

interface GetGoalVersionArguments

interface GetGoalVersionArguments {}

Object wrapping [[getGoalVersion]] function arguments.

property branch

branch?: string;

Branch, "master" if not provided

property context

context: HandlerContext;

Context providing a graph client.

property owner

owner: string;

Repository owner, i.e., user or organization.

property providerId

providerId: string;

Git repository provider identifier.

property repo

repo: string;

Repository name.

property sha

sha: string;

Commit SHA.

interface GoalCache

interface GoalCache {}

Goal cache interface for storing and retrieving arbitrary files produced by the execution of a goal.
See Also
- FileSystemGoalCache`

method put

put: (
    gi: GoalInvocation,
    p: GitProject,
    files: string | string[],
    classifier?: string
) => Promise<void>;

Add a set of files (or directories) to the cache.
Parameter gi
The goal invocation for which the cache needs to be stored.
Parameter p
The project where the files (or directories) reside.
Parameter files
The files (or directories) to be cached.
Parameter classifier
An optional classifier to identify the set of files (or directories to be cached).

method remove

remove: (gi: GoalInvocation, classifier?: string) => Promise<void>;

Remove files from the cache.
Parameter gi
The goal invocation for which the cache needs to be removed.
Parameter classifier
Optionally the classifier of the cache for the files to be removed. If not defined, all classifiers are removed.

method retrieve

retrieve: (
    gi: GoalInvocation,
    p: GitProject,
    classifier?: string
) => Promise<void>;

Retrieve files from the cache.
Parameter gi
The goal invocation for which the cache needs to be restored.
Parameter p
he project where the files (or directories) need to be restored in.
Parameter classifier
Optionally the classifier of the cache for the files to be restored. If not defined, all caches for the GoalInvocation are restored.

interface GoalCacheArchiveStore

interface GoalCacheArchiveStore {}

method delete

delete: (gi: GoalInvocation, classifier: string) => Promise<void>;

Remove a compressed goal archive
Parameter gi
The goal invocation thar triggered the cache removal
Parameter classifier
The classifier of the cache

method retrieve

retrieve: (
    gi: GoalInvocation,
    classifier: string,
    targetArchivePath: string
) => Promise<void>;

Retrieve a compressed goal archive
Parameter gi
The goal invocation thar triggered the cache retrieval
Parameter classifier
The classifier of the cache
Parameter targetArchivePath
The destination path where the archive needs to be stored.

method store

store: (
    gi: GoalInvocation,
    classifier: string,
    archivePath: string
) => Promise<void>;

Store a compressed goal archive
Parameter gi
The goal invocation thar triggered the caching
Parameter classifier
The classifier of the cache
Parameter archivePath
The path of the archive to be stored.

interface GoalCacheOptions

interface GoalCacheOptions extends GoalCacheCoreOptions {}

Options for putting goal cache entries.

property entries

entries: CacheEntry[];

Collection of glob patterns with classifiers to determine which files need to be cached between goal invocations, possibly excluding paths using regular expressions.

interface GoalContainer

interface GoalContainer {}

Simplified container abstraction for goals.

property args

args?: string[];

Docker command and arguments. We call this args rather than command because we think k8s got it right.

property command

command?: string[];

Docker image entrypoint. We call this command rather than entrypoint because we think k8s got it right.

property env

env?: Array<{ name: string; value: string }>;

Environment variables to set in Docker container.

property image

image: string;

Full Docker image name, i.e., registry/name:tag.

property name

name: string;

Unique name for this container within this goal.

property ports

ports?: ContainerPort[];

Ports to expose from container.

property secrets

secrets?: ContainerSecrets;

Provider secrets that should be made available to the container

property volumeMounts

volumeMounts?: ContainerVolumeMount[];

Volumes to mount in container.

interface GoalContainerVolume

interface GoalContainerVolume {}

Volumes that containers in goal can mount.

property hostPath

hostPath: {
    /** Absolute path on host to volume. */
    path: string;
};

Volume to be created from local host file system location.

property name

name: string;

Unique name of volume, referenced by [[ContainerVolumeMount.name]].

interface GoalStructure

interface GoalStructure {}

Data structure to configure goal contributions

property dependsOn

dependsOn?: string | Goal | Array<string | Goal>;

Optional pre conditions for goals; can be actual goal instances or names of goal contributions

property goals

goals: Goal | Goals | Array<Goal | Goals | Array<Goal | Goals>>;

Goal instances to schedule
The following cases are supported:
goals: [ autofix, build ]
This means autofix will run after build
goals: [ [autofix, build] ]
This will schedule autofix and build concurrently
goals: [ [autofix, build], dockerBuild ]
This will schedule autofix and build concurrently and dockerBuild once autofix and build are completed

property test

test?: PushTest | PushTest[];

Optional push tests to determine when to schedule provided goals
If an array of push tests is provided, they will get wrapped with allSatisfied/and.

interface K8sContainerRegistration

interface K8sContainerRegistration extends ContainerRegistration {}

Additional options for Kubernetes implementation of container goals.

property callback

callback?: K8sContainerSpecCallback;

Replace generic callback in [[ContainerRegistration]] with Kubernetes-specific callback.

property containers

containers: K8sGoalContainer[];

Replace generic containers in [[ContainerRegistration]] with Kubernetes containers.
Containers to run for this goal. The goal result is based on the exit status of the first element of the containers array. The other containers are considered "sidecar" containers provided functionality that the main container needs to function. If not set, the working directory of the first container is set to [[ContainerProjectHome]], which contains the project upon which the goal should operate. If workingDir is set, it is not changed. If workingDir is set to the empty string, the workingDir property is deleted from the main container spec, meaning the container default working directory will be used.

property initContainers

initContainers?: k8s.V1Container[];

Init containers to run for this goal. Any containers provided here will run after the one inserted by the SDM to manage the cloned repository.

property volumes

volumes?: K8sGoalContainerVolume[];

Replace generic volumes in [[ContainerRegistration]] with Kubernetes volumes available to mount in containers.

interface K8sServiceRegistration

interface K8sServiceRegistration extends ServiceRegistration<K8sServiceSpec> {}

K8s specific service registration

property service

service: (
    goalEvent: SdmGoalEvent,
    repo: RepoContext
) => Promise<
    | {
          type: K8sServiceRegistrationType.K8sService;
          spec: K8sServiceSpec;
      }
    | undefined
>;

interface K8sServiceSpec

interface K8sServiceSpec {}

K8s specific service spec
Allows to register additional containers that are being added to the goal job. Open for future extension to support adding other k8s resource types.

property container

container?: DeepPartial<k8s.V1Container> | Array<DeepPartial<k8s.V1Container>>;

Additional containers to be added into the goal job.

property imagePullSecret

imagePullSecret?:
    | DeepPartial<k8s.V1LocalObjectReference>
    | Array<DeepPartial<k8s.V1LocalObjectReference>>;

Additional image pull secrets to be added into the goal job.

property initContainer

initContainer?:
    | DeepPartial<k8s.V1Container>
    | Array<DeepPartial<k8s.V1Container>>;

Additional init containers to be added into the goal job.

property volume

volume?: DeepPartial<k8s.V1Volume> | Array<DeepPartial<k8s.V1Volume>>;

Additional volumes to be added into the goal job.

property volumeMount

volumeMount?:
    | DeepPartial<k8s.V1VolumeMount>
    | Array<DeepPartial<k8s.V1VolumeMount>>;

Additional volumeMounts to be added into the goal job. Each will be added to all containers and initContainers.

interface LocalSoftwareDeliveryMachineConfiguration

interface LocalSoftwareDeliveryMachineConfiguration
    extends SoftwareDeliveryMachineConfiguration {}

Configuration that takes SoftwareDeliveryMachineOptions inside the sdm key.

property local

local: LocalSoftwareDeliveryMachineOptions & AnyOptions;

interface LocalSoftwareDeliveryMachineOptions

interface LocalSoftwareDeliveryMachineOptions {}

Configuration determining how to run in local mode

property hostname

hostname?: string;

Name of host to use for creating local url

property mergeAutofixes

mergeAutofixes?: boolean;

Whether to merge autofixes automatically

property mergePullRequests

mergePullRequests?: boolean;

Whether to merge pull request branches automatically. For instance, if you run a BuildAwareTransform (like Upgrade Spring Boot in the spring seed SDM), it'll make a branch and then run the build on it; when the build passes, the SDM will commit the change into your default branch in your working directory.

property preferLocalSeeds

preferLocalSeeds?: boolean;

Use local seeds (in whatever git state) vs cloning if possible? Default will be true

property repositoryOwnerParentDirectory

repositoryOwnerParentDirectory?: string;

Base of expanded directory tree the local client will work with: The projects the SDM can operate on. Defaulting rule handled in sdm-local. Under this we find //

interface Preference

interface Preference {}

property name

name: string;

property namespace

namespace: string;

property ttl

ttl: number;

property value

value: string;

interface ProjectVersionerRegistration

interface ProjectVersionerRegistration extends Partial<ImplementationRegistration> {}

property versioner

versioner: ProjectVersioner;

interface UniversalGeneratorSupportOptions

interface UniversalGeneratorSupportOptions {}

Configuration options for the universalGeneratorSupport extension pack

property generators

generators: GeneratorRegistration<any> | Array<GeneratorRegistration<any>>;

Generators to enrich with additional CodeTransforms

property transformsAndParameters

transformsAndParameters?:
    | UniversalTransform<any>
    | Array<UniversalTransform<any>>;

Additional CodeTransforms, their parameters and optional project test

interface UniversalTransform

interface UniversalTransform<PARAMS = any> {}

Registration for CodeTransform, ParametersObject and an additional test

property parameters

parameters?: ParametersObject<PARAMS>;

Additional parameters the CodeTransforms need

property test

test?: (p: Project) => Promise<boolean>;

Return true if provided CodeTransforms should be executed against Project p

property transforms

transforms: CodeTransform<PARAMS> | Array<CodeTransform<PARAMS>>;

CodeTransforms to execute

Type Aliases

type AllGoals

type AllGoals = DeliveryGoals;

Deprecated
use DeliveryGoals

type AtomistBuildStatus

type AtomistBuildStatus = 'started' | 'failed' | 'error' | 'passed' | 'canceled';

type AtomistBuildType

type AtomistBuildType = 'cron' | 'pull_request' | 'push' | 'tag' | 'manual';

type AtomistWebhookType

type AtomistWebhookType = 'application' | 'build' | 'link-image';

type CommandMaker

type CommandMaker<PARAMS = NoParameters> = (
    sdm: SoftwareDeliveryMachine
) => Promise<CommandListener> | CommandListener;

type ConfigurationMaker

type ConfigurationMaker = (
    cfg: Configuration
) =>
    | Promise<
          SoftwareDeliveryMachineConfiguration<YamlSoftwareDeliveryMachineConfiguration>
      >
    | SoftwareDeliveryMachineConfiguration<YamlSoftwareDeliveryMachineConfiguration>;

type ConfigurationPreProcessor

type ConfigurationPreProcessor = (
    cfg: LocalSoftwareDeliveryMachineConfiguration
) => Promise<LocalSoftwareDeliveryMachineConfiguration>;

Process the configuration before creating the SDM instance

type Configurer

type Configurer<
    G extends DeliveryGoals,
    F extends SdmContext = PushListenerInvocation
> = (
    sdm: SoftwareDeliveryMachine & { createGoals: CreateGoals<G> }
) => Promise<void | GoalData | Array<GoalContribution<F>>>;

Configure a SoftwareDeliveryMachine instance by adding command, events etc and optionally returning GoalData, an array of GoalContributions or void when no goals should be added to this SDM.

type ContainerScheduler

type ContainerScheduler = (
    goal: Container,
    registration: ContainerRegistration
) => void;

Container goal scheduler implementation. The goal execution is handled as part of the execution of the container.

type ContainerSpecCallback

type ContainerSpecCallback = (
    r: ContainerRegistration,
    p: GitProject,
    g: Container,
    e: SdmGoalEvent,
    c: RepoContext
) => Promise<GoalContainerSpec>;

Function signature for callback that can modify and return the [[ContainerRegistration]] object.

type CreateGoals

type CreateGoals<G extends DeliveryGoals> = (
    creator: GoalCreator<G>,
    configurers?: GoalConfigurer<G> | Array<GoalConfigurer<G>>
) => Promise<G>;

Type to orchestrate the creation and configuration of goal instances for this SDM

type DeliveryGoals

type DeliveryGoals = Record<string, Goal | GoalWithFulfillment>;

Type to collect goal instances for this SDM

type EventMaker

type EventMaker<PARAMS = NoParameters> = (
    sdm: SoftwareDeliveryMachine
) => Promise<EventHandler<PARAMS>> | EventHandler<PARAMS>;

type GoalConfigurer

type GoalConfigurer<G extends DeliveryGoals> = (
    sdm: SoftwareDeliveryMachine,
    goals: G
) => Promise<void>;

Type to configure provided goals with fulfillments, listeners etc

type GoalCreator

type GoalCreator<G extends DeliveryGoals> = (
    sdm: SoftwareDeliveryMachine
) => Promise<G>;

Type to create goal instances for this SDM

type GoalData

type GoalData = Record<string, GoalStructure>;

Type to collect named GoalStructure instances
The record key will be used to name the goal contribution.

type GoalMaker

type GoalMaker<G extends Record<string, any> = {}> = (
    sdm: SoftwareDeliveryMachine,
    params: G
) => Promise<Goal> | Goal;

type K8sContainerSpecCallback

type K8sContainerSpecCallback = (
    r: K8sContainerRegistration,
    p: GitProject,
    g: Container,
    e: SdmGoalEvent,
    ctx: RepoContext
) => Promise<Omit<K8sContainerRegistration, 'callback'>>;

Function signature for callback that can modify and return the [[ContainerRegistration]] object.

type K8sGoalContainerSpec

type K8sGoalContainerSpec = Omit<K8sContainerRegistration, 'callback'>;

Deprecated
use K8sContainerSpecCallback

type ProjectIdentifier

type ProjectIdentifier = (p: Project) => Promise<ProjectIdentification | undefined>;

Return identification of this project or undefined if it can't be identified

type ProjectVersioner

type ProjectVersioner = (
    status: SdmGoalEvent,
    p: GitProject,
    log: ProgressLog
) => Promise<string>;

type PushTestMaker

type PushTestMaker<G extends Record<string, any> = any> = (
    params: G
) =>
    | ((pli: StatefulPushListenerInvocation) => Promise<boolean>)
    | Promise<PushTest>
    | PushTest;

type SoftwareDeliveryMachineMaker

type SoftwareDeliveryMachineMaker = (
    configuration: LocalSoftwareDeliveryMachineConfiguration
) => SoftwareDeliveryMachine | Promise<SoftwareDeliveryMachine>;

Type that can create a fully configured SDM

Namespaces

namespace CoreRepoFieldsAndChannels

namespace CoreRepoFieldsAndChannels {}

type Channels

type Channels = NonNullable<
    NonNullable<CoreRepoFieldsAndChannelsFragment['channels']>[0]
>;

type Fragment

type Fragment = CoreRepoFieldsAndChannelsFragment;

type Org

type Org = NonNullable<CoreRepoFieldsAndChannelsFragment['org']>;

type Provider

type Provider = NonNullable<
    NonNullable<CoreRepoFieldsAndChannelsFragment['org']>['provider']
>;

type Team

type Team = NonNullable<
    NonNullable<
        NonNullable<CoreRepoFieldsAndChannelsFragment['channels']>[0]
    >['team']
>;

namespace github

module 'src/lib/util/github/ghub.ts' {}

GitHub status

function authHeaders

authHeaders: (token: string) => AxiosRequestConfig;

function createRelease

createRelease: (
    creds: string | ProjectOperationCredentials,
    rr: GitHubRepoRef,
    release: Release
) => AxiosPromise;

function createStatus

createStatus: (
    creds: string | ProjectOperationCredentials,
    rr: GitHubRepoRef,
    inputStatus: Status
) => AxiosPromise;

Create a GitHub status
Parameter creds
Parameter rr
Parameter inputStatus
{AxiosPromise}

function createTag

createTag: (
    creds: string | ProjectOperationCredentials,
    rr: GitHubRepoRef,
    tag: Tag
) => AxiosPromise;

function createTagReference

createTagReference: (
    creds: string | ProjectOperationCredentials,
    rr: GitHubRepoRef,
    tag: Tag
) => AxiosPromise;

function deleteRepository

deleteRepository: (
    creds: string | ProjectOperationCredentials,
    rr: GitHubRepoRef
) => AxiosPromise;

function isPublicRepo

isPublicRepo: (
    creds: string | ProjectOperationCredentials,
    rr: GitHubRepoRef
) => Promise<boolean>;

function listCommitsBetween

listCommitsBetween: (
    creds: string | ProjectOperationCredentials,
    rr: GitHubRepoRef,
    startSha: string,
    endSha: string
) => Promise<GitHubCommitsBetween>;

List commits between these shas
Parameter creds
Parameter rr
Parameter startSha
Parameter endSha
{Promise}

function listTopics

listTopics: (
    creds: string | ProjectOperationCredentials,
    rr: RemoteRepoRef
) => Promise<string[]>;

function tipOfDefaultBranch

tipOfDefaultBranch: (
    creds: string | ProjectOperationCredentials,
    rr: GitHubRepoRef
) => Promise<string>;

function updateIssue

updateIssue: (
    creds: string | ProjectOperationCredentials,
    rr: RemoteRepoRef,
    issueNumber: number,
    issue: Issue
) => AxiosPromise;

interface GitHubCommitsBetween

interface GitHubCommitsBetween {}

property commits

commits: Array<{
    sha: string;
    author: { login: string };
    commit: { message: string };
}>;

interface Release

interface Release {}

property body

body?: string;

property draft

draft?: boolean;

property name

name?: string;

property prerelease

prerelease?: boolean;

property tag_name

tag_name: string;

property target_commitish

target_commitish?: string;

interface Status

interface Status {}

GitHub status

property context

context?: string;

property description

description?: string;

property state

state: State;

property target_url

target_url?: string;

interface Tag

interface Tag {}

property message

message: string;

property object

object: string;

Commit sha

property tag

tag: string;

property tagger

tagger: {
    name: string;
    email: string;
    date: string;
};

property type

type: string;

type State

type State = 'error' | 'failure' | 'pending' | 'success';

namespace OnChannelLink

namespace OnChannelLink {}

type Channel

type Channel = NonNullable<
    NonNullable<NonNullable<OnChannelLinkSubscription['ChannelLink']>[0]>['channel']
>;

type ChannelLink

type ChannelLink = NonNullable<
    NonNullable<OnChannelLinkSubscription['ChannelLink']>[0]
>;

type Repo

type Repo = CoreRepoFieldsAndChannelsFragment;

type Subscription

type Subscription = OnChannelLinkSubscription;

type Team

type Team = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<OnChannelLinkSubscription['ChannelLink']>[0]
        >['channel']
    >['team']
>;

type Variables

type Variables = OnChannelLinkSubscriptionVariables;

namespace OnRepoOnboarded

namespace OnRepoOnboarded {}

type Repo

type Repo = CoreRepoFieldsAndChannelsFragment;

type RepoOnboarded

type RepoOnboarded = NonNullable<
    NonNullable<OnRepoOnboardedSubscription['RepoOnboarded']>[0]
>;

type Subscription

type Subscription = OnRepoOnboardedSubscription;

type Variables

type Variables = OnRepoOnboardedSubscriptionVariables;

namespace PersonByChatId

namespace PersonByChatId {}

type ChatId

type ChatId = NonNullable<NonNullable<PersonByChatIdQuery['ChatId']>[0]>;

type Person

type Person = PersonFieldsFragment;

type Query

type Query = PersonByChatIdQuery;

type Variables

type Variables = PersonByChatIdQueryVariables;

namespace SdmVersionForCommit

namespace SdmVersionForCommit {}

type Query

type Query = SdmVersionForCommitQuery;

type Repo

type Repo = NonNullable<
    NonNullable<NonNullable<SdmVersionForCommitQuery['SdmVersion']>[0]>['repo']
>;

type SdmVersion

type SdmVersion = NonNullable<
    NonNullable<SdmVersionForCommitQuery['SdmVersion']>[0]
>;

type Variables

type Variables = SdmVersionForCommitQueryVariables;

Package Files (56)

Peer Dependencies (5)

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@atomist/sdm-core.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@atomist/sdm-core)

HTML

<a href="https://www.jsdocs.io/package/@atomist/sdm-core"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 year ago.
Package analyzed in 12630 ms.
Missing or incorrect documentation? Open an issue for this package.

@atomist/sdm-core

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable ContainerProjectHome

variable DisableDeploy

variable DisplayDeployEnablement

variable EnableDeploy

variable hasRepositoryGoals

variable IsGitHubAction

variable IsInLocalMode

variable K8sContainerFulfiller

variable ToPublicRepo

Parameter p

Functions

function assertUniversalGenerator

function cachePut

Parameter options

Parameter classifier

Parameter classifiers

function cacheRemove

Parameter options

Parameter classifier

Parameter classifiers

function cacheRestore

Parameter options

Parameter classifier

Parameter classifiers

function configure

function configureSdm

Parameter machineMaker

Parameter options

Returns

function configureYaml

function constructLogPath

function container

Parameter displayName

Parameter registration

function createGitTag

Parameter opts

function createSoftwareDeliveryMachine

function createTagForStatus

Parameter id

Parameter sha

Parameter message

Parameter version

Parameter credentials

Deprecated

function executeTag

Parameter opts

function executeVersioner

Parameter projectLoader

Parameter projectVersioner

function exposeInfo

Deprecated

function fetchBranchTips

function FilePreferenceStoreFactory

function getGoalVersion

Parameter args

function gitHubGoalStatus

Deprecated

function githubGoalStatusSupport

function goalInvocationVersion

Parameter gi

function goalScheduling

Deprecated

function goalState

Deprecated

function goalStateSupport

function GraphQLPreferenceStoreFactory

Deprecated

function infoSupport

function invokeCommand