floci-io/floci
55.7
Weak · 24 October 2026
609.9k
lines of production code
Java
primary language
5
measurements over time
What this system is
Floci is a local AWS emulator that provides a high-fidelity, drop-in replacement for the AWS cloud environment by running real backend containers or in-memory implementations for services like EC2, S3, RDS, and Lambda. It enables infrastructure development and testing by replicating AWS API behaviors while maintaining compatibility with standard SDKs, CLI tools, and infrastructure-as-code frameworks like Terraform and CDK. The system ensures reliability through rigorous integration testing against multiple tooling stacks and supports features such as multi-account isolation and partition awareness.
Features
AWS Backup emulator now supports vault configuration, job persistence, and SNS notifications
The Backup service now implements the AWS Backup management-plane API, allowing users to create standard and logically air-gapped backup vaults with encryption, retention locks, and tags. Vault access policies and notification configurations (SNS topics) can now be set and retrieved, replacing the previous behavior where these operations always failed. Backup jobs are persisted and automatically resumed after service restarts, and job completion events are published to the configured SNS topic. The service also correctly returns HTTP 400 for missing parameters and ensures scheduled jobs run in the caller's account context.
src/main/java/io/github/hectorvent/floci/services/backup · high confidence
AWS CodePipeline emulation with EventBridge and SNS notifications
The CodePipeline service now includes an event publishing system that emits AWS CodePipeline state-change events to the default EventBridge bus and sends SNS approval notifications. This ensures that external integrations relying on EventBridge rules or SNS topics for pipeline, stage, and action lifecycle events receive the expected notifications. The implementation also introduces a JSON handler for the service and a keyed lock pool to manage concurrent access to pipeline executions safely.
src/main/java/io/github/hectorvent/floci/services/codepipeline · high confidence
AWS IoT custom authorizers and domain configurations
The IoT service now supports managing custom authorizers and domain configurations. Users can create, describe, update, and delete custom authorizers (including setting a default authorizer and testing invocations) via the new IotAuthorizerController, which enforces token signing and Lambda invocation logic via IotCustomAuthorizer. Additionally, the service exposes REST-JSON endpoints for domain configurations (IotDomainConfigurationController), allowing users to manage custom domains, TLS security policies, and server certificates for IoT data and credential endpoints.
src/main/java/io/github/hectorvent/floci/services/iot · high confidence
AWS Organizations service emulation added
The emulator now supports the AWS Organizations API (target prefix AWSOrganizationsV20161128), allowing users to create and manage organizations, organizational units, and accounts, as well as handle policy types, service control policies, and account handshakes. This new capability includes the OrganizationsJsonHandler for request dispatching, the OrganizationsService for business logic and state management, and the necessary domain models to represent organizational resources.
src/main/java/io/github/hectorvent/floci/services/organizations · high confidence
Add ACM model classes for certificate management
This change introduces the data model classes required for the new ACM (AWS Certificate Manager) support, including the main Certificate entity, enums for status and type, and supporting records for domain validation and resource records. These classes provide the structural foundation for handling certificate lifecycle operations within the service.
src/main/java/io/github/hectorvent/floci/services/acm/model · high confidence
Add API Gateway v2 WebSocket data-plane support
The emulator now supports the full data-plane for API Gateway v2 WebSocket APIs. This adds a Vert.x-based handler that accepts WebSocket upgrades via both the path form (/ws/{apiId}/{stage}) and the AWS-style execute-api subdomain host, validating the API protocol and managing connection lifecycles ($connect, $message, $disconnect). It includes an in-memory connection manager, a route selection evaluator for dynamic routing based on message payloads, and a Lambda REQUEST authorizer service for $connect authentication. Integration invocations are handled for AWS\_PROXY, AWS (with VTL), HTTP\_PROXY, HTTP, and MOCK targets, with proxy event builders generating AWS-compatible JSON payloads for Lambda and HTTP backends.
src/main/java/io/github/hectorvent/floci/services/apigatewayv2/websocket · high confidence
Add AWS ACM (Certificate Manager) service emulation
The emulator now supports the AWS Certificate Manager API, allowing users to request, import, export, list, and manage X.509 certificates within the local environment. This implementation includes certificate lifecycle management (requesting, pending validation, issued, revoked), support for Subject Alternative Names (SANs), and validation via DNS or email. It also handles certificate imports from PEM data and integrates with the local Certificate Authority for issuing server and client certificates, enabling TLS/HTTPS testing for custom domains and Lambda containers.
src/main/java/io/github/hectorvent/floci/services/acm · high confidence
Add AWS CLI compatibility test suite
A new compatibility test suite for the AWS CLI has been added to the project. It uses the AWS CLI v2 to validate emulator support across services including S3, SQS, SNS, DynamoDB, IAM, STS, SES, Secrets Manager, KMS, Cognito, and SSM. The tests are executed via a Docker container using the Bats framework, with parallelization disabled within individual test files to prevent race conditions in stateful tests.
compatibility-tests/sdk-test-awscli · high confidence
Add AWS Cloud Map (Service Discovery) emulation support
This change introduces a new emulation layer for the AWS Cloud Map (Service Discovery) API, enabling users to create and manage HTTP, public DNS, and private DNS namespaces, along with services and instances. The implementation includes a new \CloudMapHandler\ to dispatch API actions, a \CloudMapService\ for business logic and storage, and a \CloudMapDnsRecordSource\ that integrates with the embedded DNS server to resolve service names registered in Cloud Map namespaces. This allows containers and other callers to discover peers via DNS based on Cloud Map registrations.
src/main/java/io/github/hectorvent/floci/services/cloudmap · high confidence
Add AWS Control Tower landing-zone and baseline lifecycle emulation
This change introduces the JAX-RS controllers and backend services for AWS Control Tower, enabling the emulation of landing-zone and baseline management operations. The new \ControlTowerController\ exposes endpoints for creating, listing, getting, updating, deleting, and resetting landing zones, as well as listing and polling baseline operations. The \ControlTowerControlController\ adds support for managing enabled controls, including enabling, listing, getting, updating, and resetting them, along with operation polling. The underlying \ControlTowerService\ and \ControlTowerControlService\ handle the business logic, persisting state to storage backends and managing operation ledgers. A \SeededLandingZoneFactory\ provides a pre-seeded active landing zone to support the LZA (Landing Zone Accelerator) Prepare stage, ensuring that \ListLandingZones\ returns a valid resource rather than an empty list, which would otherwise trigger a create-path. Model classes for \LandingZone\, \EnabledBaseline\, and \EnabledControl\ are also added to support serialization and data handling.
src/main/java/io/github/hectorvent/floci/services/controltower · high confidence
Add AWS Cost Explorer service emulation with anomaly monitoring
This change introduces the Cost Explorer (\ce:\*\) service emulation, providing cost and usage reporting alongside cost anomaly detection capabilities. The \CostExplorerService\ synthesizes costs from existing resource usage lines by applying unit prices from the \PricingRateLookup\ (fetched via the \PricingService\), supporting time-bucketed queries with HOURLY, DAILY, and MONTHLY granularities, metric selection, and filtering by dimensions and tags. It also supports grouping by dimension, tag, or cost category, and can emit synthetic monthly promotional credits when configured. Additionally, the \CostAnomalyService\ allows users to create, read, update, and delete anomaly monitors and subscriptions, with storage backed by account-specific JSON files, while the \CostExplorerJsonHandler\ routes the corresponding \AWSInsightsIndexService\ API actions to these services.
src/main/java/io/github/hectorvent/floci/services/ce · high confidence
Add AWS DataSync management plane emulation
Introduces the DataSync management plane, enabling the creation, description, updating, and deletion of DataSync agents, storage locations (including S3, NFS, EFS, Azure Blob, and various FSx types), and tasks, along with resource tagging. Agents are reported as immediately ONLINE and tasks as AVAILABLE to allow SDK and Terraform waiters to succeed on the first poll, while actual data transfer operations (StartTaskExecution, etc.) are not emulated and will fail fast with an UnknownOperationException.
src/main/java/io/github/hectorvent/floci/services/datasync · high confidence
Add AWS Fault Injection Simulator (FIS) service support
This change introduces a new service layer for the AWS Fault Injection Simulator, enabling users to manage fault injection experiments via the application's API. The implementation includes a REST controller (FisController) exposing endpoints for creating, listing, and deleting experiment templates, experiments, and target account configurations, as well as retrieving actions and target resource types. The backend service (FisService) handles the business logic, including state management, idempotency, and quota enforcement, while the FisCatalog provides a static definition of supported AWS FIS actions (such as EC2 instance reboots, EBS volume pauses, and API error injection) and their parameters. Data is persisted using a new storage layer (FisStores) backed by JSON files for templates, experiments, safety levers, and other entities.
src/main/java/io/github/hectorvent/floci/services/fis · high confidence
Add AWS Lightsail emulation
The application now includes an emulation layer for the AWS Lightsail service, allowing users to manage virtual private servers, disks, static IPs, and key pairs within the local environment. This new capability introduces \LightsailService\ and \LightsailJsonHandler\ to handle core instance lifecycle operations (create, start, stop, reboot, delete) and networking configurations (opening/closing public ports), with resources persisted to local storage.
src/main/java/io/github/hectorvent/floci/services/lightsail · high confidence
Add AWS Price List Service emulation
Introduces a new pricing service that emulates the AWS Price List Service API. The implementation includes a JSON handler to dispatch operations like DescribeServices, GetAttributeValues, and GetProducts, backed by a bundled static snapshot of pricing data. Users can now query simulated AWS pricing information using standard API actions, with support for filtering and pagination.
src/main/java/io/github/hectorvent/floci/services/pricing · high confidence
Add AWS Resource Explorer 2 service with cross-region resource discovery
This change introduces the AWS Resource Explorer 2 service, enabling cross-region resource discovery and search. The implementation includes a JAX-RS controller handling operations like ListResources, Search, and Index/View management, along with a path-rewrite filter to disambiguate Resource Explorer 2 endpoints from S3 Vectors endpoints that share similar path names. The service layer manages indexes and views using persistent storage, supports query parsing with filters and keywords, and integrates with the existing tag handling system. Users can now create and manage search indexes, define views with specific filters, and perform resource searches across multiple regions.
src/main/java/io/github/hectorvent/floci/services/resourceexplorer2 · high confidence
Add AWS Security Hub service implementation
This change introduces the core implementation for the AWS Security Hub service, including the REST controller, business logic service, and data models. It enables users to manage Security Hub configurations, such as enabling the hub, configuring auto-enable controls and standards, and managing finding aggregators. Additionally, it adds support for organization-level operations, allowing management accounts to configure organization admin accounts and organization-wide settings.
src/main/java/io/github/hectorvent/floci/services/securityhub · high confidence
Add AWS Transfer Family model classes for native-image support
New model classes (HomeDirectoryMapping, Server, SshPublicKey, User) are added to the transfer service package, each annotated with @RegisterForReflection to ensure they are available for reflection in native-image builds.
src/main/java/io/github/hectorvent/floci/services/transfer/model · high confidence
Add AWS WAFv2 management API support
This change introduces the initial implementation of the AWS WAFv2 management API, enabling users to create, read, update, and delete Web ACLs, IP Sets, Regex Pattern Sets, and Rule Groups. The handler dispatches AWS JSON 1.1 actions (such as CreateWebACL, CreateIPSet, CreateRuleGroup, and CreateRegexPatternSet) to a service layer that persists resources and enforces constraints including tag limits (max 50 tags), tag key/value character restrictions, and IP address CIDR validation. The implementation also supports resource tagging operations (TagResource, UntagResource, ListTagsForResource) and returns appropriate error codes for duplicate items or nonexistent resources.
src/main/java/io/github/hectorvent/floci/services/wafv2 · high confidence
Add AWS data regeneration tooling and CloudWatch Logs capture tests
New Python scripts in tools/aws regenerate vendored AWS metadata files from authoritative sources: partitions.json from botocore and CDK, region facts from Terraform and CDK, DynamoDB request shapes from botocore, and IAM service namespaces from the AWS Service Reference index. These tools ensure the Java-side AWS partition, region, and shape data stays synchronized with upstream AWS SDK definitions. Additionally, a new CloudWatch Logs capture script adds synthetic test cases for filter patterns, covering substring, regex, JSON, and selector syntaxes to validate log filtering behavior.
tools · high confidence
Add Amazon AppIntegrations service emulation
This change introduces a new emulation layer for the Amazon AppIntegrations service (API version 2020-07-29). It adds REST endpoints to create, read, update, and delete both Event Integrations and Data Integrations, along with listing capabilities. Event Integrations are addressed by name and require an EventBridge bus, while Data Integrations are addressed by a generated ID and support configuration for sources, schedules, and file/object settings. The implementation uses a storage backend to persist these resources per region and supports tagging operations.
src/main/java/io/github/hectorvent/floci/services/appintegrations · high confidence
Add Amazon Bedrock guardrail management API
Introduces the Bedrock control plane REST-JSON controller and service layer to manage guardrails. Users can now create, retrieve, update, list, and delete guardrails, as well as create and manage guardrail versions (DRAFT and numerical). The implementation includes support for tagging resources, resolving KMS keys for encryption, and applying various policy configurations (topics, filters, words, PII, etc.).
src/main/java/io/github/hectorvent/floci/services/bedrock · high confidence
Add Amazon Connect instance management API
Added the ConnectController and ConnectService to support creating, describing, listing, and deleting Amazon Connect instances, along with managing instance attributes and storage configurations. This introduces the REST endpoints under /instance and /instance/{instanceId} to allow users to provision instances with identity management types, aliases, and call settings, as well as associate and update storage configs for resources like chat transcripts and call recordings.
src/main/java/io/github/hectorvent/floci/services/connect · high confidence
Add Amazon DocumentDB service emulation
Users can now emulate Amazon DocumentDB resources. This change introduces the \DocDbContainerManager\ and \DocDbContainerHandle\ classes, which manage the lifecycle of DocumentDB containers (using MongoDB-compatible images) and handle container-specific details like logging and port mapping. The implementation includes graceful degradation when the Docker daemon is unavailable, allowing metadata operations to continue even if the backing container cannot start.
src/main/java/io/github/hectorvent/floci/services/docdb/container · high confidence
Add Amazon Inspector2 organization configuration and delegated admin management
The Inspector2 service now supports managing organization-level settings and delegated administrators. Users can update and describe auto-enable preferences for EC2, ECR, Lambda, Lambda Code, and Code Repository resources via the organization configuration endpoints. Additionally, the service allows enabling and disabling delegated administrator accounts for Inspector2 within an AWS Organization, and provides batch status checks for accounts to monitor the enabling state of these resources.
src/main/java/io/github/hectorvent/floci/services/inspector2 · high confidence
Add Amazon MQ broker control plane backed by RabbitMQ
The Amazon MQ service now supports creating and managing RabbitMQ brokers via a new REST API under /v1/brokers. Users can create, list, describe, delete, and reboot brokers, as well as manage broker users. The implementation emulates the AWS Amazon MQ API shape, supporting case-insensitive matching for EngineType and DeploymentMode, and requires exactly one user at creation for RabbitMQ brokers. Backing storage uses Docker containers for RabbitMQ instances, with a mock mode available for testing without actual containers.
src/main/java/io/github/hectorvent/floci/services/amazonmq · high confidence
Add Amazon MWAA model classes for environment management
This change introduces the data models required to support Amazon MWAA (Managed Workflows for Apache Airflow) emulation within the service. New classes include CreateEnvironmentRequest and UpdateEnvironmentRequest to handle environment configuration parameters such as execution roles, S3 paths for DAGs and plugins, network and logging configurations, and Airflow settings. The Environment class represents the state of an MWAA environment, including status, ARN, and runtime details, while EnvironmentStatus defines the possible lifecycle states (e.g., CREATING, AVAILABLE, DELETING). Supporting models like NetworkConfiguration, LoggingConfiguration, and ModuleLoggingConfiguration allow for detailed configuration of network subnets, security groups, and logging levels for various Airflow components.
src/main/java/io/github/hectorvent/floci/services/mwaa/model · high confidence
Add Amazon Managed Service for Prometheus (AMP) emulator support
This change introduces a new service layer for Amazon Managed Service for Prometheus (AMP), enabling users to create, list, describe, and delete AMP workspaces, as well as manage rule groups namespaces within those workspaces. The implementation includes the ApsController (JAX-RS endpoints), ApsService (business logic and storage handling), and corresponding data models (PrometheusWorkspace, RuleGroupsNamespace). Workspaces are provisioned with an ACTIVE status immediately, and rule groups namespaces support create, list, describe, put (update), and delete operations. Tagging is handled via the shared tag dispatcher.
src/main/java/io/github/hectorvent/floci/services/aps · high confidence
Add Amazon Rekognition stub service for image analysis
The application now includes a stub implementation for Amazon Rekognition, enabling synchronous image-analysis actions such as DetectLabels, DetectFaces, DetectText, CompareFaces, and DetectModerationLabels. These operations return fixed, AWS-shaped responses (e.g., a single 'Floci' label or empty detection lists) rather than performing real analysis, but they allow users to override the default behavior with configurable mock responses via the S3Object key for testing purposes.
src/main/java/io/github/hectorvent/floci/services/rekognition · high confidence
Add AppSync GraphQL authentication middleware
Introduces a new authentication layer for AppSync GraphQL requests, supporting API Key, IAM (SigV4), Cognito User Pools, OpenID Connect, and Lambda authorizers. The implementation includes validators for each auth type, a central middleware to classify and route requests, and a bounded cache for Lambda authorizer results to prevent unbounded memory growth.
src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth · high confidence
Add BCM Pricing Calculator workload estimate emulation
The BCM Pricing Calculator service now supports emulating AWS Workload Estimates. This change introduces the ability to create, retrieve, and delete workload estimates, as well as batch-create usage entries that are priced against the existing Pricing Service. The implementation includes the \BcmPricingCalculatorService\ for business logic (including idempotency via client tokens and cost recomputation), a \BcmPricingCalculatorJsonHandler\ for JSON request/response handling, and the \WorkloadEstimate\ and \WorkloadEstimateUsage\ data models.
src/main/java/io/github/hectorvent/floci/services/bcmpricingcalculator · high confidence
Add CloudFront model classes for native-image reflection
Added Java model classes for CloudFront resources (including Distribution, CacheBehavior, Origin, and related policies) annotated with @RegisterForReflection to ensure they are available for native-image reflection.
src/main/java/io/github/hectorvent/floci/services/cloudfront/model · high confidence
Add CloudWatch RUM app-monitor service
A new CloudWatch RUM service has been added, providing a JAX-RS controller and backend service to manage app monitors. This implementation supports the full lifecycle of app monitors—creating, retrieving, updating, deleting, and listing them—using the application's internal storage backend. The service exposes REST endpoints at /appmonitor and /appmonitors, handling JSON payloads for monitor configuration, domains, tags, and telemetry settings, and integrates with the resource explorer to report these monitors.
src/main/java/io/github/hectorvent/floci/services/rum · high confidence
Add CodeGuru Reviewer repository association management
The emulator now supports managing CodeGuru Reviewer repository associations via the REST-JSON API. Users can associate repositories from CodeCommit, Bitbucket, GitHub Enterprise Server, or S3 buckets, describe and list existing associations with filtering and pagination, and disassociate them. The implementation includes full lifecycle handling, tagging support via the shared tag handler, and validation for repository provider types and KMS encryption details.
src/main/java/io/github/hectorvent/floci/services/codegurureviewer · high confidence
Add Cost Explorer enumerators for EC2, Lambda, S3, and unpriced services
This change introduces new usage enumerators for the Cost Explorer service, enabling Floci to report resource usage for EC2, Lambda, and S3. The EC2 enumerator emits hourly usage lines for running instances, while the S3 enumerator calculates storage usage in GB-months scaled to the query period. The Lambda enumerator currently emits zero-quantity lines to ensure functions appear in service dimension searches, with actual invocation tracking planned for a future update. Additionally, an unpriced services enumerator provides placeholder entries for other AWS services (such as DynamoDB, RDS, and SQS) that lack pricing data, ensuring they remain discoverable in Cost Explorer queries without contributing to billed costs.
src/main/java/io/github/hectorvent/floci/services/ce/enumerator · high confidence
Add Cost and Usage Report (CUR) management and Parquet emission
The \src/main/java/io/github/hectorvent/floci/services/cur\ package now implements the AWS Cost and Usage Report management plane and its underlying emission pipeline. Users can create, modify, describe, and delete CUR report definitions via the \CurJsonHandler\ and \CurService\, which enforce AWS constraints such as the five-report-per-account limit and Parquet-only format. When a report is created or modified, the system can immediately emit a Parquet artifact (synchronous mode) or schedule it for daily emission via \CurEmissionScheduler\. The emission process collects usage lines through \EmissionEngine\, projects them into the FOCUS 1.2 column schema using \FocusRowProjector\, and writes the final Parquet file to the configured S3 destination via \ParquetEmitter\, which handles NDJSON staging and DuckDB conversion.
src/main/java/io/github/hectorvent/floci/services/cur · high confidence
Add DLM lifecycle policy management API
The application now exposes a new internal API for managing AWS Data Lifecycle Manager (DLM) policies. This change introduces a JAX-RS controller and service layer under the internal prefix \/\_dlm\ that supports creating, retrieving, updating, and deleting lifecycle policies. Users can manage policy details, states, execution roles, and various scheduling options (such as create/retain intervals and cross-region copy targets) through these new endpoints, with policies persisted in a region-scoped storage backend.
src/main/java/io/github/hectorvent/floci/services/dlm · high confidence
Add DMS replication subnet group lifecycle and tagging support
The DMS service now supports creating, describing, and deleting replication subnet groups, along with listing, adding, and removing tags on these resources. The JSON handler routes the corresponding API actions to the service, which persists subnet group details and tags in storage. When describing replication instances, the handler now expands the stored subnet group identifier into the full ReplicationSubnetGroup structure, ensuring the response reflects the current state of the group. This completes the lifecycle management for replication subnet groups within the DMS emulation layer.
src/main/java/io/github/hectorvent/floci/services/dms · high confidence
Add Detective organization member management operations
The detective service now supports managing organization members within a behavior graph. Users can designate an administrator account, configure auto-enable settings, and perform member lifecycle operations including listing members, inviting new accounts (with conflict handling for existing members), and starting monitoring for accepted members. The service enforces AWS-like validation rules, such as account ID format checks, member quota limits (1200 max), and proper state transitions for member monitoring.
src/main/java/io/github/hectorvent/floci/services/detective · high confidence
Add EMR Serverless application and job run management
This change introduces the EMR Serverless service implementation, exposing REST endpoints for creating, listing, updating, and deleting applications, as well as starting, listing, getting, and cancelling job runs. It includes a route filter to disambiguate the shared \/applications\ path between EMR Serverless and AppConfig, and a tag handler to support tagging on both applications and job runs.
src/main/java/io/github/hectorvent/floci/services/emrserverless · high confidence
Add Global Accelerator management plane implementation
This change introduces the backend service and JSON request handler for the AWS Global Accelerator management plane. It adds the \GlobalAcceleratorService\ to manage the lifecycle of accelerators, listeners, and endpoint groups (including health checks and port overrides) using local storage, and the \GlobalAcceleratorJsonHandler\ to route JSON API actions like CreateAccelerator, DescribeListener, and TagResource to that service.
src/main/java/io/github/hectorvent/floci/services/globalaccelerator · high confidence
Add GuardDuty service emulation
Introduces a new GuardDuty service implementation that emulates detector lifecycle operations (create, read, update, delete, list) and organization configuration management (delegated administrator status, auto-enablement settings). The change adds the JAX-RS controller, service layer, and data models required to support these GuardDuty API endpoints.
src/main/java/io/github/hectorvent/floci/services/guardduty · high confidence
Add IAM Identity Center SSO Portal emulation endpoints
This change introduces a new SSO Portal emulation layer within the \ssoportal\ service, providing REST endpoints to mimic AWS IAM Identity Center (SSO) portal behavior. The \SsoPortalController\ exposes endpoints for user logout, retrieving federated role credentials, and listing assigned accounts and roles. The underlying \SsoPortalService\ orchestrates this by validating OIDC access tokens, querying existing SSO Admin assignments and Organization account data, and generating temporary IAM credentials (access key, secret key, session token) scoped to the user's assigned roles. This allows clients interacting with the SSO Portal API to authenticate and assume roles as if they were using the real AWS SSO portal.
src/main/java/io/github/hectorvent/floci/services/ssoportal · high confidence
Add Identity Store service emulation with SCIM and JSON APIs
The Identity Store service emulation now supports managing users, groups, and group memberships via both a JSON handler and a SCIM v2 REST API. The new \ScimController\ exposes standard SCIM endpoints (Service Provider Config, Resource Types, Schemas, Users, Groups) for provisioning, while the \IdentityStoreService\ and \IdentityStoreJsonHandler\ provide the underlying persistence and AWS-style JSON operations. This allows applications to provision and manage IAM Identity Center identities using standard SCIM protocols or direct API calls.
src/main/java/io/github/hectorvent/floci/services/identitystore · high confidence
Add IoT Core model classes for native-image reflection
This change introduces a comprehensive set of Java model classes in the IoT service to represent AWS IoT Core resources, ensuring they are registered for native-image reflection. The new models include IotAuthorizer, IotCertificate, IotDomainConfiguration, IotIndexingConfiguration, IotJob, IotJobExecution, IotPolicy, IotRetainedMessage, IotShadow, IotThingGroup, IotThingType, IotTopicRule, and Thing. These classes provide the data structures necessary for the service to interact with and manage IoT entities in a GraalVM native environment.
src/main/java/io/github/hectorvent/floci/services/iot/model · high confidence
Add Macie 2 organization administration and member management
Introduces new REST endpoints and backend logic for managing Amazon Macie 2 organizations. Users can now enable Macie, designate an organization admin account, configure auto-enable settings, and invite or list member accounts. The implementation includes the MacieController for API routing, MacieService for state and member persistence, and supporting model classes for MacieState and MacieMember.
src/main/java/io/github/hectorvent/floci/services/macie2 · high confidence
Add Managed Service for Apache Flink (Kinesis Analytics V2) emulation
This change introduces support for emulating Managed Service for Apache Flink (Kinesis Analytics V2). It adds a new container management layer that spins up standalone Apache Flink session clusters (JobManager and optional TaskManager containers) to back Flink applications. The implementation handles application lifecycle operations including starting clusters, uploading JAR artifacts via the Flink REST API, running jobs, polling job states, and managing savepoints. It also ensures proper isolation by scoping container names and volumes by application ARN, injects AWS SDK environment variables into the sidecar containers for local service connectivity, and configures persistent savepoint volumes with correct user permissions.
src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/container · high confidence
Add MemoryDB model classes for ACLs, users, and clusters
New model classes have been added to the MemoryDB service to support authentication via Access Control Lists (ACLs) and users. This includes the Acl, User, AuthMode, Cluster, ClusterStatus, and Endpoint models, all registered for native-image reflection to ensure proper serialization and deserialization in the Quarkus runtime.
src/main/java/io/github/hectorvent/floci/services/memorydb/model · high confidence
Add Neptune Gremlin proxy support
Introduces a transparent TCP proxy for Neptune DB cluster Gremlin endpoints, allowing clients to relay WebSocket traffic without inspecting payloads. The new NeptuneGremlinProxy class handles bidirectional byte relay using platform daemon threads for I/O, while NeptuneProxyManager provides an application-scoped registry to start, stop, and manage individual cluster proxies.
src/main/java/io/github/hectorvent/floci/services/neptune/proxy · high confidence
Add Neptune graph database container management
Introduces the Neptune container service, which manages the lifecycle of backend Docker containers for Neptune DB clusters. The new NeptuneContainerManager supports both TinkerPop Gremlin and Neo4j (openCypher) backends, handling container creation, port mapping, and readiness checks. It includes graceful degradation when the Docker daemon is unavailable and implements rollback logic to clean up containers if provisioning fails.
src/main/java/io/github/hectorvent/floci/services/neptune/container · high confidence
Add NuGet (BaGetter) sidecar support for CodeArtifact
Users can now publish and retrieve NuGet packages through the CodeArtifact emulator. This change introduces a BaGetter sidecar container per repository to handle the NuGet V3 wire protocol, including a new manager for container lifecycle and a client for protocol interactions. The system supports package push, version listing, asset retrieval, and deletion, with specific handling for idempotent republishes and version normalization to match AWS CodeArtifact behavior.
src/main/java/io/github/hectorvent/floci/services/codeartifact · high confidence
Add OpenSearch service emulation with real Docker-backed domains
Floci now includes a new OpenSearch service emulator. Users can create, describe, and update OpenSearch domains via the standard AWS management API. In real mode, domains are backed by actual OpenSearch Docker containers (supporting OpenSearch 1.x, 2.x, and 3.x, as well as Elasticsearch 7.10 OSS), with data persisted via named volumes or host paths. The emulator round-trips configuration options including VPC, advanced security, encryption, and access policies, and exposes instance-type metadata (e.g., storage limits for or1, i3, and EBS-backed families) so that SDK clients and infrastructure tools see realistic constraints. If the Docker daemon is unavailable, domain metadata operations continue to work, and domains report a synthesized endpoint with Processing=false.
src/main/java/io/github/hectorvent/floci/services/opensearch · high confidence
Add OpenTofu compatibility test suite
A new \compat-opentofu\ directory has been added alongside the existing \compat-terraform\ suite to validate infrastructure-as-code compatibility with OpenTofu. This addition includes a dedicated Dockerfile (using OpenTofu 1.8), Terraform configuration files (main.tf, provider.tf, backend.hcl) mirroring the Terraform suite's resource definitions, and test execution scripts. The suite allows users to verify that their Floci deployments correctly handle state management and resource operations when using OpenTofu instead of Terraform.
compatibility-tests/compat-terraform · high confidence
Add RabbitMQ-backed Amazon MQ broker emulation
Users can now create and manage Amazon MQ brokers backed by a RabbitMQ Docker container. This new RabbitMqManager handles container lifecycle, allocates host ports for AMQP (5672) and management (15672) access, seeds admin credentials, and streams logs to the broker's region, enabling full emulation of the Amazon MQ control plane for RabbitMQ-based brokers.
src/main/java/io/github/hectorvent/floci/services/amazonmq/container · high confidence
Add Resource Groups service for EC2 Capacity Reservation Pools
This change introduces a new internal API for managing AWS Resource Groups, specifically tailored to support EC2 Capacity Reservation Pools. The implementation includes a REST controller with endpoints to create, retrieve, delete, and manage resources within groups, along with a service layer that validates requests against vendored schema constraints and enforces business rules (such as restricting group creation to service-configured pools and validating that added resources are active EC2 capacity reservations).
src/main/java/io/github/hectorvent/floci/services/resourcegroups · high confidence
Add Route 53 model classes for native-image reflection
Added new model classes (AliasTarget, ChangeInfo, HealthCheck, HealthCheckConfig, HostedZone, ResourceRecord, ResourceRecordSet, VpcAssociation) in the route53 model package, all annotated with @RegisterForReflection to ensure they are available for native-image reflection.
src/main/java/io/github/hectorvent/floci/services/route53/model · high confidence
Add Simple Workflow Service (SWF) emulation
Introduces a new emulation layer for Amazon Simple Workflow Service, enabling users to register and manage domains, workflow types, and activity types, as well as start and monitor workflow executions. The service handles the full decision and activity task lifecycle, including polling, heartbeat recording, and timeout sweeping, while supporting Lambda function invocations within workflows. It implements the SWF JSON 1.0 wire protocol via a dedicated JSON handler and ensures fault responses match AWS behavior, including proper namespaced error codes and legacy header support.
src/main/java/io/github/hectorvent/floci/services/swf · high confidence
Add Timestream for InfluxDB service implementation
This change introduces the core backend implementation for the Timestream for InfluxDB service, enabling the creation and management of InfluxDB 2.x database instances and clusters within the emulator. The new code includes the service layer (\TimestreamInfluxDbService\) which handles business logic for resources like instances, clusters, parameter groups, and backups, backed by persistent storage. It also adds a JSON handler (\TimestreamInfluxDbJsonHandler\) to map API actions to service methods, validation logic (\TimestreamInfluxDbValidation\), and a container manager (\TimestreamInfluxDbContainerManager\) that provisions and manages the underlying InfluxDB Docker containers for each resource.
src/main/java/io/github/hectorvent/floci/services/timestreaminfluxdb · high confidence
Add access analyzer lifecycle management
Introduced a new Access Analyzer service that allows users to create, list, get, and delete analyzers via REST endpoints. The implementation supports multiple analyzer types (ACCOUNT, ORGANIZATION, and their unused/internal access variants) with specific quota limits per type and region. Analyzers are stored in account-specific storage and include support for configuration objects and tags, with validation for analyzer names and tag constraints.
src/main/java/io/github/hectorvent/floci/services/accessanalyzer · high confidence
Add alternate contact management for AWS accounts
Users can now create, retrieve, and delete alternate contacts (billing, operations, and security) for their AWS accounts. This feature introduces new API endpoints (\/putAlternateContact\, \/getAlternateContact\, \/deleteAlternateContact\) and enforces strict validation on contact details (email, name, phone, title) and account permissions, ensuring only management or delegated administrator accounts in organizations with all features enabled can manage these contacts.
src/main/java/io/github/hectorvent/floci/services/account · high confidence
Add configurable startup and shutdown initialization hooks with LocalStack compatibility
Users can now define custom initialization scripts that run at specific lifecycle stages (boot, startup, ready, and shutdown) by placing executable scripts in configurable directories (defaulting to /etc/floci/init). The system supports shell (.sh), Python (.py), PowerShell (.ps1), and batch (.cmd/.bat) scripts, automatically selecting the appropriate interpreter per platform. To ensure drop-in compatibility with LocalStack, the hooks also scan /etc/localstack/init directories if no scripts are found in the primary Floci paths, and LocalStack environment variables are translated and injected into the hook execution environment by the Java runtime rather than the entrypoint script. Hook execution is governed by configurable timeouts and graceful shutdown periods, with the executor ensuring that process trees are properly terminated if a script hangs or exceeds its time limit.
src/main/java/io/github/hectorvent/floci/lifecycle/inithook · high confidence
Add control catalog lookup operations
Users can now retrieve and list AWS Control Catalog controls via the new \/get-control\ and \/list-controls\ endpoints. The \ControlCatalogController\ exposes these POST endpoints, which delegate to \ControlCatalogService\ to fetch definitions from storage, validate ARN formats, and support filtering by implementation type, identifier, and governed provider. The service also handles pagination via \maxResults\ and \nextToken\ and ensures default control definitions are seeded on first access.
src/main/java/io/github/hectorvent/floci/services/controlcatalog · high confidence
Add default Velocity runtime configuration
The application now includes a default Velocity configuration file (velocity.properties) that sets runtime behaviors such as enabling invalid reference logging, configuring foreach loop limits, and defining resource loaders. This ensures consistent template engine behavior across environments by providing explicit defaults for parsing, scope control, and resource management.
src/main/resources/org · high confidence
Add in-memory emulation for AWS Budgets service operations
This change introduces a new local emulation layer for the AWS Budgets service, allowing users to create, update, and delete budgets, notifications, and subscribers, as well as describe these resources and execute budget actions, all within the application's local storage. The implementation includes a new \BudgetsService\ for business logic and validation, a \BudgetsJsonHandler\ to route API-style requests, and supporting model classes (\BudgetRecord\, \BudgetActionRecord\, \BudgetNotification\) to persist state, effectively providing a functional mock for AWS Budgets-related workflows.
src/main/java/io/github/hectorvent/floci/services/budgets · high confidence
Add in-process CloudTrail trail lifecycle and S3 data event emission
This change introduces the core CloudTrail service implementation, enabling users to create, update, describe, and delete trails, as well as manage event selectors (both basic and advanced) and trail tags. It includes the control-plane API handlers for actions like CreateTrail, UpdateTrail, PutEventSelectors, and AddTags, and implements the data-plane logic that buffers API events in-memory and periodically flushes them as gzipped JSON log files to the configured S3 bucket, respecting AWS-style delivery paths and retry semantics.
src/main/java/io/github/hectorvent/floci/services/cloudtrail · high confidence
Add local AWS Sign-In OAuth flow for CLI credentials
The signin service now implements a local OAuth 2.0 / PKCE flow to support the AWS CLI login credentials provider. Users can authenticate via a branded local consent page at \/\_floci/signin/consent\, which issues single-use authorization codes and exchanges them for temporary AWS session credentials (access key, secret key, session token) at the \/v1/token\ endpoint. The implementation includes strict validation of PKCE challenges, redirect URIs, and client IDs, while preserving AWS-specific error modes and response shapes for token failures.
src/main/java/io/github/hectorvent/floci/services/signin · high confidence
Add local RDS Data API emulation for MySQL and PostgreSQL
This change introduces a local implementation of the AWS RDS Data API, allowing users to execute SQL statements, batch operations, and manage transactions against provisioned MySQL, MariaDB, and PostgreSQL databases without needing an actual AWS connection. The service exposes standard Data API endpoints (Execute, BatchExecute, BeginTransaction, CommitTransaction, RollbackTransaction) and handles parameter binding, result mapping, and metadata generation. It includes native-image support for the JDBC drivers and substitutes unavailable features like JMX, Kerberos, and load-balancing to ensure compatibility with the local runtime environment.
src/main/java/io/github/hectorvent/floci/services/rdsdata · high confidence
Add local inspection endpoints for Kinesis streams and records
A new \KinesisInspectionController\ exposes read-only \/\_aws/kinesis/streams\ and \/\_aws/kinesis/records\ endpoints for the Floci UI and test helpers. These endpoints allow users to view detailed stream metadata (including shards, tags, and monitoring settings) and peek at captured records by stream name and shard ID, providing visibility into emulator state without using the standard AWS JSON protocol.
src/main/java/io/github/hectorvent/floci/services/kinesis · high confidence
Add mock AWS Transcribe service support
This location introduces the core handler and service layer for a mock Amazon Transcribe API. The TranscribeJsonHandler routes JSON API actions (such as starting, listing, and deleting transcription jobs and vocabularies) to the TranscribeService. The service implements in-memory storage for transient transcription jobs and persistent storage for custom vocabularies, ensuring jobs complete immediately and vocabularies survive restarts. It also isolates data by account and region and supports paginated listing via next tokens.
src/main/java/io/github/hectorvent/floci/services/transcribe · high confidence
Add mock Amazon Translate service for local development
Introduces a mock implementation of the Amazon Translate API to support local testing and development without requiring AWS credentials or network access. The new \TranslateService\ and \TranslateJsonHandler\ classes provide stateless stubs for \TranslateText\, \TranslateDocument\, and \ListLanguages\ operations. These stubs echo input data back as the 'translated' output, enforce real API constraints (such as character limits, supported content types, and language code validation), and allow for custom mock responses via configuration. This enables developers to exercise i18n pipelines and validate request/response shapes against the AWS API specification locally.
src/main/java/io/github/hectorvent/floci/services/textract, src/main/java/io/github/hectorvent/floci/services/translate · high confidence
Add model classes for EventBridge Pipes service
This change introduces the data models required to represent AWS EventBridge Pipes resources within the application. It adds the \Pipe\ entity, which captures details such as name, ARN, source, target, role, and state information, along with two supporting enums: \DesiredState\ (RUNNING, STOPPED) and \PipeState\ (covering lifecycle states like CREATING, UPDATING, and various failure states). All classes are annotated for reflection to ensure compatibility with native-image builds.
src/main/java/io/github/hectorvent/floci/services/pipes/model · high confidence
Add network helper container with nftables support
A new Dockerfile for a network helper service has been added, based on Alpine 3.21. This container installs nftables, iproute2, socat, and curl, and runs indefinitely to serve as a utility for network operations.
src/main/resources/docker · high confidence
Add stubbed Amazon Comprehend text-analysis actions
The application now supports synchronous Amazon Comprehend API operations (DetectSentiment, DetectKeyPhrases, DetectDominantLanguage, DetectPiiEntities, and ContainsPiiEntities) via a new JSON handler and service layer. These actions return fixed, AWS-shaped mock responses by default, allowing users to test integrations without a real AWS connection. Input validation for required fields and supported language codes is enforced to match real API behavior, and users can override the default stub responses for specific text inputs using the configurable mock response system.
src/main/java/io/github/hectorvent/floci/services/comprehend · high confidence
Add support for Classic (v1) Elastic Load Balancing
This change introduces a dedicated implementation for the Classic (2012-06-01) ELB API, separating it from the ELBv2 service to prevent data model conflicts. It adds a new query handler (\ElbClassicQueryHandler\) to route Classic-specific actions, a service layer (\ElbClassicService\) to manage state and persist load balancers, and a health checker (\ElbClassicHealthChecker\) that probes registered EC2 instances using the Classic health check format. The update also includes the necessary data models (\ClassicLoadBalancer\, \ClassicListener\, \ClassicHealthCheck\, \ClassicLoadBalancerAttributes\) to support these operations.
src/main/java/io/github/hectorvent/floci/services/elb · high confidence
Added AWS AppSync model classes for native-image reflection
This change introduces a comprehensive set of Java model classes in the \src/main/java/io/github/hectorvent/floci/services/appsync/model\ package to represent AWS AppSync resources, including \GraphqlApi\, \DataSource\, \Resolver\, \ApiKey\, \DomainName\, \ChannelNamespace\, and various configuration and status types. All classes are annotated with \@RegisterForReflection\ to ensure they are available for reflection in native-image builds, enabling the application to correctly serialize and deserialize AppSync API responses and configurations.
src/main/java/io/github/hectorvent/floci/services/appsync/model · high confidence
Added Athena model classes for work groups, queries, and data catalogs
Added a new set of data model classes in the Athena service package to support work group management, query execution, and data catalog operations. This includes request and configuration models for creating and updating work groups (e.g., \CreateWorkGroupRequest\, \WorkGroupConfiguration\), models for tracking query execution status and results (\QueryExecution\, \ResultSet\), and a model for data catalogs (\DataCatalog\). These classes provide the necessary structure for serializing and deserializing Athena API interactions.
src/main/java/io/github/hectorvent/floci/services/athena/model · high confidence
Added DocumentDB cluster and instance model classes
The system now includes persistent data models for Amazon DocumentDB resources, specifically \DocDbCluster\, \DocDbInstance\, and their corresponding settings records (\DocDbClusterSettings\, \DocDbInstanceSettings\). These classes define the structure for storing and managing cluster and instance attributes such as identifiers, endpoints, encryption settings, backup retention, and tags, enabling the service to store and return detailed configuration states for DocumentDB resources.
src/main/java/io/github/hectorvent/floci/services/docdb/model · high confidence
Added ECR model classes for repository and image data
This change introduces a set of new Java model classes in the ECR service layer to represent AWS Elastic Container Registry entities. Specifically, it adds data structures for Repository (including image tag mutability, scan on push, and encryption settings), AuthorizationData (for short-lived credentials), Image and ImageDetail (for manifest and metadata), ImageIdentifier, ImageFailure, ImageMetadata, and PullThroughCacheRule. These models enable the application to serialize and deserialize ECR API responses and manage pull-through cache configurations.
src/main/java/io/github/hectorvent/floci/services/ecr/model · high confidence
Added MWAA web proxy for CLI command execution
A new HTTP proxy service has been introduced to support Amazon MWAA emulation. This proxy forwards standard web traffic to the backend Airflow container and specifically intercepts POST requests to /aws\_mwaa/cli. For these CLI requests, it validates a Bearer token, executes the command inside the Airflow container using a dedicated worker pool to avoid blocking the event loop, and returns the stdout/stderr output in the AWS-documented JSON format.
src/main/java/io/github/hectorvent/floci/services/mwaa/proxy · high confidence
Added Maven Wrapper with version 3.9.16
The project now includes a Maven Wrapper (\.mvn/wrapper/maven-wrapper.properties\) to ensure consistent builds across environments. This configuration pins the Maven distribution to version 3.9.16, downloads only the script distribution, and verifies the download integrity using a SHA-256 checksum.
.mvn · high confidence
Added Neptune model classes for cluster and instance state management
This change introduces the core data models for the Neptune service, including NeptuneCluster, NeptuneInstance, and their respective settings records (NeptuneClusterSettings, NeptuneInstanceSettings). These classes define the structure for cluster and instance properties such as endpoints, ports, security groups, and backup configurations, along with validation logic for settings like port ranges, storage types, and log types. Additionally, the NeptuneDbType enum is added to support selecting the backend graph database engine (Gremlin or Neo4j) via configuration, enabling the system to emulate Amazon Neptune's query protocols.
src/main/java/io/github/hectorvent/floci/services/neptune/model · high confidence
Added Redshift catalog and system views for BI tool compatibility
A new SQL script (\bootstrap-catalog.sql\) has been added to seed the Redshift database with a set of PostgreSQL-compatible catalog and system views (such as \pg\_table\_def\, \svv\_table\_info\, \svv\_all\_columns\, and \stl\_load\_errors\). This change enables metadata compatibility for external BI and migration tools like Flyway, Liquibase, dbt, DBeaver, and Tableau, allowing them to query standard system tables that are not natively present in Redshift.
src/main/resources/redshift · high confidence
Added awslocal wrapper script for local AWS development
A new executable script, bin/awslocal, has been added to simplify local development and testing against the Floci local AWS stack. The script automatically configures environment variables (endpoint, region, and default credentials) and wraps the standard AWS CLI, ensuring that commands are routed to the local endpoint (defaulting to http://localhost:4566) rather than public AWS services. It also includes an 'env' subcommand to help users configure their shell environment for seamless integration with local tools.
bin · high confidence
Added data models for Managed Service for Apache Flink (Kinesis Analytics V2)
This change introduces the core Java model classes required to support the new Kinesis Analytics V2 service emulation. It adds the \FlinkApplication\ POJO to represent the application state (including lifecycle status, configuration, and internal bookkeeping like container IDs), the \ApplicationStatus\ enum to track application lifecycle transitions (e.g., READY, STARTING, RUNNING), the \Snapshot\ class to manage Flink savepoints, and the \SnapshotStatus\ enum to track snapshot states. These models form the in-memory representation for the new service's API responses and internal state management.
src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/model · high confidence
Adds Umami analytics tracking to the site
The site now includes client-side analytics via Umami. A new \overrides/main.html\ template extends the base layout and injects the Umami tracking script into the page head, enabling usage data collection for the documentation site.
overrides · high confidence
Amazon Cognito Identity management plane support
Added the management plane for Amazon Cognito Identity, enabling users to create, describe, update, and delete federated identity pools, as well as manage pool roles, role mappings, resource tags, and principal tag attribute maps. This implementation handles the JSON request/response handling and service logic for these operations, while deliberately excluding identity and credential-vending operations (such as GetId and GetCredentialsForIdentity) that require STS session credentials.
src/main/java/io/github/hectorvent/floci/services/cognitoidentity · high confidence
Amazon Verified Permissions emulation via Cedar sidecar
The Verified Permissions service now emulates AWS behavior by delegating authorization evaluation to the external \floci-sidecar-cedar\ container. This change introduces a new sidecar management layer (\CedarSidecarManager\) that handles container lifecycle and contract validation, a client (\CedarSidecarClient\) for HTTP communication, and an adapter (\CedarAuthorizationEvaluator\) that normalizes AWS-style entity and policy data into Cedar's format. The service layer (\VerifiedPermissionsService\) and JSON handler (\VerifiedPermissionsJsonHandler\) now integrate this evaluator to support operations like \IsAuthorized\ and \BatchIsAuthorized\, while OIDC token verification (\VerifiedPermissionsOidcSignatureVerifier\) ensures secure identity claims.
src/main/java/io/github/hectorvent/floci/services/verifiedpermissions · high confidence
AppSync GraphQL data-plane execution engine and schema management
This change introduces the core data-plane components for the AppSync GraphQL emulator in the \src/main/java/io/github/hectorvent/floci/services/appsync/graphql\ package. It adds the \AppSyncExecutionController\ to handle incoming GraphQL requests, routing them through an authentication middleware and a GraphQL sidecar client for query planning and execution. The update includes the \AppSyncVtlEngine\ to evaluate VTL resolver templates using Apache Velocity with sandboxing and execution limits, along with supporting classes like \AppSyncVtlContext\ and \AppSyncVtlResult\. It also implements the \SchemaRegistry\ for in-memory SDL storage, the \SchemaCreationWorker\ for asynchronous schema validation and persistence, and the \SidecarSchemaCompiler\ to inject AWS-specific directives and scalar mappings before sending SDL to the sidecar. Finally, it adds \AppSyncDirective\ to define supported AWS directives and \AppSyncErrorFormatter\ to map sidecar errors to the AppSync wire format.
src/main/java/io/github/hectorvent/floci/services/appsync/graphql · high confidence
AppSync data source invocations and authorization
The emulator now executes AppSync resolvers against their backing data sources (DynamoDB, Lambda, RDS, and NONE) by translating resolver request payloads into native AWS API calls and returning results in the shape AppSync expects. A new authorization layer validates that each data source's service role trusts the AppSync service principal and has the specific IAM permissions required for the operation (e.g., DynamoDB actions, Lambda invocation, RDS Data API execution), failing the request with an AccessDenied error if checks do not pass.
src/main/java/io/github/hectorvent/floci/services/appsync/graphql/datasource · high confidence
AppSync emulator management API and GraphQL execution engine
This change introduces the core AppSync emulator service, exposing a REST API (AppSyncController) to manage GraphQL APIs, schemas, data sources, resolvers, and API keys, while implementing the underlying business logic (AppSyncService) with persistent storage. It also adds a new GraphQL execution engine that runs APPSYNC\_JS resolvers via a Node sidecar container (GraphqlSidecarManager/NodeAppSyncJsRuntime) and handles schema validation and query planning through a separate GraphQL sidecar, replacing the previous in-process native image approach.
src/main/java/io/github/hectorvent/floci/services/appsync · high confidence
Application Auto Scaling control plane with ECS capacity adjustment
The Application Auto Scaling service now supports registering scalable targets and step/target-tracking scaling policies, and actively evaluates them against ECS services. When a CloudWatch alarm fires, the new ScalingPolicyAlarmActionHandler calculates the required capacity change (respecting cooldowns, suspension flags, and min/max bounds) and delegates to EcsCapacityAdjuster to update the ECS service's desired count. The service also persists scalable targets, policies, and scaling activities, and handles tagging operations.
src/main/java/io/github/hectorvent/floci/services/applicationautoscaling · high confidence
Athena emulator now executes SQL queries via DuckDB sidecar
The Athena service has been refactored to replace the previous mock execution mode with real SQL processing. A new AthenaJsonHandler routes API actions (such as StartQueryExecution, GetQueryResults, and workgroup/catalog management) to an underlying AthenaService that leverages a FlociDuckClient to execute queries against a DuckDB sidecar. This enables actual query evaluation, including support for Iceberg tables via the iceberg extension, and ensures that result sets and metadata (like partition paths and column projections) are derived from real execution rather than static mocks.
src/main/java/io/github/hectorvent/floci/services/athena · high confidence
Aurora DSQL cluster emulation with resource-based policy enforcement
The emulator now supports Aurora DSQL clusters, providing a REST control plane for creating, updating, and deleting clusters along with managing their resource-based policies. Each cluster's database is served on a dedicated DSQL endpoint, and access to these endpoints is enforced by evaluating the cluster's resource-based policy against the caller's identity and connection context, ensuring that public access is correctly restricted.
src/main/java/io/github/hectorvent/floci/services/dsql · high confidence
Aurora Serverless v2 auto-pause support and container lifecycle refactoring
RDS backend containers now support auto-pause for Aurora Serverless v2 clusters: when idle for the configured duration, the container is frozen via Docker pause to simulate zero capacity, and automatically resumed on the next connection attempt. This behavior is managed by a new AutoPauseController and gated by RdsBackendLease to ensure safe state transitions. The underlying container management has been refactored to use a shared ContainerLifecycleManager and ContainerBuilder, replacing direct Docker client usage, and RdsContainerHandle now tracks runtime and storage keys to improve isolation and volume management.
src/main/java/io/github/hectorvent/floci/services/rds/container · high confidence
Automated documentation and partition-literal audits
Three new Python tools enforce consistency in the codebase: \check\_service\_matrix.py\ ensures every registered service appears in the documentation matrix and validates action counts; \regen\_action\_docs.py\ automatically regenerates supported action tables in service documentation from handler source code to prevent stale lists; and \partition\_literals.py\ audits Java source for hardcoded AWS partition assumptions (like 'aws' literals or commercial DNS suffixes) to ensure the emulator correctly supports all AWS partitions, not just the commercial one.
python · high confidence
Automatic EC2 port forwarding via security group rules
The emulator now automatically publishes TCP ports from EC2 instance security groups on the host. A new Ec2PortForwardManager creates lightweight socat sidecar containers to forward traffic from allocated host ports to the instance's internal IP, ensuring that any port opened in the security group (including those added after launch) is immediately accessible via localhost. This feature is opt-in and respects existing SSH port bindings.
src/main/java/io/github/hectorvent/floci/services/ec2/portforward · high confidence
Bedrock Runtime backend now supports streaming and proxying to OpenAI-compatible endpoints
The Bedrock Runtime backend now implements the \BedrockBackend\ interface with two concrete providers: a \StubBackend\ for local testing and a \ProxyBackend\ that forwards requests to real OpenAI-compatible APIs (such as Ollama, OpenRouter, or LiteLLM). This change introduces incremental streaming support via the new \converseStream\ method, allowing real-time token delivery, and adds a translator (\BedrockOpenAiTranslator\) that maps Bedrock Converse wire formats to OpenAI Chat Completions, preserving structured output schemas, reasoning effort, and image content. The proxy backend handles connection timeouts, cancellation, and error body reading, while the stub backend provides deterministic, stateless responses for development.
src/main/java/io/github/hectorvent/floci/services/bedrockruntime/backend · high confidence
Bedrock Runtime emulator adds streaming support and proxy backend
The Bedrock Runtime emulator now supports the Converse Stream API, allowing users to receive incremental responses via the \/model/{modelId}/converse-stream\ endpoint. Additionally, a new proxy backend option has been introduced, enabling the emulator to forward requests to a real LLM provider via an OpenAI-compatible API instead of returning static stub responses. Users can switch between the default stub backend and the new proxy backend using the \floci.services.bedrock-runtime.backend\ configuration property.
src/main/java/io/github/hectorvent/floci/services/bedrockruntime · high confidence
Cloud Control API handler for resource management
Added CloudControlJsonHandler to expose Cloud Control API operations (List, Get, Create, Delete, and GetRequestStatus) for managing resources. This handler routes requests to the underlying CloudControlService, ensuring resources are scoped by the caller's account ID and returning standardized JSON responses with progress events and resource descriptions.
src/main/java/io/github/hectorvent/floci/services/cloudcontrol · high confidence
CloudFormation model enhancements for StackSets, concurrency, and policy fidelity
The CloudFormation service models have been expanded to support StackSets, introducing new entities for StackInstance, StackSet, StackSetOperation, and StackSetAutoDeploymentTarget to track multi-account deployments and their operations. The core Stack model now includes account scoping via a new accountId field, tracks deletion time for deleted stacks, and enforces termination protection. To ensure thread-safety during concurrent requests, internal collections (parameters, outputs, resources, events, etc.) are now backed by synchronized maps and copy-on-write lists with snapshot accessors. Additionally, resource-level fidelity is improved by adding deletionPolicy and updateReplacePolicy to StackResource, and change-set previews now account for resolved SSM parameters and tags.
src/main/java/io/github/hectorvent/floci/services/cloudformation/model · high confidence
CloudFormation support for AWS::Include, CDK Provider-framework custom resources, and SAM transforms
The CloudFormation emulator now expands AWS::Include snippets by fetching and merging YAML/JSON from S3 URIs, processes AWS::Serverless-2016-10-31 SAM transforms to generate standard CloudFormation resources, and handles CDK Provider-framework custom resources by detecting the async waiter pattern and routing Lambda callbacks through a dedicated HTTP endpoint. It also enforces create-only property rules from schema definitions to prevent unintended updates.
src/main/java/io/github/hectorvent/floci/services/cloudformation · high confidence
DynamoDB model layer expanded to support vector search, S3 import/export, and advanced table configurations
The DynamoDB model package now includes new data classes for VectorIndex and SearchSchemaElement to support vector search capabilities, as well as ExportDescription, ExportSummary, ImportTableDescription, and ImportSummary to handle S3-based table import and export operations. The core TableDefinition, GlobalSecondaryIndex, and LocalSecondaryIndex models have been enriched with fields for Point-in-Time Recovery, Deletion Protection, Server-Side Encryption (SSE), Kinesis streaming destinations, TableId, TableClass, On-Demand throughput limits, Global Table replicas, and Resource Policies. Additionally, the sort key handling in index models was corrected to return all sort key attribute names without corrupting persisted data, and JSON serialization was adjusted to prevent deserialization errors on derived properties.
src/main/java/io/github/hectorvent/floci/services/dynamodb/model · high confidence
EC2 service implementation with container-backed instances and IPAM support
The EC2 service now runs guest instances as Docker containers, managed by Ec2ContainerManager which handles lifecycle, SSH, and user data execution. It includes AmiImageResolver to map AMI IDs to Docker images, Ec2ImageCatalog and Ec2InstanceTypeCatalog for metadata, and Ec2IpamService for VPC IP Address Manager emulation. Container network reachability is detected via TCP probes to ensure API clients receive routable addresses.
src/main/java/io/github/hectorvent/floci/services/ec2 · high confidence
ECR service now supports pull-through cache rules and image scanning configuration
The ECR service implementation adds support for managing pull-through cache rules, allowing users to create, describe, update, validate, and delete rules that cache images from upstream registries (such as Docker Hub, Quay, and GitHub Container Registry) in their ECR repositories. Additionally, the service now supports configuring and retrieving image scanning settings for repositories, enabling automatic vulnerability scanning on push. These changes expand the emulator's compatibility with AWS ECR APIs used for container image management and caching strategies.
src/main/java/io/github/hectorvent/floci/services/ecr · high confidence
ECS service lifecycle and integration support
The ECS service now supports service discovery via AWS Cloud Map, automatically registering task addresses when services are created and deregistering them on stop. It also integrates with ELBv2 to register and deregister task containers as load balancer targets. The service emits AWS-shaped lifecycle events to EventBridge for task state changes and deployment status updates, and includes a JSON passthrough mechanism to preserve unhandled request fields for round-trip compatibility with tools like Terraform.
src/main/java/io/github/hectorvent/floci/services/ecs · high confidence
EKS access entries, addon management, and node bootstrap support
The EKS service now supports managing access entries (creating, describing, listing, and deleting IAM principals with STANDARD or EC2\_LINUX types), installing and managing EKS addons via a version catalog, and parsing EC2 user data to extract cluster names for node joining. This includes the EksAccessEntryService for principal authorization, EksAddonService and EksAddonCatalog for addon lifecycle and version compatibility, and EksBootstrapUserData for parsing bootstrap scripts and NodeConfig YAMLs.
src/main/java/io/github/hectorvent/floci/services/eks · high confidence
EKS model layer: new data structures for cluster, node group, addon, and access management
The EKS service model package now includes a comprehensive set of Java records and classes that define the data shapes for EKS resources. This adds support for managing cluster access configurations and entries, cluster addons (including health and version info), pod identity associations, Fargate profiles, and managed node groups. The models also capture cluster-level details such as VPC configuration, network settings, logging, encryption, and OIDC identity, enabling the service to serialize and deserialize these resources for API responses and internal state persistence.
src/main/java/io/github/hectorvent/floci/services/eks/model · high confidence
ElastiCache emulator adds Memcached support and expands API coverage
The ElastiCache emulator now supports Memcached clusters alongside existing Redis functionality, introducing new service classes and a shared provisioning ID system to manage concurrent cluster creation. The query handler has been expanded to support a wide range of new operations, including Create/Describe/Modify/Delete for Cache Clusters, User Groups, Cache Subnet Groups, and Cache Parameter Groups, as well as ModifyReplicationGroup and ListTagsForResource. These changes enable users to manage Memcached resources, configure subnet and parameter groups, and handle user group associations within the emulator environment.
src/main/java/io/github/hectorvent/floci/services/elasticache · high confidence
ElastiCache model expansion and native-image reflection registration
The ElastiCache service models have been significantly expanded to support new capabilities: new model classes for CacheCluster, CacheParameterGroup, CacheSubnetGroup, ClusterNode, and ElastiCacheUserGroup have been added, while ReplicationGroup now tracks encryption, snapshot, and cluster-mode settings. Existing models (ElastiCacheUser, ReplicationGroup) have been updated to include engine type, ARN, and user-group associations. To ensure these models work correctly in native-image builds, reflection registration annotations (@RegisterForReflection) have been added to all model classes and enums, and the AuthMode enum was updated to include this registration.
src/main/java/io/github/hectorvent/floci/services/elasticache/model · high confidence
Emulate AWS Marketplace APIs for agreements, catalog, deployment, discovery, and entitlements
The marketplace service now emulates several AWS Marketplace APIs to support product listing, agreement management, and deployment workflows. The Agreement API (MarketplaceAgreementController/Service) allows creating, accepting, and cancelling agreement requests, and retrieving agreement details, terms, and billing adjustments. The Catalog API (MarketplaceCatalogController) exposes endpoints to describe and list entities, manage change sets, and handle resource policies and tags. The Deployment API (MarketplaceDeploymentController/Service) enables setting deployment parameters for products and managing resource tags. The Discovery API (MarketplaceDiscoveryController/Service) provides endpoints to search listings, get offers, and list fulfillment options. The Entitlement API (MarketplaceEntitlementController/Service) supports retrieving entitlements for a product code. These changes add new controllers and services that handle the specific request/response formats and validation logic for each of these marketplace capabilities.
src/main/java/io/github/hectorvent/floci/services/marketplace · high confidence
Emulate AWS Observability Access Manager (OAM) API
Added a new emulation layer for the AWS Observability Access Manager (OAM) service, exposing REST endpoints for managing OAM Sinks and Links. Users can now create, retrieve, list, update, and delete Sinks and Links, as well as manage sink policies and resource tags. The implementation enforces AWS-like constraints, such as allowing only one Sink per region and a maximum of five Links per region, while storing data in account-scoped JSON files.
src/main/java/io/github/hectorvent/floci/services/oam · high confidence
Emulate AWS S3 Tables service
Added an in-memory emulation of the AWS S3 Tables API, including REST endpoints for managing table buckets, namespaces, and Iceberg tables. Users can now create, list, get, delete, and rename tables, as well as manage bucket policies and maintenance configurations through the new S3TablesController and S3TablesService components.
src/main/java/io/github/hectorvent/floci/services/s3tables · high confidence
Emulate AWS Service Catalog with Control Tower Account Factory
The application now includes a mock implementation of AWS Service Catalog, allowing users to manage portfolios, products, and provisioning artifacts. This new service automatically initializes a default 'AWS Control Tower Account Factory' portfolio and product upon first access, mimicking the behavior of AWS Control Tower. Users can perform standard Service Catalog operations such as creating and describing portfolios and products, associating products with portfolios, and provisioning products, with all state persisted in local storage.
src/main/java/io/github/hectorvent/floci/services/servicecatalog · high confidence
Emulate Amazon Bedrock AgentCore control-plane endpoints
Added a new set of REST-JSON controllers and services under the \bedrockagentcorecontrol\ package that emulate the Amazon Bedrock AgentCore control plane. This includes endpoints for managing agent runtimes (create, list, get, update, delete), credential providers (API keys and OAuth2), gateways and their targets, and gateway rules. The implementation provides in-memory storage-backed CRUD operations with pagination, validation, and idempotency support, allowing users to interact with a simulated AgentCore environment without invoking real AWS services.
src/main/java/io/github/hectorvent/floci/services/bedrockagentcorecontrol · high confidence
Emulate Amazon Bedrock AgentCore data-plane and memory events
The Bedrock AgentCore service now includes stubs for the AgentCore data-plane and memory capabilities. The new BedrockAgentCoreController exposes endpoints for InvokeAgentRuntime (POST /runtimes/{arn}/invocations) and InvokeHarness (POST /harnesses/invoke), returning fixed responses and echoing session IDs, while the harness endpoint streams event-frame responses that echo the last user message. The BedrockAgentCoreEventService implements the data-plane behind CreateEvent, ListEvents, GetEvent, and DeleteEvent, storing events in a JSON-backed store with validation, pagination, and newest-first ordering. Supporting model classes (MemoryEvent, Branch, PayloadType, Conversational, Content) and the BedrockAgentCoreHarnessService handle request validation, event-stream framing, and configurable canned replies.
src/main/java/io/github/hectorvent/floci/services/bedrockagentcore · high confidence
Emulate Amazon Redshift Data API for cluster and serverless workgroups
Added a new Redshift Data API service layer that allows executing SQL statements, managing batches, and retrieving results against both provisioned Redshift clusters and Redshift Serverless workgroups. The implementation supports asynchronous execution with status tracking, client token idempotency to prevent duplicate operations, and session reuse for persistent connections. It handles credential resolution via Secrets Manager or database users, maps JDBC result sets to the AWS Data API response format, and publishes statement status events to EventBridge.
src/main/java/io/github/hectorvent/floci/services/redshiftdata · high confidence
Establish AI agent guidelines and enforce partition literal safety
Added AGENTS.md to define operating rules for AI coding agents, including architecture, protocol, and storage guidelines. Introduced .gitattributes to standardize line endings (LF for text, CRLF for Windows scripts) and mark binary files. Implemented a partition literal baseline check (via Makefile targets) to prevent hardcoded 'aws' partition assumptions in source code, ensuring compatibility with GovCloud, China, and other AWS partitions.
(repo-wide) · high confidence
EventBridge target delivery, scheduling, and advanced resource management
This change introduces the core runtime engine for EventBridge rule execution and significantly expands the supported API surface. The new EventBridgeInvoker and TargetDispatcher components handle the actual delivery of events to targets (Lambda, SQS, SNS, Batch, ECS, Firehose, and HTTP), implementing AWS-conformant retry policies with exponential backoff, dead-letter queue routing, and InputTransformer logic. Scheduled rules are now actively fired by the RuleScheduler using rate and cron expressions, while the ReplayDispatcher enables replaying archived events to destination buses. The service layer now supports managing Archives, Replays, Connections, and ApiDestinations, along with permission policies (Put/RemovePermission), resource tagging, and the TestEventPattern action.
src/main/java/io/github/hectorvent/floci/services/eventbridge · high confidence
Expanded API Gateway model support for REST API configuration
The API Gateway service models have been significantly expanded to support detailed configuration of REST APIs. New model classes include Account, EndpointConfiguration, GatewayResponse, GatewayResponseType, MethodSetting, Model, ThrottleSettings, and VpcLink. Existing models have been updated: ApiKey now supports customerId, description, stageKeys, and tags; Authorizer supports Cognito User Pools via providerARNs; CustomDomain and UsagePlan now support tags; Integration includes TLS configuration, connection types, and request parameters; MethodConfig supports API key requirements, authorization scopes, and request validators; RestApi includes endpoint configuration, binary media types, and policy; Stage includes method settings, cache cluster settings, access logs, and tracing. ApiGatewayResource now uses ConcurrentHashMap for thread safety.
src/main/java/io/github/hectorvent/floci/services/apigateway/model · high confidence
Expanded API Gateway v2 model support for HTTP and WebSocket APIs
The API Gateway v2 service models have been significantly expanded to support more granular configuration of HTTP and WebSocket APIs. New model classes have been added for IntegrationResponse, Model, RouteResponse, and VpcLink, while existing models like Api, Authorizer, Integration, Route, and Stage now include additional fields such as CORS configuration, connection types, authorization scopes, stage variables, and detailed route settings. This enables more complete representation of API Gateway v2 resources in the service layer.
src/main/java/io/github/hectorvent/floci/services/apigatewayv2/model · high confidence
Expanded Cognito model support for OAuth, MFA, and identity providers
The Cognito service models have been significantly expanded to support advanced authentication and configuration features. New model classes include CognitoAuthorizationCode and CognitoAuthorizationTransaction for handling OAuth flows, IdentityProvider for federated sign-in, and CognitoGroup for group management. UserPoolClient now supports OAuth scopes, client secrets, and managed login branding. UserPool and CognitoUser models have been enriched with fields for MFA configuration (email and software token), password history, pending attribute verification, and token revocation tracking via RevokedTokenInfo. Additional models like UserPoolDomain, ResourceServer, and ManagedLoginBranding enable domain operations, resource server scopes, and custom branding.
src/main/java/io/github/hectorvent/floci/services/cognito/model · high confidence
Expanded EC2 model definitions for new and existing resources
The EC2 service model now includes data classes for a broader set of AWS resources, enabling more complete API responses and state management. New model classes introduce support for Capacity Reservations, Dedicated Hosts, VPC Flow Logs, IP Address Manager (IPAM) pools and allocations, and EBS block device mappings. Existing resource models have been enriched with additional fields, such as public IP address handling in Elastic Addresses, instance credit specifications for burstable performance types, and detailed network interface attributes. These changes provide the structural foundation for the service to report and manage these specific EC2 features accurately.
src/main/java/io/github/hectorvent/floci/services/ec2/model · high confidence
Expanded EventBridge model support for new targets and configurations
The EventBridge service model has been significantly expanded to support a wider range of AWS capabilities. New model classes have been added for ApiDestination, Archive, ArchivedEvent, Connection, Replay, and their respective state enums, enabling management of these resources. Target configurations now support Batch, ECS, and HTTP parameters, along with InputTransformer, RetryPolicy, and DeadLetterConfig. Additionally, the EventBus model now includes fields for policy, KMS key, dead-letter configuration, and logging, while the Rule model exposes the account ID and derives the region from the ARN.
src/main/java/io/github/hectorvent/floci/services/eventbridge/model · high confidence
Expanded KMS capabilities with key import, grants, and AWS managed keys
The KMS service now supports importing external key material (RSA and ECC) via GetParametersForImport and ImportKeyMaterial, managing key grants (CreateGrant, ListGrants, RevokeGrant), and serving AWS managed keys under reserved aliases (alias/aws/\*). New operations include GenerateRandom, GenerateMac/VerifyMac, ReplicateKey for multi-region keys, and key policy management (GetKeyPolicy, PutKeyPolicy, ListKeyPolicies). The service also validates wrapping algorithms for imports and enforces key usage/spec constraints.
src/main/java/io/github/hectorvent/floci/services/kms · high confidence
Expanded KMS key model with grants, import parameters, and key specs
The KMS model now supports a broader range of AWS KMS capabilities. New model classes \KmsGrant\, \KmsImportParameters\, \KmsKeySpec\, \KmsKeyUsage\, and \KmsMessageType\ have been added to represent grants, import tokens, key specifications, usage constraints, and message types respectively. The \KmsKey\ class has been significantly extended to include fields for key origin, key manager, expiration, import parameters, multi-region settings, policies, key rotation status, encoded private/public keys, on-demand rotation counts, and AES-GCM envelope backing keys. This enables features like key grants, external key material import, multi-region keys, key policies, and more granular key specification handling.
src/main/java/io/github/hectorvent/floci/services/kms/model · high confidence
Expanded Lambda model support for extensions, code signing, and event source mappings
The Lambda service model now includes new data classes for CodeSigningConfig, ExtensionEvent, and RegisteredExtension, enabling support for Lambda Extensions and code signing configurations. FunctionEventInvokeConfig and ScalingConfig have been added to model event invocation destinations and SQS event source mapping concurrency limits. The existing EventSourceMapping, LambdaFunction, InvokeResult, LambdaAlias, and LambdaUrlConfig models have been expanded with new fields to support features such as self-managed Kafka sources, EFS file system configs, hot-reload paths, durable execution, and routing configurations.
src/main/java/io/github/hectorvent/floci/services/lambda/model · high confidence
Expanded S3 model support for checksums, object attributes, and bucket configurations
The S3 model layer has been significantly expanded to support new S3 capabilities. New model classes have been added for ChecksumAlgorithm and ChecksumType to handle CRC32, CRC32C, CRC64NVME, SHA1, and SHA256 checksums, including composite and full-object multipart checksums. GetObjectAttributes support is introduced via GetObjectAttributesResult and GetObjectAttributesParts models. Object annotations are now modeled with ObjectAnnotation and ObjectAttributeName. CopyObject and PutObject operations now include detailed options models (CopyObjectOptions, PutObjectOptions) supporting checksums, ACLs, SSE, and preconditions. Bucket configuration has been extended to include logging, replication, public access block, ownership controls, request payment, accelerate, website hosting, metrics, intelligent-tiering, analytics, and inventory configurations. Notification configurations now support Lambda functions and EventBridge. These changes provide the data structures required for these S3 features.
src/main/java/io/github/hectorvent/floci/services/s3/model · high confidence
Firehose delivery now supports Lambda transforms, data format conversion to Parquet, and compression
Delivery streams can now transform records via a Lambda function before storage, convert JSON data to Parquet using the floci-duck sidecar, and apply compression formats (GZIP, ZIP, Snappy, Hadoop Snappy) when delivering to S3. The service also validates ProcessingConfiguration and DataFormatConversionConfiguration settings, ensuring that only supported configurations (such as ParquetSerDe) are accepted and that buffering and compression constraints are enforced.
src/main/java/io/github/hectorvent/floci/services/firehose · high confidence
HTTP API v2 OpenAPI import and JWT signature verification
Users can now import and reimport HTTP API definitions from OpenAPI 3 documents via the new ImportApi and ReimportApi operations, which parse the spec and materialize routes, integrations, and authorizers while respecting AWS extensions like x-amazon-apigateway-cors. Additionally, HTTP API v2 JWT authorizers now perform actual RS256 signature verification against the issuer's JWKS endpoint, replacing the previous behavior of accepting claims without cryptographic validation, and the service supports quick-create provisioning of a default integration, route, and stage when a target is supplied during API creation.
src/main/java/io/github/hectorvent/floci/services/apigatewayv2 · high confidence
HTTP\_PROXY integration support for API Gateway v2
This change introduces the HTTP\_PROXY integration capability for HTTP APIs (API Gateway v2). It adds a new proxy subsystem that resolves request parameters (headers, query strings, path parameters, and authorizer claims) via expression mapping, constructs backend URLs using path template substitution, and forwards requests to backend targets. The implementation includes strict security controls: it pins the resolved IP address to prevent DNS rebinding, blocks link-local and metadata endpoints, enforces a 10 MB response payload quota, and handles TLS verification (including an option to skip CA verification while retaining hostname and expiration checks). It also correctly manages HTTP/1.1 framing, hop-by-hop header stripping, and multi-value header preservation.
src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy · high confidence
IAM Identity Center emulation adds SSO OIDC service endpoints
The emulator now implements the core SSO OIDC API endpoints required for IAM Identity Center emulation, including client registration, device authorization flows, and token issuance. This new SsoOidcController and its supporting service layer handle standard OAuth 2.0 grant types (authorization\_code, refresh\_token) as well as AWS-specific extensions like JWT bearer and token exchange grants tied to IAM applications. Users can now register OIDC clients, initiate device authorization codes, and obtain access tokens that integrate with the existing SSO Admin application policies.
src/main/java/io/github/hectorvent/floci/services/ssooidc · high confidence
IAM Identity Center emulation now supports permission sets, assignments, and SSO OIDC
The SSO Admin service now implements the core IAM Identity Center capabilities of managing permission sets and account assignments, alongside the SSO OIDC endpoint for client registration, device authorization, and token issuance. Users can now create and configure permission sets (including managed and customer-managed policies), assign them to accounts or principals, and utilize the OIDC flow for authentication and token exchange, completing the emulation of the IAM Identity Center feature set.
src/main/java/io/github/hectorvent/floci/services/ssoadmin · high confidence
IAM enforcement engine and policy evaluation logic
The IAM service now includes a complete enforcement engine that evaluates identity-based, resource-based, session, and permission boundary policies against incoming requests. This change introduces the core policy evaluation logic (IamPolicyEvaluator), a dedicated trust policy evaluator for AssumeRole operations (AssumeRolePolicyEvaluator), and a registry mapping REST/Query API routes to IAM actions (IamActionRegistry). It also adds support for resolving AWS managed policies from a bundled catalog (AwsManagedPolicies) and utilities for parsing request bodies and identifying request principals (RequestBodyReader, RequestPrincipal, ResourceArnBuilder) to enable accurate authorization checks.
src/main/java/io/github/hectorvent/floci/services/iam · high confidence
Implement ECS ExecuteCommand data channel for interactive container shells
This change introduces the backend logic for the ECS ExecuteCommand feature, allowing users to open interactive, root-level shells into running containers via a WebSocket data channel. The implementation includes a session registry that manages short-lived, token-authenticated sessions with a 5-minute TTL, a binary protocol handler (AgentMessage) that parses and encodes the Session Manager data frames exchanged with the AWS CLI, and a channel handler that bridges these WebSocket frames to Docker exec streams. This enables the emulator to mimic the real AWS ECS agent's behavior for remote command execution.
src/main/java/io/github/hectorvent/floci/services/ecs/exec · high confidence
Implement Lambda Extensions API support in the local runtime
The local Lambda runtime now supports the AWS Lambda Extensions API, allowing extension processes to register for lifecycle events (init, invoke, shutdown) and receive events via a dedicated polling endpoint. This is implemented in the RuntimeApiServer, which manages extension registration, event delivery, and proper shutdown sequencing (draining parked extensions before closing the API server). Additionally, the RuntimeApiServerFactory now correctly releases allocated ports if server startup fails, preventing port leaks.
src/main/java/io/github/hectorvent/floci/services/lambda/runtime · high confidence
Implement Resource Groups Tagging API
Added support for the AWS Resource Groups Tagging API, enabling users to manage resource tags via the \GetResources\, \TagResources\, \UntagResources\, \GetTagKeys\, and \GetTagValues\ operations. The implementation persists tag mappings across restarts using a storage-backed map and routes tag mutations to the owning service's \TagHandler\ when available, ensuring that tag state is consistent with the specific resource's service.
src/main/java/io/github/hectorvent/floci/services/resourcegroupstagging · high confidence
Initial Amazon EMR management API support
This release introduces the first phase of the Amazon EMR management API, enabling users to create, describe, and terminate EMR clusters (job flows) along with managing associated resources such as instance groups, instance fleets, steps, security configurations, tags, and block public access settings. The implementation simulates cluster lifecycles with immediate state transitions for deterministic testing, supports scaling and termination policies, and provides discovery endpoints for release labels and supported instance types via a curated local catalog.
src/main/java/io/github/hectorvent/floci/services/emr · high confidence
Initial Elastic Beanstalk Query API support with persistent storage
This change introduces the Elastic Beanstalk Query API implementation within the Floci service, enabling users to manage Elastic Beanstalk applications, versions, and environments via a query handler. The service layer now persists application, version, and environment data across restarts using a storage-backed map, ensuring that state is retained rather than lost on service restarts. The implementation includes handlers for core operations such as creating, describing, updating, and deleting applications, versions, and environments, as well as checking DNS availability and listing solution stacks.
src/main/java/io/github/hectorvent/floci/services/elasticbeanstalk · high confidence
Introduce AWS AppConfig service emulation with feature flag support
This change adds the core implementation for the AWS AppConfig service, including controllers and services for managing applications, environments, configuration profiles, hosted configuration versions, deployment strategies, and deployments. It introduces a pre-matching route filter to disambiguate requests to the /configuration path between the AppConfigData runtime API and S3 buckets named 'configuration'. The AppConfigData service now supports configuration sessions, respects the requested poll interval, and returns feature flag variants in Amazon Ion format when the client accepts application/ion;type=AWS.AppConfig.FeatureFlags, falling back to the standard JSON retrieval format otherwise. Resource tagging is supported for applications and accepts top-level resource ARNs for deployment strategies, extensions, and extension associations.
src/main/java/io/github/hectorvent/floci/services/appconfig · high confidence
Introduce AWS BCM Data Exports management API
Added the management-plane implementation for AWS Billing and Cost Management (BCM) Data Exports within the \bcmdataexports\ service. This includes the \BcmDataExportsJsonHandler\ to dispatch API actions (Create, Get, List, Update, Delete Export, and List/Get Executions) and the \BcmDataExportsService\ to persist export definitions and execution records. The service enforces that only PARQUET format is accepted for now and integrates with the \CurEmissionScheduler\ to trigger data emission upon export creation or updates.
src/main/java/io/github/hectorvent/floci/services/bcmdataexports · high confidence
Introduce AWS Batch service emulator
Added a new emulated AWS Batch service that exposes REST endpoints for managing compute environments, job queues, job definitions, and job execution (submit, cancel, terminate, describe). The service persists state to local JSON files and executes jobs by launching Docker containers, supporting both single-node and multi-node parallel jobs.
src/main/java/io/github/hectorvent/floci/services/batch · high confidence
Introduce AWS Config service emulation
Adds a new in-memory emulation of the AWS Config service, including the core service implementation, a JSON-based request handler, and the full set of data model records (config rules, conformance packs, aggregation authorizations, compliance summaries, evaluations, configuration recorders, delivery channels, and retention configurations). This enables users to exercise Config workflows—such as creating rules, evaluating compliance, and managing conformance packs—without requiring a live AWS account.
src/main/java/io/github/hectorvent/floci/services/configservice · high confidence
Introduce AWS EventBridge Scheduler service emulation
Adds a new EventBridge Scheduler service to the emulator, enabling the creation, listing, updating, and deletion of schedule groups and schedules via REST endpoints. The implementation supports schedule expressions including one-time (at), rate-based, and cron triggers, with configurable timezones. When schedules fire, the dispatcher invokes targets such as SQS, Lambda, SNS, EventBridge, ECS RunTask, Step Functions, and universal AWS SDK actions (e.g., sns:publish, sqs:sendMessage, redshiftdata:executeStatement). It also handles retry policies, dead-letter queue delivery for exhausted attempts, and tag management for schedule groups.
src/main/java/io/github/hectorvent/floci/services/scheduler · high confidence
Introduce AWS Lambda MicroVMs and Network Connector service modules
Added the \LambdaMicrovmsController\ and \LambdaNetworkConnectorsController\ along with the backing \LambdaMicrovmsService\ to support the AWS Lambda MicroVMs API (2025-09-09) and Lambda Core Network Connectors API (2026-04-30). This new module provides in-memory CRUD operations for MicroVM images (including version and build management), MicroVMs, and VPC egress network connectors, enabling CloudFormation resource types like \AWS::Lambda::MicrovmImage\ and \AWS::Lambda::NetworkConnector\ to provision and manage these resources locally.
src/main/java/io/github/hectorvent/floci/services/lambdamicrovms · high confidence
Introduce AWS Resource Access Manager (RAM) service emulation
Added a new JAX-RS controller and backend service to emulate AWS RAM, enabling organization-wide sharing opt-in, resource share CRUD operations, and principal association management. The implementation includes model classes for resource shares, invitations, and permissions, supporting visibility rules where organization/OU principals are visible only to members resolved through the Organizations service, and account principals see shares only while invitations are pending or accepted.
src/main/java/io/github/hectorvent/floci/services/ram · high confidence
Introduce Amazon DocumentDB service emulation
Added emulation support for Amazon DocumentDB, including the core service and query handler classes. This enables users to create, describe, modify, and delete DocumentDB clusters and instances, as well as manage tags. The implementation handles region-scoped identifiers, integrates with existing RDS-family APIs for global cluster descriptions, and supports engine version validation against a defined set of supported versions.
src/main/java/io/github/hectorvent/floci/services/docdb · high confidence
Introduce Amazon MQ broker data models
Added the core model classes (Broker, BrokerInstance, BrokerState, MqUser) that represent the in-memory state and wire format for Amazon MQ brokers. These classes define the structure for broker metadata, instance connection details, lifecycle states, and user credentials, enabling the service to mirror the Amazon MQ REST-JSON protocol shape and manage broker lifecycle transitions.
src/main/java/io/github/hectorvent/floci/services/amazonmq/model · high confidence
Introduce Amazon MSK service with Redpanda orchestration and configuration management
This change adds the Amazon MSK service implementation, enabling users to create, list, describe, and delete MSK clusters and configurations via the emulator. Clusters are backed by Redpanda containers managed by RedpandaManager, which handles container lifecycle, port allocation, and external broker address advertisement. The service supports both provisioned and serverless cluster types, persists cluster metadata and configuration details (including broker node groups, encryption, client authentication, logging, and tags), and exposes configuration CRUD operations with revision tracking. Input validation includes precise handling of broker node counts to reject malformed values, and the service gracefully degrades when Docker is unavailable.
src/main/java/io/github/hectorvent/floci/services/msk · high confidence
Introduce Amazon MWAA emulation with real Airflow containers
Added a new emulation service for Amazon MWAA that runs real Apache Airflow (LocalExecutor) and Postgres containers to provide a high-fidelity local testing environment. The implementation includes a REST controller mirroring the MWAA API (using PUT for CreateEnvironment and PATCH for UpdateEnvironment), a service layer managing environment lifecycle and state, and an environment manager that orchestrates the Docker containers, including dynamic port allocation, DAG synchronization from S3, and CLI token generation for authenticated access.
src/main/java/io/github/hectorvent/floci/services/mwaa · high confidence
Introduce CloudFront service emulation for local testing
Adds a new CloudFront service emulation layer that allows users to create, configure, and serve content through CloudFront distributions locally. This includes a REST controller for distribution management, a request filter to route traffic by distribution domain, an HTTP client for streaming origin responses, and logic to handle cache behaviors, origin request policies, and signed content, enabling end-to-end testing of CloudFront-based architectures without AWS.
src/main/java/io/github/hectorvent/floci/services/cloudfront · high confidence
Introduce CloudHSM v2 service emulation
Adds a new CloudHSM v2 service implementation to the emulator, enabling users to create, initialize, and manage HSM clusters and individual HSM instances. The change includes the JSON handler for dispatching AWS API actions (such as CreateCluster, DescribeClusters, CreateHsm, and backup operations), the core service logic for cluster lifecycle management and certificate generation, and the necessary domain models (Cluster, Hsm, Backup, Certificates) to support these operations.
src/main/java/io/github/hectorvent/floci/services/cloudhsmv2 · high confidence
Introduce CloudWatch dashboard management service
Added a new service implementation for CloudWatch dashboards that supports creating, retrieving, listing, and deleting dashboards, along with tag management. The service validates that dashboard bodies are proper JSON objects, enforces a maximum of 50 tags per dashboard, and correctly handles region-specific storage keys and ARN generation. It also implements best-effort deletion semantics where missing dashboards in a batch trigger an error only after attempting to delete existing ones.
src/main/java/io/github/hectorvent/floci/services/cloudwatch/dashboards · high confidence
Introduce DSQL emulator dataplane with cluster-specific PostgreSQL containers and IAM-authenticated endpoint
The DSQL emulator now manages a dedicated PostgreSQL 16 container for each cluster, handling container lifecycle, volume persistence, and bootstrap scripts via DsqlDatabases. A single DsqlEndpoint serves all clusters on one port, routing connections by server name and enforcing Aurora DSQL-compatible authentication: mandatory TLS (accepting direct handshakes without SSLRequest), SigV4 IAM token validation with a 5-second expiry grace, and IAM role mapping via AWS IAM GRANT. The endpoint enforces DSQL protocol limits (startup packet size, message size, 300-second transaction age) and evaluates resource-based IAM policies on connect. DsqlStatements rewrites DSQL-specific syntax (e.g., CREATE INDEX ASYNC, AWS IAM GRANT/REVOKE) and rejects unsupported statements, while DsqlTlsCertificates issues a wildcard TLS certificate for all known regions.
src/main/java/io/github/hectorvent/floci/services/dsql/dataplane · high confidence
Introduce EC2 Auto Scaling service implementation
This change adds the core implementation for the EC2 Auto Scaling service, including the query handler for API actions (such as creating and describing launch configurations, auto scaling groups, and managing scaling policies), a background reconciler to maintain group state and capacity, and the underlying service layer with storage-backed persistence for groups, policies, and lifecycle hooks. It also introduces the necessary model classes (e.g., AutoScalingGroup, AsgInstance, InstanceRefresh) to support these operations.
src/main/java/io/github/hectorvent/floci/services/autoscaling · high confidence
Introduce ECS model classes for native-image reflection
Added a comprehensive set of Java model classes in the ECS service package (including Attribute, AwsVpcConfiguration, CapacityProvider, Container, ContainerDefinition, EcsServiceModel, and request/response types) to represent ECS resources. All classes are annotated with @RegisterForReflection to ensure they are available for dynamic reflection during native-image execution, addressing previous issues where persisted model records were not correctly registered.
src/main/java/io/github/hectorvent/floci/services/ecs/model · high confidence
Introduce ECS task container management with task-role credentials and FireLens support
This change adds the core ECS container runtime components, enabling the emulation of ECS task lifecycles. It introduces EcsContainerManager to orchestrate Docker containers per task definition, including support for container dependencies, volume mounts, and log streaming. A new task-role credential system is implemented, featuring EcsCredentialsProxy and EcsTaskRoleCredentials to issue and rotate IAM sessions via a local HTTP endpoint, ensuring task containers can authenticate with AWS services. Additionally, FireLens configuration generation is added to support Fluent Bit and Fluentd log routers, and a HostVolumePolicy is introduced to enforce safe bind-mount restrictions for host volumes.
src/main/java/io/github/hectorvent/floci/services/ecs/container · high confidence
Introduce Elastic File System (EFS) service implementation
This change adds the core backend implementation for AWS Elastic File System (EFS) support. It introduces the EfsController REST endpoints and the EfsService business logic to manage file systems, mount targets, and access points, along with the necessary request/response model classes. The service persists data using a file-based storage backend and includes specific handling for replication overwrite protection, which is enabled by default on new file systems.
src/main/java/io/github/hectorvent/floci/services/efs · high confidence
Introduce Elastic Load Balancing v2 (ELBv2) emulation
This change adds the core implementation for the ELBv2 service, enabling the emulator to manage Application, Network, and Gateway load balancers, target groups, listeners, and rules. It includes the data plane for routing traffic (including WebSocket upgrades and Lambda invocations), a health checker that probes targets on the configured health check port, and a query handler that exposes the full AWS ELBv2 API surface. The implementation also handles OIDC and Cognito authentication actions, preserves host headers, and ensures default attributes are reported to prevent infrastructure-as-code drift.
src/main/java/io/github/hectorvent/floci/services/elbv2 · high confidence
Introduce FlociDuckClient and FlociDuckManager for DuckDB sidecar management
Added FlociDuckClient and FlociDuckManager classes in the services.floci.duck package to manage the floci-duck sidecar container. FlociDuckClient provides HTTP methods to execute SQL queries (writing results to S3 for Athena) and query data (returning rows as JSON for S3 Select), supporting optional DDL setup and specific AWS account authentication. FlociDuckManager handles the lifecycle of the floci-duck container, lazily starting it on first use, supporting pre-configured URLs for external deployments, and ensuring health before making it available.
src/main/java/io/github/hectorvent/floci/services/floci/duck · high confidence
Introduce Lake Formation service with resource and permission management
This change adds a new Lake Formation service layer to the application, exposing REST endpoints for managing data lake settings, registering and updating resources, granting and revoking permissions, and managing Lake Formation tags (LFTags). The implementation includes a controller handling JSON requests, a service layer with business logic and validation, and an in-memory storage backend using the existing storage factory. Key capabilities include setting data lake permissions, registering AWS resources with IAM roles, managing access control lists, and tagging resources with LF tags.
src/main/java/io/github/hectorvent/floci/services/lakeformation · high confidence
Introduce Lambda Durable Functions execution engine
Adds the backend implementation for Lambda Durable Functions, enabling long-running, checkpointed workflows within the emulator. This includes a new REST API under the \/2025-12-01\ prefix for managing durable executions (start, checkpoint, state, history, stop, and list), a background sweeper to fire persisted timers and step retries, and the core service logic to handle operation updates, chained invokes, and callback timeouts.
src/main/java/io/github/hectorvent/floci/services/lambda/durable · high confidence
Introduce Lambda Web Functions service
Adds the control plane and data plane for Lambda Web Functions, including a REST API for managing functions, revisions, and endpoints, alongside runtime support for Node.js environments, IAM authentication, and AWS-compatible error responses.
src/main/java/io/github/hectorvent/floci/services/lambdaweb · high confidence
Introduce Managed Service for Apache Flink (Kinesis Analytics V2) emulation
This change adds support for the Kinesis Analytics V2 API, allowing users to create, describe, start, stop, update, and delete Managed Service for Apache Flink applications within the emulator. The implementation includes a new JSON handler for the \application/x-amz-json-1.1\ protocol, a service layer that manages application state and delegates container lifecycle to \FlinkContainerManager\, and a runtime catalog (\KinesisAnalyticsRuntimes\) that maps AWS runtime environments (e.g., \FLINK-1\_18\, \FLINK-2\_3\) to specific pinned Docker images. Applications are isolated by account and region, and the service supports features like application snapshots, environment properties, and parallelism configuration.
src/main/java/io/github/hectorvent/floci/services/kinesisanalytics · high confidence
Introduce MemoryDB container management with graceful Docker-unavailable handling
Added MemoryDbContainerHandle and MemoryDbContainerManager to manage the lifecycle of MemoryDB backend Docker containers. The manager now gracefully degrades when no Docker daemon is reachable, allowing metadata operations to continue without crashing, and cleans up containers by ID on readiness-timeout rollback.
src/main/java/io/github/hectorvent/floci/services/memorydb/container · high confidence
Introduce MemoryDB service with cluster, user, and ACL management
Added a new MemoryDB emulator service that supports creating, describing, updating, and deleting clusters, users, and Access Control Lists (ACLs). The service implements AWS-like authentication models where users are defined with specific auth modes (password or IAM) and attached to ACLs, which are then referenced by clusters. It includes support for tagging resources and operates in a mock mode that bypasses container requirements, allowing for testing without a Docker daemon.
src/main/java/io/github/hectorvent/floci/services/memorydb · high confidence
Introduce Neptune graph database emulation support
Added new \NeptuneQueryHandler\ and \NeptuneService\ components to emulate Amazon Neptune operations, including cluster and instance lifecycle management (create, describe, delete, modify), IAM authentication, role associations, and tagging. The service supports both Gremlin and Neo4j backends via configuration, handles resource isolation by account and region, and ensures robust cleanup by rolling back proxy ports and containers if provisioning fails.
src/main/java/io/github/hectorvent/floci/services/neptune · high confidence
Introduce Network Firewall service emulation
Added a new mock implementation for AWS Network Firewall, including the \NetworkFirewallService\ for managing rule groups, firewall policies, and firewalls, and the \NetworkFirewallJsonHandler\ to route API actions. This enables users to create, describe, update, delete, and list Network Firewall resources within the local environment.
src/main/java/io/github/hectorvent/floci/services/networkfirewall · high confidence
Introduce Redshift container lifecycle management
Added RedshiftContainerManager and RedshiftContainerHandle to the service layer, enabling the system to start, adopt, and stop Docker containers that emulate Redshift clusters. This change introduces logic to manage container lifecycles, including adopting existing containers to preserve data across restarts and bootstrapping the cluster with a default database and catalog.
src/main/java/io/github/hectorvent/floci/services/redshift/container · high confidence
Introduce S3 Vectors service implementation
Added the S3 Vectors service layer, including the REST controller, business logic, and data models, to support vector storage and retrieval. The implementation provides endpoints for managing vector buckets and indexes, storing vector data with associated metadata, and querying vectors using cosine or euclidean distance metrics. It also includes a metadata filter engine that allows filtering vector results based on field values, logical operators (AND/OR), and comparison operators.
src/main/java/io/github/hectorvent/floci/services/s3vectors · high confidence
Introduce SageMaker emulator with Docker-backed training and GPU support
The SageMaker service now emulates AWS SageMaker APIs using Docker containers for both training jobs and inference endpoints. Training jobs run as isolated containers that pull specified images, execute training logic, and upload artifacts to S3, while endpoints are backed by running containers that proxy invocations. The emulator now supports GPU-backed training jobs by resolving instance types against a catalog and mapping them to host GPU devices via CDI, device IDs, or count modes, failing explicitly if hardware cannot be provided. State resets now correctly restore worker pools via afterReset() to ensure background work continues, and lifecycle management ensures containers are properly torn down and cleaned up.
src/main/java/io/github/hectorvent/floci/services/sagemaker · high confidence
Introduce Service Quotas API emulation
Adds a new Service Quotas emulation layer that supports listing and retrieving service quotas, including AWS default values, and requesting quota increases. The implementation provides a curated set of real AWS quota codes for specific services (such as CodeBuild, Lambda, EC2, and VPC) alongside a deterministic generic quota set for other services. It also introduces a history lookup for requested quota changes, allowing users to track the status of their increase requests within the emulator.
src/main/java/io/github/hectorvent/floci/services/servicequotas · high confidence
Introduce dedicated compatibility test suite for Floci
Adds a new \compatibility-tests\ directory containing a comprehensive test suite to verify that standard AWS tooling (Python, TypeScript, Java, Go SDKs, AWS CLI, CDK, Terraform, and OpenTofu) works correctly against the Floci emulator without modification. The suite includes a \justfile\ for orchestration, Dockerfiles for isolated execution, and Bats-based tests for CLI and IaC tools that generate JUnit XML reports, enabling developers to validate cross-tool compatibility locally and in CI.
compatibility-tests · high confidence
Introduce floci-aws landing page with dashboard and theme toggle
A new landing page (index.html) is now served at the UI root, providing a dashboard view for the local AWS emulator. This page includes a built-in wait view for when the Floci UI console is launching, and supports both light and dark themes with a toggle button that respects OS preferences and local storage.
src/main/resources/ui · high confidence
Introduce in-memory Glue Schema Registry service
Added a new \GlueSchemaRegistryService\ and supporting model classes (\Registry\, \Schema\, \SchemaVersion\, etc.) that provide an in-memory implementation of the AWS Glue Schema Registry API. This service supports creating, updating, and deleting registries and schemas, managing schema versions, and validating schema definitions for Avro, JSON, and Protobuf formats using the Apicurio library. It also includes a \SchemaToColumnsConverter\ to translate registered schemas into Glue Catalog column definitions.
src/main/java/io/github/hectorvent/floci/services/glue/schemaregistry · high confidence
Introduces AWS Transfer Family management-plane API emulation
This change adds a new service layer for emulating the AWS Transfer Family management API. The \TransferHandler\ exposes REST endpoints for creating, describing, updating, starting, stopping, and deleting SFTP servers, as well as managing associated users, SSH public keys, and resource tags. The underlying \TransferService\ implements the business logic, storing server and user data in account-scoped JSON files to support multi-tenancy, and enforces state transitions (e.g., allowing server deletion in any state) consistent with the AWS API specification.
src/main/java/io/github/hectorvent/floci/services/transfer · high confidence
Introduces extensible DNS resolution architecture with forwarding and record sources
The embedded DNS server now supports a pluggable architecture for resolving queries, allowing it to consult external sources before performing its own resolution or forwarding. Three new components are introduced in the common DNS package: \DnsRecordSource\ allows services owning private DNS zones to provide A records directly; \DnsForwardingRuleSource\ enables the registration of ECS tasks in specific DNS namespaces by providing forwarding rules per VPC/account/region; and \DnsLookupHelper\ handles the resolution of external hostnames to IPv4 addresses using upstream DNS servers with fallback to system name resolution. This change decouples the DNS server from specific service implementations via CDI, enabling features like private hosted zone record resolution and ECS task registration in DNS namespaces.
src/main/java/io/github/hectorvent/floci/core/common/dns · high confidence
Introduces multi-account routing and partition-aware infrastructure
Floci now supports multi-account isolation by resolving the caller's account ID from SigV4 Authorization headers and presigned URL credentials, using a 12-digit access key ID as the account ID to match LocalStack conventions. It also introduces a vendored AWS partition catalog (derived from botocore) to correctly handle ARN minting, region-to-partition resolution, and DNS suffix matching across commercial, China, GovCloud, and ISO partitions. Additionally, a new AI mock configuration loader allows users to provide custom JSON responses for stubbed AI services (Textract, Comprehend, Rekognition, Translate) via a file that is re-read on change without restarting the emulator.
floci · high confidence
Lambda concurrency enforcement and asynchronous invocation destinations
The Lambda service now enforces per-function reserved and per-region unreserved concurrency limits, rejecting invocations that exceed the configured quotas. It also delivers asynchronous invocation results to configured OnSuccess/OnFailure destinations (EventBridge, SQS, SNS, or Lambda) and to a Dead-Letter Queue on failure, constructing the standard AWS invocation record envelope for each delivery.
src/main/java/io/github/hectorvent/floci/services/lambda · high confidence
Lambda execution environment now supports Kubernetes and configurable Docker flags
Floci can now run Lambda functions as Kubernetes pods instead of Docker containers, selected via the \floci.services.lambda.executor\ configuration. The launcher also accepts custom Docker flags (such as environment variables, volumes, ports, and network settings) through a new \LambdaDockerFlags\ parser, and introduces a dedicated \LambdaExitWatcher\ to reliably report container exit codes and runtime errors instead of generic timeouts.
src/main/java/io/github/hectorvent/floci/services/lambda/launcher · high confidence
Major expansion of RDS API coverage and service architecture
The RDS service handler and core logic have been significantly expanded to support a much broader set of AWS RDS operations. The query handler now routes dozens of new actions, including DB instance and cluster lifecycle management (stop, start, reboot), read replica operations (create, promote, switchover), global cluster management, DB proxy configuration, and extensive snapshot and parameter group handling. The underlying service layer has been refactored to integrate with other services like EC2, KMS, and Secrets Manager, and now supports persistent storage for a wider variety of resource types including proxies, global clusters, and event subscriptions.
src/main/java/io/github/hectorvent/floci/services/rds · high confidence
MemoryDB cluster authentication via ACL-based proxy
A new TCP authentication proxy for AWS MemoryDB clusters has been introduced, allowing users to connect to MemoryDB with credential validation. The proxy, implemented in MemoryDbAuthProxy, extends shared Redis authentication logic and delegates credential checks to an AuthValidator that supports both password and IAM users against the cluster's ACL. A MemoryDbProxyManager handles the lifecycle of these proxies, enabling or disabling authentication per cluster based on its ACL configuration (e.g., open-access clusters bypass auth).
src/main/java/io/github/hectorvent/floci/services/memorydb/proxy · high confidence
Native Kubernetes Lambda executor with EKS token minting
Floci now supports running Lambda functions as Kubernetes pods instead of only Docker containers. This new executor launches pods that download code via an init container, connects to the Runtime API, and streams logs to CloudWatch. It replaces the previous fabric8 Kubernetes client dependency with a lightweight, native REST client using the JDK HttpClient, reducing native image footprint. For EKS clusters, it natively mints EKS bearer tokens (mimicking aws eks get-token) to authenticate with the cluster API without requiring the AWS CLI or external exec plugins.
src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes · high confidence
New CloudFormation provisioners for API Gateway and ACM resources
The CloudFormation emulator now supports provisioning several AWS resource types through dedicated provisioners. This includes AWS::CertificateManager::Certificate (AcmCfnProvisioner), which handles certificate issuance, replacement on create-only property changes, and in-place updates for transparency logging. Additionally, API Gateway resources are now provisioned via ApiGatewayAccountCfnProvisioner (for CloudWatch role configuration), ApiGatewayApiKeyCfnProvisioner (with in-place updates for enabled/description/tags and replacement for name/value changes), ApiGatewayDomainCfnProvisioner (handling custom domains and base path mappings), ApiGatewayGatewayResponseCfnProvisioner (for REST API error response customizations), ApiGatewayRestApiCfnProvisioner (covering the core REST API family: RestApi, Resource, Method, Deployment, Stage, and Authorizer), and ApiGatewayUsagePlanCfnProvisioner (managing usage plans and their keys). These changes enable users to define and manage these specific resources within CloudFormation templates.
src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners · high confidence
New CloudWatch Logs capabilities: cross-account policies, metric filters, and Logs Insights
This update introduces several new CloudWatch Logs features. It adds support for cross-account resource policies, allowing you to manage destinations and account-level policies (such as data protection and subscription filter policies) via the new CloudWatchLogsCrossAccountService. It also implements the full metric filter lifecycle (Put, Describe, Delete, Test), enabling you to extract metrics from log events and publish them to CloudWatch Metrics, including support for system field dimensions and field selection criteria. Additionally, a minimal Logs Insights query engine is added, supporting fields, filter, sort, dedup, and limit commands, while explicitly failing queries with unsupported syntax rather than silently dropping them.
src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs · high confidence
New CodeBuild emulator implementation with persistent state and Docker-based execution
The CodeBuild service now features a complete, new implementation that executes builds in Docker containers. This includes a new JSON API handler (\CodeBuildJsonHandler\) supporting full CRUD operations for projects, report groups, and source credentials, as well as build lifecycle actions like start, stop, and retry. The \CodeBuildRunner\ orchestrates the actual build execution by parsing buildspec files (YAML/JSON) and running phases in isolated containers. Additionally, the \CodeBuildService\ introduces persistent storage for projects, report groups, source credentials, and build counters, ensuring that state survives emulator restarts.
src/main/java/io/github/hectorvent/floci/services/codebuild · high confidence
New Cognito authentication, federation, and managed login components
Added core implementation files for the Cognito service, including CognitoAuthFlowHandler for managing authentication flows (USER\_PASSWORD\_AUTH, USER\_SRP\_AUTH, REFRESH\_TOKEN\_AUTH, CUSTOM\_AUTH, USER\_AUTH), CognitoCustomDomainFilter for routing custom domain requests, CognitoFederationService and CognitoFederationStateStore for handling OIDC federation flows, CognitoManagedLoginService for managing browser sessions and authorization codes, CognitoOAuthController for OAuth2/OIDC endpoints, CognitoOidcClient for external identity provider communication, and CognitoSrpHelper for SRP-6a cryptographic operations.
src/main/java/io/github/hectorvent/floci/services/cognito · high confidence
New Docker container management and reliability infrastructure
This change introduces a new set of core components in the Docker module to improve container lifecycle management and system reliability. A fluent ContainerBuilder is added to simplify the creation of container specifications with support for GPU requests, log rotation, and network resolution. To handle transient Docker daemon failures during high-load operations, a DockerRetry mechanism with exponential backoff and a RetryingTarCopier for robust file transfers are implemented. Additionally, a ContainerDetector provides accurate detection of the host environment (Docker, Podman, etc.), and a ContainerReachableEndpoint ensures launched containers can correctly resolve the Floci service URL.
src/main/java/io/github/hectorvent/floci/core/common/docker · high confidence
New Dockerfile variants and LocalStack compatibility layer
The docker directory now includes a complete set of Dockerfiles (Dockerfile, Dockerfile.native, Dockerfile.compat, Dockerfile.jvm-package, Dockerfile.native-package) and supporting scripts (entrypoint.sh, localstack-parity.sh, healthcheck.sh) that establish a drop-in LocalStack compatibility mode. The entrypoint script handles privilege dropping, Docker socket group resolution, and state directory ownership, while localstack-parity.sh maps LocalStack environment variables (such as EDGE\_PORT, PERSISTENCE, and GATEWAY\_LISTEN) to Floci equivalents. The compat image installs AWS CLI v2 to ensure AWS\_ENDPOINT\_URL is honored correctly, and the JVM and native images are built on UBI 9.8 and Eclipse Temurin 25, with the compat image providing pre-installed boto3 and awslocal for seamless integration with existing LocalStack tooling.
docker · high confidence
New ECR registry management and data-plane components
Added EcrGcController, EcrRegistryDataPlane, EcrRegistryManager, and RegistryHttpClient to src/main/java/io/github/hectorvent/floci/services/ecr/registry. EcrRegistryManager now orchestrates the shared registry:2 container lifecycle, including lazy start, port allocation, and storage management. EcrRegistryDataPlane proxies OCI Distribution traffic to enforce ECR repository policies and supports immutable image tags. EcrGcController exposes an admin endpoint to trigger garbage collection on the backing registry container. RegistryHttpClient provides a thin wrapper for the Docker Registry HTTP API v2 to enumerate tags, fetch manifests, and delete images.
src/main/java/io/github/hectorvent/floci/services/ecr/registry · high confidence
New Glue data model classes for connections, crawlers, and jobs
Added a comprehensive set of Java model classes in the glue service to represent AWS Glue Data Catalog resources, including Connection, ConnectionInput, and AuthenticationConfiguration for managing data source connections and their credentials; Crawler, CreateCrawlerRequest, and CrawlerTargets for defining and configuring crawlers with support for various target types (S3, JDBC, Delta, etc.); and CreateJobRequest, CreateJobResponse, and DeleteJobRequest for job lifecycle management. These models also include supporting structures for Data Catalog encryption settings, classifiers, and column definitions, enabling the service to properly serialize and deserialize Glue API requests and responses.
src/main/java/io/github/hectorvent/floci/services/glue/model · high confidence
New RDS data models for Aurora and proxy resources
The RDS service layer now includes model classes for Aurora custom cluster endpoints (DbClusterEndpoint), DB cluster snapshots (DbClusterSnapshot), DB cluster parameter groups (DbClusterParameterGroup), and DB proxies with their authentication and target groups (DbProxy, DbProxyAuth, DbProxyTarget, DbProxyTargetGroup). Additionally, new records handle DB instance scaling changes (DbInstanceScalingChanges) and instance settings (DbInstanceSettings), while existing models for DB snapshots (DbSnapshot), subnet groups (DbSubnetGroup), event subscriptions (EventSubscription), and global clusters (GlobalCluster) are also present to support the broader RDS feature set.
src/main/java/io/github/hectorvent/floci/services/rds/model · high confidence
New Security Admin API endpoint for listing organization admin accounts
A new \SecurityAdminController\ has been added to expose a \GET /admin\ endpoint that allows users to list organization admin accounts. The endpoint routes requests based on the AWS service context: for \macie2\, it delegates to the Macie controller, while for \guardduty\ (or when unspecified), it retrieves admin accounts via the GuardDuty service and returns them as a JSON array. This provides a unified entry point for managing security admin configurations across supported AWS services.
src/main/java/io/github/hectorvent/floci/services/securityadmin · high confidence
New branded styling for the sign-in consent flow
A new CSS stylesheet has been added for the sign-in consent page, introducing a branded visual design with a purple and orange color scheme, a centered card layout, and specific styling for brand logos, verification codes, and action buttons.
src/main/resources/META-INF/resources · high confidence
New lifecycle management endpoints and UI sidecar integration
The emulator now exposes a comprehensive set of REST endpoints for managing its state and monitoring its health. Users can check the startup progress and initialization script results via the new \/init\ endpoint, view version and configuration details at \/info\, and trigger state resets or nukes via \/state/reset\ and \/state/nuke\. A dedicated \/health\ endpoint provides service status, while \/ca.pem\ serves the necessary TLS certificate bundle for clients to trust the emulator's HTTPS endpoint. Additionally, a new UI sidecar can be launched via \/\_floci/ui\, which polls a status endpoint to redirect the browser once the console is ready.
src/main/java/io/github/hectorvent/floci/lifecycle · high confidence
New shared VTL utility library for AppSync resolvers
Added a new set of Java utility classes in the \appsync.graphql.util\ package to support VTL (Velocity Template Language) resolvers. This includes \AppSyncUtil\ as the main entry point, along with specialized helpers for DynamoDB type conversion (\DynamoDbUtil\), list and map manipulation (\ListUtil\, \MapUtil\), string and time formatting (\StrUtil\, \TimeUtil\), math operations (\MathUtil\), and query/subscription transformation (\TransformUtil\). These utilities provide a consistent API for common resolver tasks like JSON parsing, error handling, and data transformation, replacing the need for inline VTL logic or scattered helper methods.
src/main/java/io/github/hectorvent/floci/services/appsync/graphql/util · high confidence
New verification code subsystem for Cognito user pools
This change introduces a new verification code subsystem within the Cognito service, adding classes to generate, persist, and validate verification codes for user pool operations such as sign-up confirmation, password reset, MFA, and attribute verification. The system stores hashed codes with per-code salts to prevent exposure from storage dumps, enforces rate-limiting and attempt limits, and supports dispatching codes via SES (email) or SNS (SMS) with configurable templates and sender addresses. It also handles custom message overrides from Lambda triggers and ensures codes are properly invalidated or retained based on their purpose.
src/main/java/io/github/hectorvent/floci/services/cognito/verification · high confidence
Optional DynamoDB Local backend for emulation
Users can now configure the DynamoDB emulator to run against an external DynamoDB Local instance instead of the default in-process native engine. By setting the backend selection to 'local' and providing a local endpoint, all DynamoDB and DynamoDB Streams operations are forwarded via signed HTTP requests, with account-scoped isolation and tag persistence handled by the emulator. Stream checkpoint lifetimes are automatically adjusted to persist across process restarts when using the local backend, and TTL deletion events are correctly mapped to match AWS behavior.
src/main/java/io/github/hectorvent/floci/services/dynamodb/backend · high confidence
Persistent CodeDeploy state and on-premises instance management
The CodeDeploy service now persists applications, deployment groups, deployment configs, tags, and on-premises instances to storage, ensuring these resources survive restarts. It also introduces full management capabilities for on-premises instances, including registration, deregistration, and tagging, alongside the standard lifecycle for applications, deployment groups, and configs.
src/main/java/io/github/hectorvent/floci/services/codedeploy · high confidence
RDS proxy now enforces TLS, IAM token binding, and connection limits
The RDS proxy now terminates TLS for client connections using a persistent, self-signed CA certificate that automatically expands its Subject Alternative Names to cover new advertised hosts, ensuring clients can use sslmode=verify-full across restarts. IAM authentication is hardened by binding tokens to the specific proxy endpoint (host, port, region) and enforcing the rds-db:connect permission, while connection limits and timeouts are applied to prevent backend resource exhaustion. The proxy also supports dynamic updates to master passwords and IAM settings without restarting, and correctly handles MySQL TLS upgrades and PostgreSQL startup parameter forwarding.
src/main/java/io/github/hectorvent/floci/services/rds/proxy · high confidence
Real Docker-backed VPC networking with accurate private IP addressing
VPCs are now backed by real Docker networks in RFC 1918 space, ensuring that EC2 instance private addresses are routable and actually connectable rather than being simulated numbers. A new Cidr4 utility handles CIDR arithmetic to validate that subnet blocks sit within their VPC, detect collisions with existing Docker networks, and enforce IPv4 CIDR restrictions. The VpcNetworkManager creates one Docker network per VPC (not per subnet) to preserve AWS routing semantics while reducing Linux bridge overhead, and it substitutes declared CIDRs with allocated blocks only when necessary, logging the change to avoid silent address mismatches.
src/main/java/io/github/hectorvent/floci/services/ec2/net · high confidence
Redshift Serverless: new admin actions and custom domain/endpoint access services
This change introduces a new \RedshiftServerlessAdminJsonHandler\ that exposes metadata-only operations for resource policies, endpoint access, custom domain associations, snapshot copy configurations, scheduled actions, and reservation reads. It also adds dedicated services (\RedshiftServerlessCustomDomainService\, \RedshiftServerlessEndpointAccessService\, \RedshiftServerlessResourcePolicyService\, etc.) to store and manage these associations, including validation of endpoint names and workgroup ownership checks. The main handler now delegates unknown actions to this admin handler, and request constraints are validated against the AWS model via \RedshiftServerlessRequestShapes\ before dispatch.
src/main/java/io/github/hectorvent/floci/services/redshiftserverless · high confidence
Redshift emulator adds IAM database authentication, DynamoDB zero-ETL replication, and cluster ordering options
The Redshift emulator now supports IAM database authentication via GetClusterCredentials and GetClusterCredentialsWithIAM, allowing users to connect using IAM identities instead of static passwords. It also introduces DynamoDB zero-ETL replication, enabling automatic data synchronization from DynamoDB streams to Redshift landing tables. Additionally, the emulator now exposes DescribeOrderableClusterOptions, providing a list of valid cluster types and node types for IaC providers to validate before cluster creation.
src/main/java/io/github/hectorvent/floci/services/redshift · high confidence
Redshift model layer expanded to support zero-ETL, snapshots, and auth proxy
The Redshift service model now includes new data classes for zero-ETL integrations (Integration), cluster snapshots (Snapshot), snapshot copy grants (SnapshotCopyGrant), and parameter groups (ClusterParameterGroup). The Cluster model has been enriched with fields for IAM role authorization, S3 logging destinations, and internal auth proxy wiring (container host/port and proxy port), while also supporting master password secrets via KMS. These changes provide the data structures required for the new replication, snapshot, and authentication proxy capabilities.
src/main/java/io/github/hectorvent/floci/services/redshift/model · high confidence
Redshift proxy adds Extended Query protocol support for S3 COPY/UNLOAD and Spectrum queries
The Redshift proxy now handles the PostgreSQL Extended Query protocol (Parse/Bind/Execute) for S3 data operations and Spectrum queries. This introduces a new BackendResponseCoordinator to manage pipelined operations and error recovery, allowing clients to queue multiple statements before a Sync. Specific handlers include ExtendedS3Exchange for executing COPY FROM/TO S3 and UNLOAD operations, ExtendedSpectrumExchange for running Spectrum SELECTs with row buffering via PortalCursor, and supporting classes like CopyStatementParser, CopyRecordTransformer, JsonLinesToCsvConverter, and ManifestReader to parse and transform data during these Extended Query executions.
src/main/java/io/github/hectorvent/floci/services/redshift/proxy · high confidence
Route 53 Resolver emulation with DNS forwarding and tagging support
The emulator now supports the Route 53 Resolver service, enabling users to manage DNS Firewall domain lists, resolver endpoints, and resolver rules. This includes creating and listing firewall domain lists (both AWS-managed and custom), managing resolver endpoints and their IP addresses, and associating resolver rules with VPCs. Crucially, resolver rules are now applied to the embedded DNS server, allowing DNS queries to be forwarded to specified targets based on the configured rules. The service also supports tagging resources via TagResource, UntagResource, and ListTagsForResource operations.
src/main/java/io/github/hectorvent/floci/services/route53resolver · high confidence
Route 53 management-plane emulation and private zone DNS resolution
The application now includes a new Route 53 management-plane emulation, exposing a REST API (Route53Controller) for creating, updating, and deleting hosted zones, managing resource records, and handling VPC associations. Additionally, private hosted zone records are now resolvable from within cluster containers via the embedded DNS server (Route53DnsRecordSource), allowing internal services to look up records defined in Route 53 private zones as if they were standard DNS entries.
src/main/java/io/github/hectorvent/floci/services/route53 · high confidence
S3 service receives foundational streaming, security, and configuration components
The S3 service implementation gains several new core classes to improve reliability and security. Streaming upload support is added via AwsChunkedInputStream, which decodes aws-chunked bodies on the fly to prevent holding entire uploads in memory, and CopyRangeInputStream, which handles range-based copy-source reads. Security is hardened with S3HeaderSignatureFilter, which verifies SigV4 signatures on the Authorization header when authentication enforcement is enabled, and S3AclPublicAccessEvaluator, which evaluates ACLs against Block Public Access settings. Additionally, new configuration models (S3AnalyticsConfiguration, S3IntelligentTieringConfiguration, S3BlockPublicAccessSettings) and an S3 Control controller (S3ControlController) are introduced to support bucket analytics, intelligent tiering, account-level public access block management, and Terraform-compatible S3 Control API endpoints.
src/main/java/io/github/hectorvent/floci/services/s3 · high confidence
SES v2 account, configuration set, and contact list management endpoints
This change introduces the REST JSON controllers and domain services for SES v2 account settings, configuration sets, and contact lists. Users can now manage account-level sending status, Virtual Deliverability Manager (VDM) attributes, and provisioning details via the account endpoints, create and update configuration sets with options for suppression, tracking, delivery, and VDM, and perform full CRUD operations on contact lists including topics and preferences. The implementation includes strict validation for address lengths, configuration set names, and account details, ensuring behavior aligns with AWS SES v2 specifications.
src/main/java/io/github/hectorvent/floci/services/ses · high confidence
SNS inspection endpoints and mobile push delivery support
Added REST inspection endpoints for SMS and mobile push notifications to allow test verification of sent messages. The new \SnsInspectionController\ exposes \GET /\_aws/sns\ to list, filter, and clear SMS messages, and \GET /\_aws/sns/push-notifications\ to inspect captured push notifications for APNS and FCM. The \SnsMessageSigner\ now signs SNS deliveries with a self-signed RSA certificate, serving the certificate at \/\_aws/sns/SimpleNotificationService-\<fingerprint\>.pem\ for signature verification. Additionally, the service now supports creating and managing platform applications and endpoints, enabling the mocking of mobile push delivery flows.
src/main/java/io/github/hectorvent/floci/services/sns · high confidence
SQS emulator core rewritten with thread-safe message handling and expanded API support
The SQS service implementation has been significantly refactored to improve correctness and feature parity. A new \GuardedMessageQueue\ class ensures thread-safe, atomic message operations using \ReentrantLock\, while \ReceiptHandle\ now uses HMAC-SHA256 signatures to prevent tampering. The service now supports additional AWS SQS actions including \AddPermission\, \RemovePermission\, and \CancelMessageMoveTask\, and correctly handles binary message attributes and the \AWSTraceHeader\ system attribute. Message retention is now enforced by a background \SqsRetentionSweeper\, and a new \SqsInspectionController\ provides a LocalStack-compatible endpoint for peeking at queue contents during testing.
src/main/java/io/github/hectorvent/floci/services/sqs · high confidence
SSM Run Command support for direct container execution
The SSM service now supports the Run Command workflow (SendCommand, GetCommandInvocation, etc.) for instances backed by running Docker containers. When a command targets such an instance, the emulator executes the script directly inside the container via Docker exec, using virtual threads for concurrency and a bounded output collector to cap stdout/stderr memory usage. For instances not backed by a container, the system falls back to the standard SSM agent polling flow, and warns users when an SSM-managed instance lacks a corresponding EC2 container.
src/main/java/io/github/hectorvent/floci/services/ssm · high confidence
Secrets Manager adds scheduled rotation, random password generation, and resource policy validation
The Secrets Manager service now supports automatic secret rotation via a background scheduler that triggers rotations based on configured schedules, ensuring secrets are rotated without manual intervention. A new RandomPasswordGenerator enables the GetRandomPassword API and CloudFormation GenerateSecretString to create secure, random passwords with customizable character sets and lengths. Additionally, the service introduces resource policy validation through ValidateResourcePolicy, which checks for overly permissive wildcard principals, and implements several missing APIs including BatchGetSecretValue, UpdateSecretVersionStage, and RestoreSecret to improve compatibility and operational flexibility.
src/main/java/io/github/hectorvent/floci/services/secretsmanager · high confidence
Store and serve CloudWatch metric stream definitions
Floci now persists CloudWatch metric stream metadata (name, ARN, Firehose target, output format, filters, and state) in local storage and exposes it via the service layer. Users can create, update, retrieve, list, start, and stop metric stream definitions; the system validates required fields and supported output formats (json, opentelemetry0.7, opentelemetry1.0) and enforces that include and exclude filters are not used together. Note that Floci stores only the definition and state—it does not deliver metric data to the configured Firehose delivery stream.
src/main/java/io/github/hectorvent/floci/services/cloudwatch/metricstreams · high confidence
Support LocalStack-compatible execute-api URL formats and custom domain routing
Users can now invoke API Gateway REST APIs using LocalStack-compatible URL prefixes (\_aws/execute-api and \_user\request\) and custom domain names. The new ApiGatewayAwsExecuteController and ApiGatewayUserRequestController handle these alternative paths, while the ApiGatewayCustomDomainFilter resolves base path mappings to rewrite requests to the standard execute-api format. Additionally, the ApiGatewayExecuteApiHostFilter ensures correct routing for execute-api hostnames, and the ApiGatewayExecuteResponseFilter provides standard AWS request IDs in responses.
src/main/java/io/github/hectorvent/floci/services/apigateway · high confidence
Support for APPSYNC\_JS resolver execution via a Node sidecar
The AppSync emulator now supports JavaScript-based resolvers (APPSYNC\_JS) by executing them in a long-lived Node.js sidecar container. This change introduces the \AppSyncJsRuntime\ interface and its \NodeAppSyncJsRuntime\ implementation, which manages the lifecycle of a Node 22 Alpine container to evaluate resolver code. The sidecar is started lazily on the first request and reused for subsequent evaluations to minimize boot overhead. Resolver code is passed to the sidecar via HTTP, and the result—including data, errors, stash state, and early return flags—is returned to the Java pipeline. The feature is controlled by configuration properties (\floci.services.appsync.js-runtime.enabled\, etc.) and can also connect to an externally provided Node server URL.
src/main/java/io/github/hectorvent/floci/services/appsync/graphql/js · high confidence
Support for AWS IoT SQL subset in topic rules
The IoT rules engine now evaluates a subset of the AWS IoT SQL dialect for topic rules. This allows users to write SELECT, FROM, and WHERE clauses in their rule statements to filter messages and project specific fields. The implementation includes a parser and evaluator that support standard comparisons, logical operators (AND, OR, NOT), the IN operator, array literals, and specific functions like isNull, isUndefined, topic, clientid, timestamp, accountid, newuuid, startswith, and endswith. Messages that do not match the WHERE clause are dropped, and the payload passed to actions is transformed according to the SELECT projection, preserving the original payload if only \* is selected without a WHERE clause.
src/main/java/io/github/hectorvent/floci/services/iot/rules · high confidence
Support for Glue job and crawler run lifecycles with conditional trigger chaining
The Glue emulator now simulates the execution of jobs and crawlers through dedicated run services that manage state transitions (e.g., RUNNING to SUCCEEDED) and enforce configurable run durations. These services expose completion events that are consumed by the new trigger service, enabling CONDITIONAL triggers to fire based on run outcomes and supporting chained workflows where one run initiates subsequent jobs or crawlers. The JSON handler routes run-related API actions to these services and ensures triggers are evaluated after state changes, while the table resolver provides the read-plan logic required for Athena and Redshift to interpret Glue table metadata.
src/main/java/io/github/hectorvent/floci/services/glue · high confidence
Support for Kafka sources in EventBridge Pipes
EventBridge Pipes now support Kafka topics as source connectors. This change replaces the previous embedded Kafka client library with a lightweight REST Proxy (Karapace) sidecar, allowing Floci to poll Kafka sources (both self-managed and MSK) over HTTP. The implementation includes a new REST-based consumer client, a manager to handle container lifecycle for the proxy, and DTOs for Kafka records and offsets, enabling pipes to consume, filter, and forward Kafka messages to targets.
src/main/java/io/github/hectorvent/floci/services/pipes · high confidence
Support for metric-math alarms, tagging, and DatapointsToAlarm in CloudWatch models
The CloudWatch metrics models have been updated to support more complex alarm configurations and metadata. MetricAlarm now includes a metrics list to define metric-math queries (via the new AlarmMetricDataQuery model), allowing alarms to be based on expressions rather than single metrics. The DatapointsToAlarm field is now nullable to accurately reflect AWS API responses where this field is omitted if not set, preventing drift in client plans. Additionally, MetricAlarm now supports tags and a region field, enabling proper tagging of alarms and ensuring background evaluators know which region to query. MetricDatum also includes a new factory method for easier creation of metric data points.
src/main/java/io/github/hectorvent/floci/services/cloudwatch/metrics/model · high confidence
Support for querying AWS Glue external tables via Redshift Spectrum
Users can now define and query external tables backed by AWS Glue catalogs through Redshift Spectrum. This update introduces the ability to create external schemas and tables (supporting Parquet, JSON, and TextFile formats) via SQL, with the system automatically mirroring Glue metadata into the Redshift catalog views. It includes a statement parser for external DDL, a materializer that loads data from S3 into a local cache for performance, and concurrency controls to ensure consistent reads while Glue metadata is being updated.
src/main/java/io/github/hectorvent/floci/services/redshift/spectrum · high confidence
Support for third-party web consoles via a standardized sidecar contract
Floci now allows any web console implementing the new console contract to run as its sidecar, rather than being limited to the built-in Floci UI. The system automatically resolves connection details (port, health-check path, and readiness fields) from the container image's labels, built-in profiles, or explicit configuration, enabling seamless integration of external consoles without manual setup. Additionally, the UI manager now provides a dedicated interstitial page to display startup progress and specific error messages when the console fails to start, improving the user experience during initialization.
src/main/java/io/github/hectorvent/floci/services/floci/ui · high confidence
Architecture
Refactor ElastiCache auth proxy to share Redis wire logic and delegate SigV4 validation
The ElastiCache TCP authentication proxy now extends the new AbstractRedisAuthProxy base class, consolidating shared RESP protocol handling, connection management, and relay logic previously duplicated in ElastiCacheAuthProxy. This change enables the proxy to support both the standard AUTH command and the HELLO AUTH handshake for protocol negotiation. Additionally, SigV4 token validation is delegated to the shared SigV4RequestValidator utility, which enforces that the username in the token matches the authenticated user, replacing the previous inline cryptographic implementation.
src/main/java/io/github/hectorvent/floci/services/elasticache/proxy · high confidence
Behavioural changes
Align Lambda Web runtime logging and initialization errors with AWS behavior
The Lambdaweb runtime now formats console output into JSON log events that match AWS Lambda's structure, including request and endpoint context, and filters output based on the AWS\_LAMBDA\_LOG\_LEVEL environment variable. Additionally, initialization failures are now reported with specific error types (Runtime.ImportCodeError or Application.InitCodeError) and written to a standard error file, mirroring AWS's native error reporting for better compatibility and debugging.
src/main/resources/lambdaweb · high confidence
AppSync JavaScript resolvers now execute via a Node sidecar
JavaScript resolvers for AppSync are no longer evaluated in-process within the native executable; instead, they are executed by a dedicated Node.js sidecar service. This change ensures that resolver code runs in a real Node environment, supporting native ES modules and import statements, while providing a local shim for the \@aws-appsync/utils\ library to maintain offline compatibility.
src/main/resources/appsync · high confidence
AppSync resolver execution moves to a Node sidecar with a Java callback interface
The GraphQL engine has been offloaded to a separate sidecar container, and this package now provides the Java-side infrastructure to handle resolver execution requests from that sidecar. A new REST endpoint at \/\_floci/appsync/resolve\ accepts invocation payloads, while \AppSyncResolverExecutor\ runs the actual VTL and JavaScript resolver logic (including pipeline stages and data source interactions) and returns results via \ResolverOutcome\. \ResolverCallbackSessions\ manages per-operation authentication tokens to secure these callbacks, and \AppSyncResolverError\ ensures that resolver-specific errors are formatted to match AppSync's native error structure.
src/main/java/io/github/hectorvent/floci/services/appsync/graphql/resolver · high confidence
Centralized tag management and improved AWS protocol compliance
This update introduces a shared tagging infrastructure via AbstractTagsController, consolidating tag operations (list, add, remove) for all services into a common dispatcher to ensure consistent behavior. It also enhances protocol compliance by adding the AccountContextFilter to correctly resolve account and region context from AWS credentials and presigned URLs, and the AwsCborContentTypeFilter to normalize CBOR content types for RPC v2 protocols. Additionally, the emulator now automatically injects AWS request ID headers (x-amz-request-id, x-amzn-RequestId) into all responses for SDK compatibility, standardizes AWS hostname generation across partitions, and fixes timestamp encoding in CBOR responses to match AWS conventions.
src/main/java/io/github/hectorvent/floci/core/common · high confidence
CloudWatch alarm evaluation, metric-math support, and new API operations
CloudWatch alarms are now actively evaluated by a background scheduler that queries metric data over a wider range to correctly handle missing datapoints and transitions, dispatching actions via a new extensible handler interface. Alarms now support metric-math expressions (storing and evaluating the query definitions) and the new GetMetricData API operation. The service also adds support for tagging resources (alarms, metrics), dashboards, and metric streams, along with the corresponding List/Tag/Untag and CRUD operations for these resources across both the JSON and Query protocols.
src/main/java/io/github/hectorvent/floci/services/cloudwatch/metrics · high confidence
Enhanced SigV4 signature verification and session token validation
The authentication module now enforces stricter validation for AWS SigV4 requests. It introduces support for verifying SigV4A (ECDSA-P256) signatures alongside the existing HMAC-SHA256 checks, ensuring compatibility with modern signing algorithms. Additionally, the system now validates that session tokens correctly correspond to the access key used in the request, rejecting long-term keys that carry session tokens and temporary keys that lack them or present mismatched tokens. Canonical request construction has also been refined to handle URI encoding variations and query string normalization more robustly.
src/main/java/io/github/hectorvent/floci/core/common/auth · high confidence
Introduce DSQL dialect support with transaction limits and IAM role mapping
Added a bootstrap SQL script that establishes the DSQL dialect on Aurora PostgreSQL clusters, enabling IAM role mapping via AWS IAM GRANT and enforcing specific transaction limits (such as restricting DDL/DML mixing and row counts) to align with DSQL's behavior.
src/main/resources/dsql · medium confidence
Kinesis model updates for concurrency, retention, and API support
The Kinesis data model now supports thread-safe record management and retention enforcement: KinesisShard uses a monitor lock to prevent data races when producers append records concurrently and introduces a pruneRecordsBefore method to drop expired records based on the stream's retention period, ensuring bounded memory usage. KinesisStream has been extended with fields to support new capabilities, including per-account isolation (accountId), configurable maximum record size (maxRecordSizeInKiB), enhanced monitoring metrics tracking, and enforcement of the 24-hour rolling limit on shard count updates via a timestamp history. Additionally, the shard list in KinesisStream now uses a CopyOnWriteArrayList for safer concurrent access, and model records are registered for native-image reflection.
src/main/java/io/github/hectorvent/floci/services/kinesis/model · high confidence
New configuration sources for TLS, host defaults, and LocalStack parity
The application now registers three new MicroProfile ConfigSource implementations (TlsConfigSource, HostDefaultsConfigSource, LocalStackParityConfigSource) and a ConfigSourceInterceptor (FlociConfigRelocationsInterceptor) via META-INF/services. This enables the system to load TLS settings, host-specific defaults, and LocalStack environment variable translations directly from the configuration layer rather than relying on entrypoint scripts or external mechanisms.
src/main/resources/META-INF/services · high confidence
Refactor ElastiCache container management and add Valkey cluster formation support
The ElastiCache container management layer has been refactored to use a new, higher-level Docker abstraction (ContainerBuilder, ContainerLifecycleManager, ContainerLogStreamer) replacing direct Docker client usage, which improves code reuse and testability. A new ElastiCacheMemcachedContainerManager has been added to handle Memcached backend lifecycle, including graceful degradation when the Docker daemon is unreachable. Additionally, a new ValkeyClusterFormation class enables the programmatic creation of Valkey clusters (MEET, slot assignment, replication) from individual nodes, and a shared RespLineReader utility supports RESP protocol parsing for readiness probes across both Memcached and MemoryDB managers.
src/main/java/io/github/hectorvent/floci/services/elasticache/container · high confidence
Refactored KMS key management by type-specific implementations
The KMS service logic has been restructured to handle different key types (Symmetric, HMAC, RSA, ECC, Ed25519, ML-DSA, SM2) through dedicated classes implementing the new \KmsKeyType\ interface. This change introduces specific handling for each algorithm, including support for importing RSA and ECC key material, generating keys for NIST and SECG curves, and managing SM2 keys exclusively in China regions. The refactoring isolates algorithm-specific logic, such as PSS signature parameters for RSA and Ed25519ph signing, into these new type-specific components.
src/main/java/io/github/hectorvent/floci/services/kms/keytype · high confidence
Secret model supports rotation, replication, and resource policies
The Secret model now exposes fields and getters/setters for rotation configuration (Lambda ARN, rules, dates), AWS-owned service indicators, resource policies, and cross-region replication status (including a helper to identify replicas). Additionally, the versions map is automatically wrapped in a ConcurrentHashMap to ensure thread-safe iteration during secret rotation without blocking read operations.
src/main/java/io/github/hectorvent/floci/services/secretsmanager/model · high confidence
Shared VTL utility functions for API Gateway and AppSync
A new common utility class, VtlUtilFunctions, has been introduced to centralize the implementation of AWS VTL $util functions that are identical across both API Gateway and AppSync. This class provides shared implementations for string escaping (matching $util.escapeJavaScript), URL encoding/decoding, Base64 encoding/decoding (supporting both string and byte inputs to match service-specific signatures), and JSON parsing. By consolidating these overlapping capabilities, the codebase eliminates duplicate maintenance efforts while allowing each service's specific wrapper to continue handling its own unique template dialect requirements.
src/main/java/io/github/hectorvent/floci/core/common/vtl · high confidence
TLS configuration and certificate management refactored into dedicated config classes
The TLS subsystem has been restructured into a set of dedicated configuration and management classes to improve certificate lifecycle handling and security. A new local root CA (FlociCertificateAuthority) is now persisted and automatically upgraded if key identifiers are missing, ensuring chain validity. Certificate metadata (CertificateMetadata) is persisted alongside certificates to detect configuration changes and trigger regeneration on restart. A new ContainerCaBundle class generates a trust bundle for launched containers, allowing them to trust Floci's HTTPS endpoints without manual configuration. Runtime certificate extension (TlsCertificateManager) now safely adds custom domain SANs while enforcing local suffix restrictions. Additionally, a config relocation interceptor (FlociConfigRelocationsInterceptor) ensures backward compatibility for moved configuration keys, and a network exposure guard (NetworkExposureGuard) enforces safe default binding by refusing non-loopback addresses unless explicitly allowed.
src/main/java/io/github/hectorvent/floci/config · high confidence
Fixes
DynamoDB validation and access path infrastructure
The DynamoDB service now includes a dedicated validation and access-path layer to enforce AWS-compatible constraints before operations execute. New classes handle access path resolution for tables and indexes (DynamoDbAccessPath), validate query key conditions and projections (DynamoDbAccessPathValidator), and enforce attribute value rules such as base64 encoding and nesting limits (DynamoDbAttributeValueValidator). Item size is now calculated and enforced against the 400KB limit (DynamoDbItemSize), numbers are validated and normalized within DynamoDB's range and precision (DynamoDbNumberUtils), and expression sizes are checked (DynamoDbExpressionSize). Additionally, IAM condition key extraction (DynamoDbConditionKeys) and a facade for backend access (DynamoDbFacade) provide the necessary context for fine-grained access control and consistent region/account scoping.
src/main/java/io/github/hectorvent/floci/services/dynamodb · high confidence
Expose build version via version.properties
A new version.properties file has been added to the filtered resources, mapping the application's version to the Maven project version. This ensures the build version is available as a resource property, which supports the fix to report the version when the FLOCI\_VERSION environment variable is unset.
src/main/resources-filtered · high confidence
Improved storage reliability with boot-time validation, deduplication, and WAL optimizations
The storage layer now validates that the persistent storage path is writable at boot, failing fast with a clear error if the directory is inaccessible rather than surfacing opaque 500s or silent data loss later. Storage backends are now deduplicated by resolved file path to prevent duplicate in-memory stores and state clobbering on shutdown, and each backend is loaded exactly once to avoid replaying state or opening multiple WAL writers. For append-heavy workloads, the Write-Ahead Log (WAL) storage now supports batched writes and skips unnecessary snapshot compactions when the store is idle, improving performance and durability. Additionally, unreadable persisted data files are quarantined to .corrupt siblings to make data loss visible instead of silently starting empty, and scan() operations return mutable lists to allow safe in-memory filtering.
src/main/java/io/github/hectorvent/floci/core/storage · high confidence
Lambda code storage now scopes by account and region, with atomic extraction and versioned code copies
The on-disk layout for extracted Lambda function code has changed from a flat function-name directory to a structure scoped by account and region (e.g., \<codePath\>/\<accountId\>/@regions/\<region\>/\<functionName\>), preventing collisions when different accounts use the same function name. Extraction is now atomic: packages are unpacked into a staging directory and swapped in place, ensuring that failed deployments do not leave partial or stale code on disk. Additionally, each published version of a function now receives its own isolated copy of the code, so publishing or deleting a version no longer affects the $LATEST deployment or other versions. The ZIP extractor also switched to reading via the central directory to correctly handle archives that use STORED entries with data descriptors, and it normalizes backslash separators in entry names to match AWS behavior.
src/main/java/io/github/hectorvent/floci/services/lambda/zip · high confidence
Seed AWS managed policy catalog for accurate IAM resolution
The IAM module now includes a local seed of the AWS managed policy catalog (managed-policies.yaml) and their corresponding default policy documents (managed-policy-documents.json). This allows the system to resolve standard AWS managed policy ARNs (e.g., arn:aws:iam::aws:policy/\*) against a known list, ensuring that valid AWS policies attach correctly and that typos or non-existent policies are rejected with a NoSuchEntity error, mirroring real AWS behavior.
src/main/resources/iam · high confidence
Step Functions ASL Choice state and JSONata engine improvements
The Step Functions engine now enforces stricter validation and type-strict evaluation for ASL Choice state rules, ensuring that malformed rules or undefined paths raise runtime errors rather than silently falling through. JSONata expression evaluation is now bounded by time (5 seconds), depth (100 levels), and memory (approx. 7MB) to prevent runaway executions, and top-level references that do not start with $states or a workflow variable are rejected at definition time. Additionally, the $formatNumber function now validates picture strings against XPath F&O rules, failing with specific error codes (e.g., D3086) for invalid formats instead of producing incorrect output.
src/main/java/io/github/hectorvent/floci/services/stepfunctions · high confidence
Test coverage
3454 commits adding/updating tests in src/test; Add CDK-based compatibility test stack for AWS services; Add Java SDK compatibility test fixtures; Add Python SDK compatibility test suite for Floci; Added CDK compatibility tests for AWS resource provisioning and endpoint handling; Added Node.js SDK compatibility tests for ACM, API Gateway, CloudFormation, CloudWatch, and Cognito; Added OpenTofu compatibility tests; Added SDK compatibility test utilities for AWS services; Added legacy SDK compatibility tests for DynamoDB and ELB; Expanded AWS CLI compatibility test coverage; Expanded Java SDK compatibility test coverage across AWS services; Expanded SDK compatibility test coverage for DynamoDB, CloudWatch, API Gateway, and ACM; Expanded Terraform compatibility test coverage for multiple AWS services; Go SDK compatibility tests added for ACM, CloudWatch, Cognito, DynamoDB, ECR, Glue, IAM, IoT, Kinesis, KMS, Lambda, Neptune, and Pipes.
Dependencies
Release 2.2.0: Quarkus 3.39.2 upgrade, SES SMTP relay, and dependency updates
The emulator is released as version 2.2.0, upgrading the Quarkus platform to 3.39.2 and adding support for the SES SMTP relay via new Vert.x mail and Apache MIME4J dependencies. The build also pins Jackson to 2.22.2, updates the Docker client to 3.7.1, and introduces json-path 3.0.0 for Step Functions JSONPath evaluation. Additionally, the release tooling now uses semantic-release 24.2.9, and compatibility test suites for Java, Node, and Python have been added with pinned AWS SDK versions.
(dependencies) · high confidence
Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 53 → 56 (+2.3)
Lenses
- Code Health 49 → 54 (+5.2)
- Architecture 90 → 90 (-0.4)
- Maturity 78 → 74 (-3.6)
- Readiness 47 → 48 (+0.3)
- Security 71 → 71 (-0.2)
- Accessibility 62 → 71 (+10.0)
- Performance 65 → 65 (+0.0)
Resolved (1357)
- ApiGatewayExecuteController.dispatchV2 (cognitive 27) (src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteController.java)
- ApiGatewayExecuteController.dispatchV2 (cyclomatic 24) (src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteController.java)
- ApiGatewayExecuteController.toAuthorizerEvent (cognitive 19) (src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteController.java)
- AslExecutor.awaitToken (cognitive 17) (src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java)
- AwsConfigService.putConfigRule (cyclomatic 17) (src/main/java/io/github/hectorvent/floci/services/configservice/AwsConfigService.java)
- AwsProtocolClaimFilter.filter (cognitive 18) (src/main/java/io/github/hectorvent/floci/core/common/AwsProtocolClaimFilter.java)
- AwsQueryController.inferServiceFromAction (cyclomatic 16) (src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java)
- Change coupling: AwsJson11Controller.java ↔ AwsJsonController.java (src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java)
- ClassTooLong: AwsQueryController (src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java)
- ClassTooLong: CodeArtifactService (src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactService.java)
- ClassTooLong: DynamoDbStreamsEventSourcePoller (src/main/java/io/github/hectorvent/floci/services/lambda/DynamoDbStreamsEventSourcePoller.java)
- ClassTooLong: SamTransformProcessor (src/main/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessor.java)
- ClassTooLong: SesIdentityController (src/main/java/io/github/hectorvent/floci/services/ses/SesIdentityController.java)
- CloudFormationService.deleteRemovedOrConditionFalseResources (cognitive 16) (src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.java)
- CodeArtifactService.deletePackage (cognitive 22) (src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactService.java)
- CognitoAuthFlowHandler.invokeTrigger (cognitive 19) (src/main/java/io/github/hectorvent/floci/services/cognito/CognitoAuthFlowHandler.java)
- CognitoAuthFlowHandler.invokeTrigger (cyclomatic 18) (src/main/java/io/github/hectorvent/floci/services/cognito/CognitoAuthFlowHandler.java)
- CognitoService.signUpUnderUserLock (cognitive 19) (src/main/java/io/github/hectorvent/floci/services/cognito/CognitoService.java)
- CognitoService.signUpUnderUserLock (cyclomatic 16) (src/main/java/io/github/hectorvent/floci/services/cognito/CognitoService.java)
- CognitoService.updateUserPoolClient (cognitive 30) (src/main/java/io/github/hectorvent/floci/services/cognito/CognitoService.java)
- …and 1337 more
New (2400)
- AccountContextFilter.filter (cognitive 23) (src/main/java/io/github/hectorvent/floci/core/common/AccountContextFilter.java)
- AcmService.importCertificate (cognitive 19) (src/main/java/io/github/hectorvent/floci/services/acm/AcmService.java)
- AcmService.importCertificate (cyclomatic 17) (src/main/java/io/github/hectorvent/floci/services/acm/AcmService.java)
- ApiGatewayExecuteController.buildV2ProxyEvent (cyclomatic 17) (src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteController.java)
- ApiGatewayExecuteController.dispatchMatchedRouteV2 (cognitive 21) (src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteController.java)
- ApiGatewayExecuteController.dispatchMatchedRouteV2 (cyclomatic 18) (src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteController.java)
- ApiGatewayExecuteController.withHttpApiCors (cognitive 18) (src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteController.java)
- ApiGatewayService.parseOpenApiSpec (cognitive 18) (src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayService.java)
- ApiGatewayService.patchEndpointConfiguration (cyclomatic 16) (src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayService.java)
- ApiGatewayTaskInvoker.invoke (cognitive 27) (src/main/java/io/github/hectorvent/floci/services/stepfunctions/ApiGatewayTaskInvoker.java)
- ApiGatewayTaskInvoker.invoke (cyclomatic 28) (src/main/java/io/github/hectorvent/floci/services/stepfunctions/ApiGatewayTaskInvoker.java)
- AslExecutor.doExecute (cognitive 21) (src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java)
- AssumeRolePolicyEvaluator.allowedAwsPrincipals (cognitive 16) (src/main/java/io/github/hectorvent/floci/services/iam/AssumeRolePolicyEvaluator.java)
- AssumeRolePolicyEvaluator.matchPrincipal (cognitive 19) (src/main/java/io/github/hectorvent/floci/services/iam/AssumeRolePolicyEvaluator.java)
- AutoPauseController.acquire (cognitive 17) (src/main/java/io/github/hectorvent/floci/services/rds/container/AutoPauseController.java)
- AutoScalingGroupCfnProvisioner.provisionAutoScalingGroup (cognitive 19) (src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/AutoScalingGroupCfnProvisioner.java)
- AutoScalingGroupCfnProvisioner.resolveMetricsCollection (cognitive 16) (src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/AutoScalingGroupCfnProvisioner.java)
- AutoScalingGroupCfnProvisioner.resolveMixedInstancesPolicy (cognitive 16) (src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/AutoScalingGroupCfnProvisioner.java)
- AutoScalingReconciler.launchInstance (cognitive 32) (src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingReconciler.java)
- AutoScalingReconciler.reconcileRefreshReplacements (cognitive 19) (src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingReconciler.java)
- …and 2380 more
Changes since last survey
- 300 commits — 99 feature/other, 201 fixes
By area
- src/main — 147 commits
- src/test — 117 commits
- docs/services — 17 commits
- compatibility-tests/sdk-test-java — 9 commits
- (root) — 5 commits
- docs/configuration — 3 commits
- compatibility-tests/sdk-test-python — 2 commits
Notable commits
- fix: fix(acm): reject mismatched certificate private keys (#5987)
- fix: fix(apigateway): answer an HTTP API proxy result without a Content-Type as text/plain (#6201)
- fix: fix(apigateway): map Cognito list claims in REST integrations (#6348)
- fix: fix(apigateway): preserve API ownership across integration invocations (#6001)
- fix: fix(apigateway): tag REST API VPC links (#6165)
- fix: fix(apigatewayv2): answer an HTTP API's Lambda proxy body it cannot read with 500 (#6012)
- fix: fix(apigatewayv2): answer the Lambda proxy results an HTTP API cannot read with 500 (#5985)
- fix: fix(autoscaling): apply group capacity reservation preferences (#6378)
- fix: fix(autoscaling): honor launch configuration metadata options (#5964)
- fix: fix(backup): resume unfinished jobs after restart (#5721)
- fix: fix(bedrock): validate guardrail ARNs for tag actions (#6342)
- fix: fix(cloudformation): carry EC2 MetadataOptions from templates and instances (#6050)
- fix: fix(cloudformation): check S3 ownership rules against the resource schema (#5834)
- fix: fix(cloudformation): enforce SAM REST authorization defaults (#6021)
- fix: fix(cloudformation): forward Firehose processing and logging configuration (#6277)
- fix: fix(cloudformation): keep Route 53 routing policies and provision health checks (#6191)
- fix: fix(cloudformation): keep a rule target's dead-letter queue, retry policy, role and ECS parameters (#5958)
- fix: fix(cloudformation): move a kept load balancer onto the template's subnets (#5881)
- fix: fix(cloudformation): order leftover deletes by what their attributes reference (#5998)
- fix: fix(cloudformation): read ECS awsvpc subnets and security groups as lists (#6180)
- …and 280 more
Architecture
- Unchanged — 0 containers · 2 contexts · 0 edges
Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
floci-io/floci was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 24 October 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 307380750ffddc2bb15d898c120539cbb4f7eb95 — the exact code this score is about.
- Scored under rubric-2026.10.5 — the same rubric and the same method as every other entry in this index.
- Measured by watchdog.canine.dev using codehealth-analyzer measure-2026.10.6+preprod-d36780c2d857.