GoCD
A continuous delivery server written in Java. It models pipelines, stages, jobs and materials, runs builds on agents, and manages approvals, environments and artifacts. Maintained by the GoCD project.
Business rules, traced to source lines.
These 12 rules are a sample of the 29,582 CoreStory V3 extracted from GoCD. Each one links to the exact lines on GitHub at commit d5088f6. The statement is CoreStory V3’s wording; the code excerpt is the source it cites.
A user must have operate permission for the given stage in the given pipeline in order to schedule/trigger the pipeline; if the user lacks that permission, the check fails as forbidden with the message "Failed to trigger pipeline [<pipelineName>]" and detail "User <username> does not have permission to schedule <pipelineName>/<stageName>" scoped to the pipeline, otherwise the check succeeds with that same scope.
- Failed to trigger pipeline [%s] — forbidden message format applied when permission is absent, with the pipeline name substituted
- User — prefix of the forbidden detail message
- does not have permission to schedule — middle segment of the forbidden detail message
- / — separator between pipeline name and stage name in the forbidden detail message
Also cited: L38
A scheduling check fails (reports an error) when any stage for the given pipeline identifier is active; otherwise it succeeds. The error message is `Failed to trigger pipeline [%s]` and the description is `Pipeline[name='%s', counter='%s', label='%s'] is still in progress`, both populated from the pipeline identifier's name, counter, and label.
- Failed to trigger pipeline [%s] — error message format when any stage is active
- Pipeline[name='%s', counter='%s', label='%s'] is still in progress — error description format when any stage is active
Also cited: L34
If the pipeline lock service reports that a stage cannot be scheduled in the given pipeline, the operation result must be marked not acceptable with the message "Pipeline %s is locked." (substituting the pipeline name) and general global health state scope.
- Pipeline %s is locked. — rejection message format used when scheduling is disallowed
When the stage scheduling check returns ScheduleStageResult.PreviousStageNotPassed, the operation result is reported not acceptable with an error message of the form "Cannot schedule %s as the previous stage %s has %s!", using the requested stage name, the previous stage name, and the previous stage result, with a forbidden health state type, and the check returns immediately without reporting success.
- PreviousStageNotPassed — scheduling check outcome that triggers rejection
- Cannot schedule %s as the previous stage %s has %s! — error message format for rejected scheduling
Also cited: L43
An elastic agent profile cannot be deleted if any job in any pipeline config references it by elastic profile id; when at least one such job exists, the operation result is marked unprocessable entity with a cannot-delete-because-of-dependent-pipelines message and a GoConfigInvalidException is thrown listing the referencing pipeline/job identifiers, formatted as "The %s '%s' is being referenced by pipeline(s): %s." with the entity name lowercased, the elastic profile id, and the comma-and-space-joined identifiers.
- The %s '%s' is being referenced by pipeline(s): %s. — exception message format string
- , — separator used when joining dependent pipeline identifiers
Validation fails and deletion is rejected if the preprocessed config's list of pipelines associated with the template name is non-empty; the operation result is marked unprocessable entity with a cannot-delete-resource-because-of-dependent-pipelines message naming the template and its dependent pipelines, and a GoConfigInvalidException is thrown stating the template is being referenced by pipeline(s).
- template — resource type passed to cannotDeleteResourceBecauseOfDependentPipelines
Also cited: L53
Old artifacts are purged iteratively until the available space exceeds the configured required space in bytes, where the required space is the purge-upto disk space in gigabytes converted to bytes; the loop stops early if available space exceeds the required space, and continues while available space is less than the required space and stages remain.
Also cited: L67
A material filter must not contain both ignores and includes; if it is ignored (ignore is non-null and its size is greater than 0) and included (includes is non-null and its size is greater than 0), an error "Material filter cannot contain both ignores and includes" is added at the filter's location.
- Material filter cannot contain both ignores and includes — error message added when both ignores and includes are present
Resources on elastic agents cannot be updated: if any resources are being added or removed (i.e., not both resourcesToAdd and resourcesToRemove are empty), the elastic agents among the requested UUIDs are collected and, if any exist, a BadRequestException is thrown naming those elastic agent UUIDs. If neither resourcesToAdd nor resourcesToRemove is updated, the check is skipped.
Also cited: L101–L103
The configured artifacts directory must not be the current working directory or the sandbox root; if it equals "." (case-sensitive) or its absolute path equals the absolute path of an empty File, validation throws a RuntimeException with the message "artifactsdir should not point to the root of sand box [<absolute path>]".
- . — literal artifacts directory value forbidden as sandbox root
- artifactsdir should not point to the root of sand box [ — error message prefix when artifacts directory is sandbox root
- ] — error message closing bracket
Also cited: L30
A pipeline group rename is rejected when the existing pipeline group contains at least one remote pipeline; the operation result is set to unprocessable entity with the message "Can not rename pipeline group '%s' as it contains remote pipelines." and the command cannot continue unless the result remains successful.
- Can not rename pipeline group '%s' as it contains remote pipelines. — error message format used when rename is blocked
When a pipeline has more than one SCM or pluggable SCM material, each such material must have a non-blank destination folder; if the folder is blank, the error "Destination directory is required when a pipeline has multiple SCM materials." is added to the material's folder field (ScmMaterialConfig.FOLDER for SCM materials, PluggableSCMMaterialConfig.FOLDER for pluggable SCM materials).
- 1 — threshold compared using > 1 to trigger the rule
- Destination directory is required when a pipeline has multiple SCM materials. — error message added when folder is blank
Also cited: L180–L182
What the application does
20 capabilities identified, grouping 164 of the 6,910 distinct features extracted. Most extracted features are not grouped under a capability, so this list is a partial view of the application. These are descriptions, not the cited rules above.
Pipeline Configuration and Definition
Authoring, defining, validating, and persisting CI/CD pipelines composed of stages, jobs, tasks, materials, and parameters.
- Config Migration: Migrates elastic agent plugin configuration between versions.
- Config Validation: Preprocesses and validates a configuration document before it is saved, applying post-validation updates.
- Configuration File Persistence: Read, update, and write the Go server configuration XML file, including full-config save and reload.
- Configuration Migration: Capability to migrate existing plugin configuration to the current format.
- Configuration Validation: Validate admin configuration content and expose any resulting errors.
- Cruise Config Validation: Validate the cruise configuration and aggregate all validation errors across child parts, including cyclic dependency checks.
- Cruise Configuration: Defines a complete Cruise server configuration including pipelines, environments, agents, repositories, and security settings.
- Cruise Configuration Schema: Defines and validates the full Cruise server configuration document covering pipelines, environments, agents, artifacts, and materials.
- Pipeline Config CRUD: Create, read, update, and delete pipeline configurations through the admin API.
- Pipeline Config Creation: Create a new pipeline configuration, optionally pausing it via request headers.
- Pipeline Config Deletion: Delete a pipeline configuration when it is not defined remotely.
- Pipeline Config Management: Users can create, read, update, and delete pipeline configurations by name.
- Pipeline Config Update: Update an existing pipeline configuration with etag-based concurrency control.
- Pipeline Config Validation: Validate pipeline and template configuration, including external artifacts and elastic profile references, before saving.
- Pipeline Configuration: Define pipelines composed of stages, jobs, tasks, materials, environments, and parameters within a cruise-config XML document.
- Pipeline Configuration Management: Define and manage pipelines with their stages, jobs, tasks, materials, and templates as the core GoCD modeling capability.
- Pipeline Configuration Update: Allows a user to update an existing pipeline's configuration, including changing its group name, with permission checks.
- Pipeline Configuration Validation: Validate cruise configurations, including after preprocessing and against clones generated for validation.
- Pipeline Configuration and Scheduling: A pipeline's configuration is used to populate stages and drive scheduling checks.
- Pipeline Definition: Allows users to define pipelines with their stages, materials, tasks, and parameters as the core unit of continuous integration behaviour.
- Pipeline Definition and Configuration: Define and configure CI/CD pipelines including their stages, jobs, and tasks.
Pipeline Execution and Scheduling
Triggering, scheduling, executing, and controlling pipeline runs and their stages.
- Automatic Pipeline Scheduling: Pipelines are automatically scheduled when their materials change, subject to pause state, ignored changes, and server health.
- Build Triggering: Capability to define and represent different causes that can trigger a build, such as external requests, forced builds, or detected modifications, with associated messages and priorities.
- Job Cancellation: Allows cancelling a running job, including deciding whether the job should be cancelled and killing its running tasks.
- Job and Stage Cancellation: Cancel a running stage or job, recording who cancelled it and preventing cancellation of already-completed builds.
- Manual Pipeline Trigger: Users can manually trigger a pipeline, with the system checking for material modifications and scheduling a build.
- Manual Pipeline Triggering: Allows users to manually trigger a pipeline run, subject to permission and state checks.
- Pipeline Execution: Runs pipelines and tasks with exec commands and stores results as console logs and artifacts.
- Pipeline Job Cancellation: Cancels all jobs belonging to a pipeline, preventing further execution.
- Pipeline Run: Execute a configured pipeline composed of stages, jobs, and tasks against fetched materials.
- Pipeline Scheduling: Allows a user to schedule a pipeline, including querying available schedule options and triggers.
- Pipeline Scheduling and Approval: Controls when and whether pipeline stages run via timers, manual approval gates, cancellation, and conditional execution.
- Pipeline Scheduling and Triggers: Definition of timers and cruise scheduling that trigger pipeline runs on a cron-like schedule.
- Stage Cancellation: Cancel a running stage instance on user request.
- Stage Execution and Result Tracking: Lets a user run pipeline stages and record their pass, fail, or cancel outcomes.
- Stage Scheduling: Determines and enforces whether a pipeline stage may proceed based on the outcome of its previous stage.
- Timer and Scheduling: Defines timer-based scheduling for triggering pipeline runs.
Access Control and Authorization
Roles, users, permissions, and enforcement governing who may view, operate, or administer pipelines, stages, and server resources.
- Access Control: Comparison requests are subject to security authorization, exercised under an admin-user context.
- Access Control and Security: Manage security settings, roles, users and approval gates controlling who may operate pipelines.
- Authorization Permission Checks: System determines whether a user has view, operate, or admin permissions on pipelines, stages, templates, and groups, honoring admin and super-admin roles and security-disabled mode.
- Authorization and Permissions: Check user admin/group-administrator status and enforce read/write permission on artifacts directory.
- Authorization and Role Discovery: Resolving whether users are administrators and what roles they hold.
- Authorization and Role Management: Configure users, roles, and authorization rules including admin-only views.
- Authorization and Roles: Define users, roles, and admin-only access controls governing who may view or operate pipelines.
- Authorization and Security: Managing users, roles, permissions and security configuration.
- Authorization and Security Configuration: Configure roles, users, and authorization rules controlling access to the system.
- Config Save Authorization: The create operation permits saving the cruise configuration only when the current user is an admin, group admin, or otherwise authorized, blocking unauthorized users.
- Configuration Save Authorization: Gating whether a configuration save may proceed based on the current user's admin or group-admin status is the user-facing capability covered here.
- Permission Checking: Determine a user's admin, view, and operate permissions against the configured authorization rules.
- Pipeline Permission Control: Controls who is permitted to access or run a pipeline by assigning an access level of Everyone, NoOne, or a specific pipeline permission.
- Role-Based Access Control: Configure security with roles and default role assignments for users and admins.
- User Authorization and Roles: Defines security roles, authorization policies, and authorized user lists controlling access.
Agents and Environments
Registering and managing build agents and grouping pipelines and agents into deployment environments.
- Agent Configuration: Capability to declare build agents that the server can distribute work to.
- Agent Environment Association: Users can associate environments with agents, including config-repo-derived environments.
- Agent Management: Provides control over build agents, including registration, scheduling of work, initialization, and upgrades.
- Agent Registration: Provides the endpoint an agent uses to register itself with the service.
- Agent Work Assignment: The server assigns jobs/work to elastic agents and reads the agents' assignment responses.
- Build Agent Management: Register and manage build agents, including EC2 cloud agents and agent resources.
- Build Agent Registration: Registers build agents and their per-job metadata by UUID.
- Deployment Environment Management: Create, find, validate, and configure named deployment environments and their local/agent-backed variants.
- Elastic Agent Management: Configure elastic agent profiles and cluster profiles that supply build agents.
- Environment Agent Configuration: Represent and manage the configuration of an environment agent, including its identity and validation state.
- Environment Configuration: Set up environments with variables, agents, and associated pipelines.
- Environment Management: CRUD lifecycle for named environments, including create, retrieve, list, update, and delete operations.
- Environment Variable Configuration: Loads and exposes environment-based configuration variables for the system.
- Environment and Agent Configuration: Users define environments and associate agents with them for pipeline execution.
- Environment and Agent Management: Define environments, agent assignments, and elastic agent profiles that control where jobs run.
Job and Task Execution
Defining and running jobs and their tasks via build-tool runners such as Ant, NAnt, Rake, exec, and pluggable tasks.
- Ant Task Builder: Configure and build Ant tasks with a working directory, cancellation behavior, and optional target execution.
- Build Task Execution: Runs configured build tasks (e.g. Ant, NAnt, Rake) with conditional run-if evaluation and working directory support.
- Build Task Runners: Execute build and task steps using supported build tool runners.
- Build Tool Execution: Run builds and tests through supported build runners including Ant, NAnt, Rake and generic commands.
- Build Tool Execution and Command Execution: Run project builds and arbitrary shell commands as pipeline tasks using supported build tools.
- Command Execution: Executes external commands on the agent and reports errors when commands do not exist.
- Conditional Task Execution: Controlling whether tasks run via run-if conditions and cancellation handling.
- Conditional Task and Stage Execution: Control task execution using run-if conditions and on-cancel handlers.
- Job Configuration: Creation and assembly of job configurations, including resource and artifact plans and resource requirements.
- Job Definition and Execution: Defines jobs with tasks and execution behavior for running build work.
- Job Execution: Runs a job by setting its work and executing it within the job runner.
- Job and Task Configuration: Define and look up job configurations and their associated tasks within pipelines, including on-cancel validation context.
- Pluggable Task Execution: Runs pluggable tasks with a publisher channel and a working directory.
- Task Execution: Runs scheduled tasks and background jobs within the system.
- Task Execution Request Building: Builds request bodies and constructs execution results from task execution responses, including failure cases.
Materials and Source Control
Configuring, fetching, and tracking source-control materials and repositories across Git, Mercurial, Subversion, Perforce, and TFS.
- Git Material Configuration: Configure Git source material including URL, branch, submodule folder, and shallow clone options.
- Material (Source Control) Configuration: Configure source control materials for pipelines across multiple SCM types such as Git, SVN, Mercurial, Perforce, and TFS.
- Material / SCM Configuration: Configure source control materials such as Git, Mercurial, Perforce, SVN, and TFS repositories that feed pipelines.
- Material Configuration: Add, remove, and query pipeline materials including package, pluggable SCM, and dependency materials with fingerprint lookup.
- Material Fetching: Fetches SCM materials for a build, optionally skipping the update when configured.
- Material Revision Tracking: Maintains the revision state of a pipeline material, tracking source and target revisions and whether the material has changed.
- Mercurial Material Configuration: Define and edit a Mercurial (hg) material by specifying repository URL and branch, including resolving the branch from the URL.
- Perforce Material Configuration: Allows users to configure a Perforce SCM material with server, port, username, view, ticket authentication, and material view settings.
- Pluggable SCM Material: A material representing a pluggable SCM source that can be created, configured, and used in pipelines.
- SCM Material Configuration: Configure pipeline materials (Git, Hg, SVN, P4, TFS) with branch, shallow, ignore and destination-folder options.
- SVN Material Configuration: Enables users to configure an SVN material by specifying and displaying its URL, type, and checkout options within the configuration UI.
- Source Control Integration: Connects the system to source control management providers via extensions.
- Source Control Material Configuration: Configures source control repositories (Git, Mercurial, SVN, TFS, Perforce) as pipeline materials.
- Source Material Configuration: Connect version-control and artifact repositories (Git, SVN, Mercurial, Perforce, TFS, Maven, etc.) as pipeline materials.
- TFS Material Configuration: Configure a Team Foundation Server source-control material for a pipeline, including its project path, domain, and server URL.
Artifact Management
Publishing, fetching, storing, checksumming, and cleaning up build artifacts across pipelines and artifact stores.
- Artifact Checksum Computation: Computes checksums for files and directory contents so artifact integrity can be verified.
- Artifact Cleanup: Purge historical artifacts according to cleanup settings and purge schedules.
- Artifact Configuration: Artifact storage configuration is ensured, read, updated, and its root directory managed.
- Artifact Download: Capability to download a build artifact to a configured local folder via HTTP.
- Artifact Fetch: Retrieves artifacts, their metadata, validation, and view rendering from the service.
- Artifact Fetching: Fetching build work artifacts, either as a single file or a folder, into a destination as part of a job.
- Artifact Management: Defining, fetching, and storing build artifacts including pluggable artifact configurations and artifact stores.
- Artifact Publishing: Publishes built artifacts to remote destinations, including artifact transfer to an HTTP destination with retry handling.
- Artifact Store Management: Configuring and retrieving artifact stores used for storing build outputs.
- Artifact Upload: Uploads artifacts produced by a job to the Go artifact repository, including their checksums and destination paths.
- Artifact Upload (POST/PUT): Posting and putting artifacts to a stage, with validation of stage counter returning errors when invalid.
- Artifact and Artifact Repository Configuration: Configures artifact definitions, artifact storage directories, and artifact-fetching behavior.
- Build Artifact Handling: Produce, fetch, and manage build artifacts within pipelines.
Authentication
Authenticating users through password files, LDAP, plugins, and web-based providers, including login/logout and session handling.
- Authentication: Enables users to authenticate, with web-based login and password credentials and a defined set of supported auth types.
- HTTP Basic Authentication: Authenticates incoming requests via HTTP Basic credentials and returns a challenge response on failure.
- LDAP Authentication: Authenticate users against an external LDAP directory using manager credentials and search base/filter settings.
- LDAP Authentication Configuration: Users configure LDAP-based authentication including server, credentials, search base, and filter settings.
- Password File Authentication: Authenticate users and admins via a password-file-based auth configuration.
- Plugin-Based Authentication: Authenticating principals through pluggable password-based or web-based authentication providers.
- Reauthentication: Re-authenticating an already-established session when authentication credentials need to be refreshed.
- User Authentication: Users authenticate against the system using username/password credentials via the authentication service and workflow.
- User Authentication and Access Control: Authenticate users and control login and authorization settings.
- User Authentication and Authorization: Configure user accounts, passwords, roles, and authorized user lists for access control.
- User Login: Authenticate users, creating and updating user information from LDAP on login.
- User Login and Logout: Allows users to log in under various roles and log out of the system.
- User Logout: Displays a logged-out state with logout graphics after a session ends.
Server and System Administration
Configuring server-wide settings, admin users, maintenance mode, backups, and system health.
- Admin and Security Configuration: Defines admin settings, security realm, password files, and license information for server operation.
- Administration Configuration: Central administration settings including approval, property, and mail host configuration.
- Backup Management: Users trigger and configure server backups and view backup progress.
- Backup and Restore: Configure backup of server configuration and data.
- Maintenance Mode: Allows the system to enter a maintenance state and report when/why it was updated, gating user access while active.
- Server Backup Management: Persists and manages server backup records, tracking their progress and last successful completion.
- Server Configuration: Persisted server settings such as site URLs, security, mail host, job timeout, artifact directory, and backup configuration are loaded, validated, and updated.
- Server Configuration Management: Reading, setting, and clearing typed server-wide configuration properties and system properties, including cached access and value conversion.
- Server Configuration and Licensing: Configure server-level settings, properties, and licensing.
- Server Health Check: Provides an endpoint that reports server health status to callers.
- Server Health State Reporting: Records and exposes the server's health state so operators can observe runtime problems.
- Server Site URL Management: Exposes and updates the server's site URL settings and derived site URLs.
- Server and VM Configuration: Configure server attributes, virtual machine management (EC2/VMware), and cloud resources.
Pipeline Approval and Gating
Manual and automatic approval gates, authorization rules, and conditional execution that control stage progression.
- Approval Gates: Define manual approval stages with authorization and on-cancel directives.
- Approval Workflow: Model manual approval gates within a pipeline via approval configuration.
- Approval and Authorization: Gate pipeline progression with stage approval and role-based authorization settings.
- Conditional Execution Rules: Users attach conditions that control whether a task or stage runs.
- Manual Approval Gates: Define manual and automatic approval gates controlling stage progression.
- Manual Stage Trigger: Users manually trigger a gated stage during a pipeline run via a gate control.
- Pipeline Approval: Gating pipeline execution on manual or automatic approval steps.
- Pipeline Approval Gates: Configure manual approval stages that gate pipeline progression.
- Pipeline Approval Workflow: Configuration of manual approvals within a stage, allowing a pipeline to pause for human authorization before proceeding.
- Stage Approval: Gate pipeline progression behind manual approvals for stages.
- Stage Success Gating by Previous Stage: Controls whether a stage is permitted to run based on the allowOnlyOnSuccess setting and the outcome of the previous stage.
Secrets and Encryption
Managing secret configurations and encrypting/decrypting sensitive values such as passwords and secure properties.
- AES Encryption and Decryption: Encrypt plaintext into AES ciphertext and decrypt it back, including detection of AES-shaped passwords and preservation of surrounding whitespace.
- Cipher Management: Provides creation, lookup, and removal of ciphers/keys used for encrypting sensitive data.
- Credential Encryption: Encrypts and decrypts sensitive configuration values so that secrets are stored in an encrypted form rather than plaintext.
- Credential Encryption on Write: Encrypting stored passwords before they are written into the configuration output.
- Secret Config Management: Create, read, update, list, and delete secret configurations through the V3 API.
- Secret Config Management API: REST endpoints for creating, reading, updating, and deleting secret config entities.
- Secret Configuration Management: Exposes an HTTP API for reading and updating internal secret configuration, with ETag-based concurrency control.
- Secret Management: Injects secrets into a command's environment and redacts them from output.
- Secret Parameter Resolution: Detect secret parameters and resolve configuration into maps with secrets resolved or secure fields masked.
- Secure Property Encryption: Encrypting secure configuration properties and managing secret configs.
- Secure Property Encryption for Config: Secure properties of pipeline configurations are encrypted when a template config command is applied.
Plugin and Extension Management
Loading, configuring, and managing plugins and their extensions, settings, profiles, and lifecycle.
- Authorization Extension Registration: Registers and advertises the authorization plugin extension capabilities, icon and supported Go versions.
- Go Plugin Lifecycle Management: Loading and unloading of a Go plugin through its lifecycle callbacks, including invocation handling and plugin identity reporting.
- Plugin Configuration: Configuring plugins with their settings, properties, and profiles.
- Plugin Configuration Management: Edit, identify, and version plugin configuration entries with associated validation errors.
- Plugin Extension Registration: Registers and manages plugin extensions by name and identifier through the plugin manager.
- Plugin Extension Registry: Defines the recognized extension identifiers that plugins can contribute or hook into, providing a registry of extension points across analytics, artifacts, authorization, config repositories, elastic agents, notifications, package material, pluggable tasks, SCM, and secrets.
- Plugin Lifecycle Management: Handles the loading and unloading of plugins and registration of their event listeners.
- Plugin Management: Configuring plugin locations, activation jars, work directories, provided paths, plugin zips, and plugin logging levels.
- Plugin Settings Configuration: Lets a user read and write plugin configuration values.
- Plugin Settings Management: Create, read, and update plugin settings exposed through the v1 pluginsettings API.
Access Token Management
Issuing, validating, listing, and revoking API access tokens for users and admins.
- Access Token Authentication: Authenticates incoming requests by validating a provided access token against a security auth configuration before allowing the request through the filter chain.
- Access Token Authentication and Validation: Authenticate a request by validating a provided access token, rejecting tokens with invalid length, salt id, or hash.
- Access Token Creation: Generates a new access token for the current user through the access token controller endpoint.
- Access Token Last-Used Time Tracking: Track and persist the last-used time of an access token when it is used for authentication.
- Access Token Last-Used Tracking: Update and persist the last-used timestamp for given access tokens.
- Access Token Listing: Admin-facing listing of access tokens with filtering by active, revoked, or all states.
- Access Token Management: Users can create, list, view, filter, and revoke personal access tokens through the API, with validation and not-found handling.
- Access Token Revocation: Allows a user to revoke an access token, including a guard that rejects revocation requests that use the token being revoked.
- Access Token Validation: Validates access tokens to confirm they are legitimate and usable.
Configuration Repositories
Managing external config repositories providing pipelines as code, including parsing, validation, and migration.
- Config Repo Command Validation: Validates config repo commands, ensuring the plugin id, id presence, and config repo are correct before execution.
- Config Repo Creation: Creates a new config repo when the user has create permission and no repo already uses the id.
- Config Repo Management: Users manage configuration repositories and their operations.
- Config Repo Parse Result Tracking: Tracking and updating parse results for config repo materials, recording success or failure keyed by material fingerprint.
- Config Repo Partial Config Parsing: Parses configuration repositories using plugins to produce partial configuration results for materials, including handling plugin failures.
- Config Repository Management: Allows users to define and configure configuration repositories, including repository reference details and their material/fingerprint identity.
- Config Repository Validation: Validates configuration repository definitions, ensuring required repository is set and material definitions are valid and unique.
- Configuration Repository Management: Users attach and configure SCM repositories (git, hg, svn, p4, tfs) as configuration sources.
- Configuration Repository Validation: Validates a configuration repository's identifiers and plugin configuration, reporting errors that a user can clear and re-check.
Notifications and Email
Configuring mail hosts, sending pipeline and system email notifications, and managing per-user notification filters.
- Backup Email Notifications: Sends email to the configured admin on backup success or failure, and skips sending when email configuration is absent.
- Email Notification: Configures email and mail host settings for sending notifications.
- Email Notification Configuration: Configure mail host settings used to send notifications from the server.
- Email Sending: Sends an email message with a configurable body, sender address, and transport settings.
- Mail Host Configuration: Capability to configure the outbound mail server host, port, TLS, and sender address.
- Notification Configuration: Configure email and webhook notifications on success/failure with mail host settings and security tickets.
- Notification Filter Management: Users can create, update, and delete notification filters through the V2 notification filter controller.
- Stage Notification Email: Sends email notifications about stage events, composing an email body and delivering it to recipients.
Dashboard and Visibility
Presenting pipeline, stage, and build status through dashboards, feeds, and history views.
- Build Status Display: Exposes the current build status, label, and time for display in a tray or status view.
- CCTray Status Feed: Provides aggregated project pipeline statuses for CCTray monitoring clients, including cached job/stage statuses and per-pipeline status appending.
- Dashboard: A user-facing dashboard capability that presents aggregated information to the user.
- Dashboard Display: Users view a landing dashboard whose content depends on their toggle/preference configuration.
- Pipeline Dashboard Display: Displays the current state of pipelines and their stage instances on the dashboard, including completed, running, and re-run pipelines.
- Pipeline History Viewing: Users can retrieve and list the execution history of pipelines via the history controller.
- Stage History Viewing: Retrieve the run history of a stage, including the instance identified by a counter.
Package and Repository Management
Defining and managing packages and package repositories used as pipeline materials.
- Package Configuration: Users define package and repository configurations used as pipeline materials.
- Package Connection Check: Checks connectivity to a package and returns a success or failure result built from the response.
- Package Definition Management: Allows users to create, configure, retrieve, and update package definitions including their repository, configuration, and identity.
- Package Management: Defines and references packages with identifiers for artifact consumption and publication.
- Package Material Configuration: Defines and manages a package-based material with its package ID, package definition, display/fingerprint metadata, and equality semantics.
- Package Repository Connection Check: Verifies connectivity to a configured package or repository endpoint on demand.
- Package Repository Management: CRUD operations over package repositories exposed through a REST API controller.
Elastic Agent Provisioning
Configuring elastic agent and cluster profiles that dynamically provision build capacity, including cloud providers.
- Cloud Agent Provisioning: Users provision build agents from cloud images with configurable AMI and instance settings.
- Cluster Profile Management: Users can create, list, retrieve, update, and delete cluster profiles through the V1 API, with duplicate-id protection and rename handling.
- Elastic Agent Management: Configure elastic agent profiles and their elastic configuration.
- Elastic Agent Profile Management: Provides metadata, views, validation, and capability negotiation for elastic agent profiles used to configure elastic agents.
- Elastic Agent Provisioning: Configure elastic agent profiles and clusters for dynamic build agent provisioning.
- Elastic Profile Management: Create, update, view, list, and delete elastic profiles through the admin API.
Pipelines-as-Code Webhooks
Receiving and authenticating webhook events from Git providers to trigger material and config updates.
- Bitbucket Webhook Event Handling: Receives and processes Bitbucket webhook events such as push, pull request, and ping notifications.
- Config Repo Webhook Endpoint: A V1 webhook controller that receives push and pull request events and triggers config repos, with ping support and validation.
- GitHub Webhook Handling: Receives and processes GitHub webhook events such as PING, PULL_REQUEST, and PUSH.
- GitLab Webhook Handling: Receives and processes incoming GitLab webhook requests, authenticating them via a token and dispatching the associated event.
- Webhook Authorization Validation: Validates incoming webhook requests by checking an authorization token against a configured secret, rejecting absent or mismatched tokens.
- Webhook Signature Verification: Authenticates incoming webhook requests by computing and verifying their signatures.
Audit and Tracking Integration
Recording audit logs and integrating pipelines with external issue-tracking tools such as Mingle.
- Audit Log: Enables recording and viewing audit logs of user operations such as contact, organisation, interest, and contact list changes.
- External Tracking Tool Integration: Link pipelines to external tracking tools such as JIRA or Bugzilla.
- Issue Tracking Integration: Users link pipelines to issue-tracking tools by configuring tracking tool URLs.
- Mingle Integration: Integrate the server with Mingle project management including card and property configuration.
- Tracking Tool Integration: Configuring integration with external tracking tools.
What was analyzed
- Java · 3,838 files · 317,601 lines
- XSD · 142 files · 118,954 lines
- TypeScript · 965 files · 86,281 lines
- Groovy · 416 files · 43,779 lines
- SCSS · 201 files · 20,476 lines
- XML · 115 files · 20,023 lines
- JavaScript · 170 files · 18,817 lines
- Gradle · 90 files · 5,378 lines
- Ruby · 99 files · 4,807 lines
- JSON · 59 files · 3,288 lines
- XSLT · 140 files · 2,777 lines
- Other (16 languages) · 169 files · 7,821 lines
Whole repository: 7,430 files. cloc 2.06 counts 650,002 lines of code in 6,404 of them (862,162 lines with comments and blanks).
Where this came from
Extracted by CoreStory V3 (build 4470 with two small engine fixes) using DeepSeek-V4.1-Flash from the public repository at commit d5088f6 on 2026-11-15. Capability descriptions are from the same run.
- Repository gocd/gocd
- Commit d5088f6d96609a1cde39518adea52c07f54ace2c
- Line counts cloc 2.06
- Rule citations Each rule shown was checked: its quote was compared with the repository source at the cited lines at this commit.
Code excerpts are from the upstream repository and remain under its Apache-2.0 license. CoreStory is not affiliated with or endorsed by the GoCD project.
Want this for your own codebase?
Talk to us about mapping the business rules in your repositories.