Nomad
A workload orchestrator written in Go. It schedules containers and other applications across clusters, with ACLs, namespaces, node pools, deployments and volumes. Maintained by HashiCorp.
Business rules, traced to source lines.
These 12 rules are a sample of the 29,519 CoreStory V3 extracted from Nomad. Each one links to the exact lines on GitHub at commit e77c361. The statement is CoreStory V3’s wording; the code excerpt is the source it cites.
The uncompressed Dispatch input payload must not exceed 16384 bytes; a request payload larger than that limit is rejected.
- 16384 bytes — maximum size of uncompressed input data payload
Also cited: L31–L35
A service check interval is required and must be at least 1 second (minCheckInterval). Zero is rejected as missing, and any value below 1 second is rejected.
- 1 seconds — minimum check interval
Also cited: L46–L49
If ACL bootstrap cannot proceed (ok is false), and the file bootstrap reset index is 0, Bootstrap fails with RPC code 400 and message "ACL bootstrap already done (reset index: %d)"; if the specified index is nonzero but not equal to resetIdx, it fails with code 400 and message "Invalid bootstrap reset index (specified %d, reset index: %d)".
- 400 — RPC error code
Also cited: L468–L473
HostVolume.Create is rejected with permission denied unless the volume namespace is allowed the host-volume-create ACL capability.
- host-volumes:create — ACL capability required to create a volume
Also cited: L205
The Periodic.Force RPC requires the caller's ACL object to allow one of the namespace capabilities DispatchJob, SubmitJob, or ForcePeriodicJob for the request namespace; otherwise it returns structs.ErrPermissionDenied.
- DispatchJob — allowed namespace capability
- SubmitJob — allowed namespace capability
- ForcePeriodicJob — allowed namespace capability
Also cited: L43–L44
For the system stack, preemption is enabled by default; it is overridden by the scheduler configuration's SysBatchSchedulerEnabled setting when constructing a sysbatch stack, or by the SystemSchedulerEnabled setting otherwise.
- true — default preemption enablement
Also cited: L319
If the job is stopped and the current deployment is non-terminal (active), a deployment status update is staged with status set to "cancelled" and status description set to the stopped-job description; no further processing occurs for this job.
- cancelled — status assigned to the cancelled deployment update
- Deployment stopped due to stopped job — status description assigned to the cancelled deployment update
When memory oversubscription is enabled for a task: if MemoryMaxMB is greater than 0, the allocated MemoryMaxMB is MemoryMaxMB plus SecretsMB using saturating addition; if MemoryMaxMB equals structs.MemoryNoLimit, the allocated MemoryMaxMB is set to structs.MemoryNoLimit; if MemoryMaxMB is 0, no max memory value is set.
- 0 — MemoryMaxMB threshold below which no max memory is set unless it equals MemoryNoLimit
- -1 — value (referenced as structs.MemoryNoLimit) indicating no memory limit and propagated to the allocation
Also cited: L388–L392
RemainingAllocs excludes allocations that are terminal, and also excludes allocations whose job type is system when the drain strategy's IgnoreSystemJobs is true.
- system — job type conditionally excluded when IgnoreSystemJobs is true
- true — required value of IgnoreSystemJobs for system jobs to be skipped
Also cited: L99
When reschedule attempts exceed 0 and a reschedule tracker with events exists, reschedule eligibility is attempted < attempts and nextDelay < policy.Interval; when not using that branch, eligibility is policy.Unlimited or (Attempts > 0 and the reschedule tracker is nil). The next reschedule time is failTime plus NextDelay.
- 0 — attempts threshold for eligibility branches
When the sum of desired counts across a spread's explicit targets is greater than 0 and less than the task group's total count, the remaining count (total count minus sumDesiredCounts) is assigned to the implicit target "*".
- * — implicit target key for remaining attribute values
Also cited: L11–L14
A score penalty of 50.0 per excess allocation is applied in task-group and network preemption scoring when maxParallel is greater than 0 and the number of already-preempted allocations is at least maxParallel, computed as ((numPreemptedAllocs+1) - maxParallel) * maxParallelPenalty.
- 50.0 — score penalty multiplier applied per excess preempted allocation
- 0 — minimum maxParallel threshold for applying penalty
What the application does
20 capabilities identified, grouping 210 of the 4,730 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.
Access Control & Authentication
Authentication of callers and enforcement of ACL policies, roles, tokens, auth methods, and binding rules across the system.
- ACL Authorization: Access control layer that decides whether a caller (client, user, or workload) is allowed to perform an operation on a given resource by matching claims against a capability set.
- ACL Binding Rule Management: Lets users view and manage access-control-list binding rules through a dedicated command.
- ACL Bootstrap: Bootstraps ACL configuration on a server using a bootstrap token, including operator-file-based token setup and non-ACL server handling.
- ACL Login: Authenticate via ACL login to obtain credentials.
- ACL Management: CRUD operations for ACL policies, roles, tokens, auth methods, and binding rules.
- ACL Policy Management: Capability to create, list, inspect and delete ACL policies.
- ACL Policy Storage: Persistence of ACL tokens, policies, roles, auth methods and binding rules.
- ACL Policy and Token Management: Upserting, deleting, bootstrapping, and querying ACL policies and tokens.
- ACL Role Management: Capability to manage ACL roles.
- ACL Token Management: Capability to bootstrap, create, update, delete, list, inspect and upload ACL tokens.
- ACL and Authorization: Enforces access control and authentication, including token resolution and permission checks.
- Access Control: Requests can be authenticated and authorized using ACL tokens.
- Auth Method Management: Create, list, retrieve, and delete authentication methods.
- Authentication and Authorization: The system authenticates operators and workloads via tokens, ACLs, JWT/Vault-backed auth methods, and identity TTLs.
- Authorization: Requests are authorized via an authorizer that evaluates ACL policies and enterprise metadata.
- Identity and Authentication: Manages user identity and authentication, including a soft-fail authentication behavior.
- JWT Authentication: Authenticate users via JWT-based auth methods and signed tokens.
- OIDC Authentication: Initiating an OIDC authorization URL and completing the OIDC auth flow to obtain an ACL token.
Allocation Lifecycle Management
Creation, placement, scheduling, updating, restarting, stopping, and garbage collection of task allocations across clients and servers.
- Allocation Counting and Tracking: Counts and tracks outstanding allocations by ID for collection decisions.
- Allocation Garbage Collection: Trigger and execute garbage collection of allocations.
- Allocation Health Tracking: Tracks and exposes the health state of allocations and their tasks based on Nomad and Consul checks.
- Allocation Lifecycle Management: Clients and operators can observe, stop, pause, restart, and query the status of allocations and their task groups.
- Allocation Lifecycle Tracking: Tracks and mutates the set of terminal and non-terminal allocations, marking lost allocations and recording progress.
- Allocation Listing: Lists allocations with sortable ordering over allocation properties.
- Allocation Listing and Stubs: Users can list and browse allocations via lightweight list stubs and prefixed queries.
- Allocation Management: Users can create, list, inspect, and stop allocations, including prefix and index-sorted listings and associated service/resource details.
- Allocation Placement: The capability to place allocations on the set of candidate nodes and observe the placement results.
- Allocation Rescheduling: The system supports rescheduling allocations and exposing reschedule information to users.
- Allocation Rescheduling on Failure: Decides whether failed allocations should be rescheduled and computes the next reschedule time and delay.
- Allocation Restart: Ability to restart allocations, locally, remotely, or under ACL restrictions.
- Allocation Snapshot: Capability to capture allocation state snapshots, including atomic and migration-token variants.
- Allocation State Persistence: Store and retrieve allocation records and their consul ACL tokens, identities, and attached volumes.
- Allocation State Persistence and Diffing: Maintains allocation state, computes differences between states, and appends state updates.
- Allocation State Persistence and Restore: The client periodically snapshots and restores its local allocation state so it can recover across restarts.
- Allocation Stop: Allows a caller to start and stop an allocation, with the stop operation reporting success or failure.
- Allocation Tracking: Persistence and indexing of allocations placed on nodes.
Job Scheduling & Lifecycle
Defining, registering, planning, evaluating, deploying, updating, versioning, and scaling jobs including batch, service, system, and periodic variants.
- Batch Job Scheduling: Users can define, dispatch, run on a periodic schedule, stop early, and replace running or dead batch jobs.
- Job Dispatch: Dispatching a parameterized job with a payload and metadata.
- Job Dispatch Submission: Constructs and submits a job dispatch command that triggers execution of jobs.
- Job Evaluation: Triggering and inspecting scheduler evaluations that drive job placement decisions.
- Job Lifecycle Management: Creating, reading, updating, deleting, and querying jobs through the job CRUD endpoints.
- Job Management: Creates and manages batch and service jobs, including scaling policies and periodic schedules.
- Job Planning: Dry-run planning of job changes to show scheduling and placement diff before committing.
- Job Planning and Evaluation: Dry-run planning, evaluation and forced evaluation of job changes before applying them.
- Job Registration: Submitting and registering jobs with the cluster, including HCL parsing and validation of the job specification.
- Job Scale Up and Down: A job's task group counts can be scaled up or down (including to zero) and the reconciler settles allocations accordingly across strategies.
- Job Scaling: Scale job task groups with status reporting and invalid action handling.
- Job Scheduling: Define and register jobs (including periodic batch jobs) with constraints, update policies, and task groupings for execution.
- Job Submission: Submit and create jobs of various types (service, batch, system, sysbatch) with validation and canonicalization.
- Job Versioning: Retrieving, tagging, and reverting to prior versions of a job specification.
- Parameterized Job Dispatch: Dispatching parameterized jobs with runtime payloads and inspecting dispatch results.
- Periodic Job Scheduling: Enables scheduling of jobs to run on a recurring periodic or cron-based basis.
- System Job Scheduling: Allows users to schedule system jobs that run on a defined cadence, grouped and resumed via restart.
- Task Group Scaling: Scale a job's task group up or down and read scale status, including system jobs.
Task Execution & Runtime
Running, signalling, pausing, streaming, and observing tasks through drivers and executors across container, exec, java, QEMU, and remote runtimes.
- Command Execution: Run an external command with arguments, output code, and captured output/errors.
- Docker Task Execution: Runs tasks in containers with configurable networking, mounts, resources, and user settings, and supports streaming exec into running containers.
- Exec Handler Command Execution: Executing configured commands through the exec handler.
- Exec Streaming: Streaming execution of commands into an exec session, with heartbeat and response exit handling over a bidirectional stream.
- Java Task Execution: The java driver launches and runs Java workloads with JVM options, classpath, JAR, working directory, and resource (PID/IPC mode) configuration.
- Job Action Execution: Runs a job action command and executes its implementation with attached standard IO streams.
- Process Lifecycle Management: Capability to run external processes and control their state through start, kill, restart, signal, and running-status checks within a defined lifecycle.
- Raw Exec Task Execution: Starts, waits on, and kills raw exec tasks within allocated cgroups and working directories.
- Streaming Exec: Ability to stream exec output including terminal allocation handling.
- Task Execution: Runs named tasks through a taskrunner, invoking a prestart hook and per-task directory hooks before executing the runner.
- Task Lifecycle Management: Starting, running, stopping, and restarting tasks on a node, including clean shutdown and exit-code handling.
- Task Restart: Restart individual tasks or all running tasks within an allocation.
- Task Signal Delivery: Send signals to running tasks within an allocation.
- Task Signaling: Send signals to running tasks to influence their behavior.
- Volume Command Execution: Run a volume command provided by the user, driving the tool's primary action.
UI & CLI Interface
User-facing web dashboard, navigation, forms, tables, charts, and the command-line interface with help, autocomplete, and formatted output.
- Breadcrumb Navigation: Displays a breadcrumb trail allowing users to see and navigate the navigation path within the application.
- CLI Autocomplete: Provides shell autocompletion suggestions for a command's arguments and flags.
- CLI Command Execution: Runs the command with the given name and operator metrics options.
- CLI Command Help: Displays usage, synopsis, and flags for a command so users can discover how to invoke it.
- CLI Command Help and Usage: Exposes command metadata such as name, synopsis, help text, and argument/flag definitions for the CLI.
- CLI Flag Autocompletion: Merges autocomplete flags for the command-line interface.
- Command Execution: Run an external command with arguments, output code, and captured output/errors.
- Dashboard Display: A web user interface that presents operational data in a dashboard view with live counts.
- Job Action Execution: Runs a job action command and executes its implementation with attached standard IO streams.
- Line Chart Display: Renders a line chart with axes, gridlines, and a standard gradient area fill inside an SVG container.
- Navigation and Subnavigation Registration: Allows users to register and unregister navigation and subnavigation contexts that drive keyboard command availability.
- Table Display: Renders a tabular data container with a header and a content section, giving users a structured table view.
- Volume Command Execution: Run a volume command provided by the user, driving the tool's primary action.
- Web Dashboard Display: Serves a user-facing web dashboard exposing service and infrastructure state.
- Web UI Serving: Serve the embedded web UI assets and index page to browsers.
Node Management & Drain
Registration, listing, health, eligibility, drain, and lifecycle management of cluster client and server nodes.
- Host Fingerprinting: Computes and assigns fingerprints to nodes to identify them.
- Node Drain: Initiates and tracks the draining of a node, polling local and server status until the drain completes.
- Node Drain Management: Users can toggle node draining and monitor drain progress, including multiplexed drain migrations.
- Node Eligibility Management: Operators change node scheduling eligibility, producing eligible/ineligible events.
- Node Fingerprinting: Generate and periodically report a stable fingerprint identifying the node.
- Node Health Monitoring: Cluster node liveness is monitored through configurable keep-alive intervals, node windows, and thresholds.
- Node Lifecycle Events: Emits and validates events covering node registration, readiness, drain, and deregistration transitions.
- Node Listing: Enumerate the nodes currently registered in the cluster for inspection by clients.
- Node Management: HTTP-facing capability to list, query, and manage cluster nodes including draining, purging, and allocation eligibility.
- Node Management and Drain: Registering, listing, draining, and updating the scheduling eligibility of client nodes.
- Node Purge: Users can purge nodes from the cluster.
- Node Registration: A client registers itself as a node with the Nomad servers, including retries, identity token handling, and initial heartbeat.
- Node Status and Health Reporting: Nodes report and update their liveness, scheduling eligibility, and health status, allowing operators to observe node state.
Container & Resource Isolation
Cgroups, namespaces, filesystems, devices, and resource limits that isolate and constrain workload execution.
- Cgroup Isolation & Resource Management: Run processes in isolated cgroups and update their resource allocations.
- Container Resource Allocation: Lets users declare CPU and memory resources and constraints for a workload.
- Device Allocation: Allocates devices from an available pool based on matching criteria.
- Executor Isolation Configuration: Applying namespaces, capabilities, cgroups, and mounts to isolate an executor's process environment.
- Filesystem Isolation: Capability to run tasks in an isolated filesystem with configurable extra mount paths and optional disabling.
- NUMA Resource Management: Provides canonicalization, copying, and merging of NUMA resource configurations so users can normalize and combine resource specifications.
- Namespace Isolation: Provides process isolation through Linux namespaces, including PID and IPC host modes and escape-container handling.
- Network Isolation: Run a workload with an isolated network environment.
- Network Isolation for Containers: Enables and configures network isolation for containers, including applying isolation settings and honoring per-container network specifications for hostname and labels.
- Resource Allocation: Specifies the compute resources a job requires, including CPU and memory.
- Resource Limits: Enforce CPU, memory, and device resource limits on containers.
- Security Configuration: Exposes configurable security settings including Alpine, local daemon, and dependency options for scan behavior.
Networking & Service Mesh
CNI network configuration, port mapping, bridge networking, and Consul Connect service mesh integration for workloads.
- Bridge Network Configuration: Configure a network bridge with subnet, gateway, IP masquerading, hairpin mode, and port mapping options for container networking.
- CNI Network Configuration: Generates CNI conflist configuration defining plugin chains, network names, IP subnets, and versioning for container network setup.
- Connect Service Mesh: Enabling Consul Connect proxies, ingress, mesh, terminating and native integration modes.
- Consul Connect Service Mesh: Capability to register and test Consul Connect ingress, sidecar, and terminating gateway integrations.
- Network Configuration: Configure container networking including DNS, MAC address, ports mapping, and IPv6 advertisement.
- Network Management: Create and destroy isolated task networks.
- Network Namespace Lifecycle Management: Create and remove network namespaces, with a per-namespace runtime directory for their state.
- Network and Endpoint Configuration: Configures network bindings, static routes, and driver/expose settings for service connectivity.
- Network and Port Configuration: Capability for specifying network attachments, CNI configuration, DNS settings, and static or dynamic port allocations for a workload.
- Port Mapping: Map container ports to host ports for external access to containerized services.
- Service Mesh Proxy Configuration: Users configure sidecar proxies, upstream services, transparent proxying, and exposure rules via the Consul and ConsulProxy structures with their associated data elements.
- Transparent Proxy Configuration: Users can configure transparent proxy behavior for Consul services, including traffic redirection, ingress and outbound port settings, and address/UDP transparency options.
Service Discovery & Registration
Registering workloads and agents as services and health checks for Consul and Nomad service discovery, including deregistration and TTL management.
- Check Status Retrieval: Retrieves the most recent check statuses for services, allowing users to observe current check results.
- Check Watcher: Watches a check and reports status updates, allowing clients to observe changes over time.
- Consul Service Discovery: Looks up services and their metadata in Consul, including namespaces and Connect-aware kinds, to drive proxy configuration.
- Consul Service Registration: Registering and managing Nomad workloads and agents as services and checks in Consul, including per-workload registration, cluster-scoped sync, and deregistration.
- Health Check Result Management: Record, retrieve, purge, and clear service and task health check results.
- Nomad Service Registration: Automatically register and deregister workloads and their health checks with the Nomad service registry as they are scheduled on a node.
- Service Deregistration: Allows workloads to remove themselves from the service discovery registry.
- Service Discovery: Discover and register services so consumers can locate available providers.
- Service Discovery Registration: Register and discover services via Consul, including dynamic and static service proxies.
- Service Discovery and Listing: Discover and list services and datacenters, including filtered service/health-check queries.
- Service Registration: Users configure services and health checks for task registration with discovery providers like Consul.
- Service Registration Management: The capability to register, update, and remove service workloads and their registrations in the local agent's service registry.
Cluster Consensus & Leadership
Raft consensus, leader election, peer management, autopilot, and high-availability coordination across servers.
- Autopilot Configuration: Read and write the cluster's Autopilot settings such as cleanup of dead servers, upgrade migration, redundancy zones, and server stabilization timing.
- Autopilot Management: Operators can enable automated cluster management through autopilot.
- Cluster Membership: Servers join, leave, and track cluster membership and the current leader across the cluster.
- Cluster Membership Management: Capability for clients to retrieve the current cluster members and known peers.
- Cluster Snapshot Backup and Restore: Save and restore cluster state snapshots with checksum reporting.
- High Availability and Failover: Servers form a quorum-based consensus cluster with autopilot-driven stabilization, redundancy zones, and leader failover.
- Leader Election: Nomad servers elect a single leader and transition leadership when the leader leaves, reelection occurs, or the server rolls.
- Raft Consensus: Maintains replicated state through the Raft log with index tracking for consistency.
- Raft Leadership: Establish, monitor, and transfer Raft leadership among servers in the cluster.
- Raft Peer Management: Inspect the Raft cluster configuration and remove or transfer leadership between Raft peers by ID or address.
- State Replication: The leader replicates cluster state such as ACL policies, ACL tokens, namespaces, and node pools to followers.
Compute & Device Fingerprinting
Detecting and reporting host CPU, memory, storage, network, and device attributes for scheduling and identification.
- CPU Fingerprinting: Capture and compare CPU characteristics such as cores, frequency, NUMA topology, and model name to identify a host's compute profile.
- Cgroup Fingerprinting: Computes a fingerprint identifying a cgroup from its state, used to detect configuration changes.
- Device Discovery: Enumerate and describe the devices available on a host, including vendor, type, name, and hardware locality.
- Device Fingerprinting: Compute a unique identifier for a device from its device information and link speed characteristics.
- Environment Fingerprinting: Produces a fingerprint of the environment, with support for skipping fingerprinting based on configuration.
- Host Fingerprinting: Computes and assigns fingerprints to nodes to identify them.
- Host Network Fingerprinting: Computes a host network fingerprint reflecting interface addresses, aliases, default device selection, and reserved/link-local port preferences.
- Memory Fingerprinting: Computes a fingerprint of current process memory usage to track and compare memory consumption.
- Node Fingerprinting: Generate and periodically report a stable fingerprint identifying the node.
- Storage Capacity Fingerprinting: Computes a fingerprint representing storage device capacity, converting byte values into megabyte-based fingerprints for identification of storage media.
- System Hardware Discovery: Scans the host to discover and enumerate hardware platform details such as CPUs, cores, sockets, PCI devices, online state, and costs.
Configuration & TLS Security
Reading, merging, and validating agent/plugin configuration, and configuring TLS certificates, ciphers, and verification for secure communication.
- Agent Configuration: Configures agent runtime settings including datacenter, node identity, data directory, and server addresses.
- Certificate Issuance: Issue signed end-entity certificates with subject attributes, SANs, and extended key usage from a signer.
- Configuration Parsing: Parses a configuration file into structured client template, Consul, and Vault settings.
- Configuration Reload: Allows users to reload configuration at runtime, detecting new config files and reloading the HTTP server.
- Configuration Validation: Validates configuration inputs, including detection of invalid characters in fields like datacenter and region.
- Configuration Value Parsing: Capability for coercing declared configuration values into typed forms such as bool, int, float, and string.
- Incoming TLS Configuration: Configure and validate TLS settings for accepting incoming connections, including CA certificates, key pairs, and cipher suites.
- Outgoing TLS Configuration: Configure and validate TLS settings for establishing outgoing connections, including CA trust, hostname verification, and client key pairs.
- Plugin Configuration: Configure external plugins through plugin configuration entries.
- Secure Cluster Communication: Cluster traffic can be encrypted and authenticated using TLS certificates and a gossip encryption key.
- TLS Configuration: Configuration of TLS/SSL settings, including certificate and key files and verification options, for securing HTTP and RPC connections.
Deployment & Rolling Updates
Managing job deployments including canary rollouts, promotion, pausing, rollback, health tracking, and auto-revert.
- Canary Deployment: Support canary-style task deployment behavior.
- Deployment Canary Promotion: A user-directed capability to promote a canary deployment, including automatic promotion based on canary health.
- Deployment Lifecycle Management: Operators can pause, fail, unblock, and auto-revert a running deployment to control its progression.
- Deployment Management: View and track deployments running on the platform.
- Deployment Monitoring: Continuously watch a deployment's progress, with terminal and non-terminal monitoring modes and a default monitor fallback.
- Deployment Promotion: Users can promote canaries or all task groups in a deployment to advance it toward completion.
- Deployment Reconciliation: The reconciler drives a deployment toward its desired state by computing placements, migrations, updates, stops, and canary actions and applying the resulting plan to the cluster.
- Deployment Rollback: Rolls back a deployment when rollback conditions are valid.
- Deployment Status Tracking: Record and read per-allocation deployment status.
- Job Update Strategy: Users configure update strategies governing how running allocations are replaced during job updates.
- Rolling Update Deployment: Performing controlled rolling updates with canary and auto-promotion settings.
Observability & Telemetry
Collecting, exposing, and exporting logs, metrics, audit events, statistics, and profiles for cluster and workload observability.
- Agent Monitoring: Query an individual agent's health, profile, CPU profile, trace, and node name through the agent API.
- Allocation Stats Tracking: Collects and exposes per-task allocation telemetry covering CPU, memory, and pause metrics for monitoring.
- Audit Logging: The system emits audit events of operations to configurable sinks with filtering.
- Client Resource Stats Reporting: The client collects and emits host, device, and allocation statistics to monitoring backends.
- Cluster Health Report / Operator Health: Query and display the health status of individual servers and the overall cluster, including leader, voter, and quorum information.
- Logging: Configures agent logging including level, file path, rotation, and JSON/syslog output.
- Metrics Emission: Emits runtime metrics for observers, typically on lifecycle events.
- Profiling and Tracing: Lets operators capture CPU profiles and traces from a running agent.
- Prometheus Metrics Endpoint: Exposes application metrics over HTTP in Prometheus format for external monitoring systems to scrape.
- Telemetry and Metrics: Operators configure telemetry sinks, metric providers, prefixes, and counter/gauge/summary definitions for monitoring.
- Telemetry and Metrics Export: Operators can export cluster and allocation telemetry to statsd, statsite, or Prometheus sinks.
Secrets & Workload Identity
Issuing and verifying workload identities and providing Vault-backed secrets and tokens to tasks and services.
- ACL Token Management: Create, list, retrieve, upsert, and delete ACL tokens, including bootstrap token generation and one-time token issuance/exchange/expiry.
- Client Identity: Provides retrieval and assertion of client identity claims, including renewal of client identity.
- Consul Workload Identity: Users assign Consul service and task identities with associated auth methods for Nomad workloads.
- Identity Signing: Signs node identities using a configured signer and secret to produce signed identity tokens.
- Identity and Token Signing: Signs identities, claims, tasks, and services for authentication purposes.
- Node Identity Management: Retrieves and renews a node's cryptographic identity, exposing a controlled API for reading the current identity and refreshing/renewing it.
- Secret Management: Carries secret data identified by name and plugin for use by mounted volumes.
- Token Management: Set and manage default and alternate authentication tokens for a workload identity.
- Vault Integration: The client sets up Vault clients for allocations and validates migration tokens used to move work between nodes.
- Vault Secret Integration: Connects to HashiCorp Vault with an address, token, and mount path to supply secrets to workloads.
- Workload Identity Issuance: Mint and sign workload identities (JWT claims) for a task, service, or allocation, with optional Vault and Consul integration.
Storage & Volumes
Provisioning, attaching, mounting, snapshotting, and reclaiming CSI, host, and dynamic storage volumes for workloads.
- Block Volume Management: Provisioning, validating, expanding, and removing storage block volumes through the controller interface.
- CSI Snapshot Management: Create, delete, list, and inspect CSI volume snapshots.
- CSI Volume Claiming and Scheduling: Claim, release, and schedule read/write access to CSI volumes across allocations and nodes.
- CSI Volume Management: Attach and query CSI volumes associated with a running allocation.
- Dynamic Host Volume Management: Create, list, and delete dynamic host volumes.
- Host Volume Claim Management: Users create, list, and delete task group host volume claims that bind a volume to a specific client host.
- Host Volume Management: Create, retrieve, delete, and register host volumes through request and list operations.
- Storage Provisioning: Provisioning and mounting storage volumes for workloads via CSI plugins and NFS-backed volumes.
- Volume Lifecycle Management: Create, list, validate, expand, attach, detach, and delete storage volumes through a CSI controller.
- Volume Mounting: Mounts and restores CSI volumes for tasks when they start running, with retry on transient failures.
- Volume and Data Mounting: Capability for requesting volume mounts, such as host volumes and CSI plugin options, for a workload.
Cluster State & Persistence
Durable state stores, snapshots, restores, upgrades, and streaming event fan-out for cluster data and changes.
- Blocking Queries and Watches: Blocking query behavior with timeouts, minimum indexes, and watch notification for state changes.
- Change Persistence Store: A database-backed store that records committed changes and supports reading and tracking transactions.
- Cluster State Persistence: Store and retrieve node, allocation, deployment, network, plugin, volume, identity, and task-runner state in the state database.
- Event Publish/Subscribe: Clients can subscribe to topics and publish events to subscribers through the event broker.
- Event Stream: Provides a streaming channel over which clients observe state changes and operational events, with support for region forwarding, filtering, and ACL/namespace validation.
- Raft Consensus: Maintains replicated state through the Raft log with index tracking for consistency.
- State Persistence Store: Durable Bolt-backed storage for cluster state that can be opened, upgraded, and closed.
- State Restoration: Restore previously reserved or shared partition state.
- State Snapshot and Restore: Capture and restore the state store snapshot for backup and recovery.
- State Store Upgrade: Upgrade the persisted state store schema using versioned metadata.
Infrastructure & Environment Provisioning
Provisioning cloud infrastructure, clusters, nodes, and test environments via Terraform, Packer, and cloud integrations.
- Client Instance Deployment: Deploys a configurable pool of client VM instances with chosen machine type, disk size, image, and preemptible setting.
- Cluster Provisioning: Provisions a cluster and applies workloads to it.
- Consul Cluster Deployment: Deploys and licenses a Consul cluster with configurable regions and infrastructure settings.
- Droplet Provisioning: Provision DigitalOcean droplets from a template and user-supplied configuration.
- HashiCorp Cloud Infrastructure Provisioning: Provisions HashiCorp Cloud Platform infrastructure including HVN networking, Vault clusters, and supporting cloud resources across regions and availability zones.
- Nomad Cluster Deployment: Deploys a Nomad cluster with configurable server and client counts, binaries, region, and licensing.
- Packer Image Build: Build machine images via Packer, identified by a pinned Packer SHA version.
- Terraform Provisioning: Declare and manage the Enos infrastructure and provider configuration through Terraform.
- Terraform Workflow: Provides users the Terraform lifecycle operations to validate, plan, apply, and destroy infrastructure.
- Test Environment Provisioning: Provisioning and tearing down isolated test clusters with Consul, Vault, and Nomad clients for integration test runs.
Namespace & Quota Management
Creating and governing namespaces, node pools, and resource quotas for multi-tenant isolation and resource limits.
- Namespace Access Control: Allows or denies access to namespaces, including wildcard namespace matching.
- Namespace Capability Control: Declare and control which capabilities and task drivers or network modes are enabled or disabled for a namespace.
- Namespace Management: View namespaces defined in the platform.
- Namespace Quota Management: Configure resource quotas applied to a namespace.
- Node Pool Management: Create, inspect, list, and delete node pools with scheduler configuration and identity TTL settings.
- Node Pool Policy Management: Define and validate node pool policies granting read, write, or delete access to node pools.
- Quota Management: View quotas configured in the platform.
- Quota Reconciliation: Reconcile and verify quota specifications, updating entities with their allocations.
- Quota Status Reporting: Reports quota status and usage to the user, including formatted quota limits, devices, node pools, and spec basics.
- Resource Quota Management: Set CPU and memory resource limits and weights for workloads.
Upgrade & Version Management
Managing product versions, rolling upgrades, binary acquisition, protocol version negotiation, and release packaging.
- Autopilot Upgrade Tracking: Track and observe the progress of server version upgrades across voters, non-voters, and read replicas toward a target version.
- Dynamic Plugin Registry Upgrade: Upgrades the dynamic plugin registry and checks whether an upgrade is needed.
- Post-Upgrade Health Verification: Verify cluster and workload health after client and server upgrades.
- Release and Distribution Packaging: Produces release binaries and packages with version, commit, and build-date metadata embedded.
- Rolling Client Upgrade: Upgrade clients one at a time across the cluster.
- Server Upgrade: Upgrades the servers and verifies cluster and workload health afterward.
- Server Version Compatibility: Checking whether servers meet a minimum required version.
- Upgrade Binary Acquisition: Fetch and stage the initial and upgrade binaries needed for the rollout.
- Version Compatibility Checking: Verify that servers meet a minimum version requirement.
- Version Information Display: Exposes the application's full version metadata, including semantic version fields, prerelease, revision, and build provenance (git commit/describe and build date), to users or callers.
What was analyzed
- Go · 2,184 files · 536,310 lines
- JavaScript · 947 files · 77,731 lines
- Handlebars · 270 files · 18,268 lines
- HCL · 450 files · 18,254 lines
- YAML · 48 files · 15,758 lines
- Markdown · 63 files · 10,139 lines
- SCSS · 98 files · 6,638 lines
- Text · 1,653 files · 5,284 lines
- JSON · 59 files · 3,513 lines
- Bourne Shell · 78 files · 2,010 lines
- Bourne Again Shell · 21 files · 852 lines
- Other (12 languages) · 38 files · 2,195 lines
Whole repository: 6,116 files. cloc 2.06 counts 696,952 lines of code in 5,909 of them (908,928 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 e77c361 on 2026-11-15. Capability descriptions are from the same run.
- Repository hashicorp/nomad
- Commit e77c361fd055c12659a194ed62eae477b6e45f40
- 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 BSL 1.1 (source-available) license. CoreStory is not affiliated with or endorsed by HashiCorp.
Want this for your own codebase?
Talk to us about mapping the business rules in your repositories.