flipkart-incubator/flux

Flux is an asynchronous, scalable state machine orchestrator that manages the lifecycle of distributed workflows. It provides a client-side framework for defining and intercepting tasks, while the runtime handles execution, event scheduling, and persistence. The system supports versioned workflow executions, dynamic deployment unit hot-swapping, and automated redriving of stalled tasks.

54 changes.

This period marks the initial scaffolding and architectural foundation of the Flux project, establishing a multi-module Maven build and defining core domain models for workflow execution and state machines. The work introduced the runtime, client, and API layers, including dashboard visualizations, dynamic deployment unit management, and client-side interception frameworks. Comprehensive test coverage was added across all modules to validate the new persistence services, routing utilities, and workflow execution logic.

22 changes.

This period focused on implementing a comprehensive event and message scheduling system, including database schemas, DAOs, and services for managing scheduled tasks. It also introduced sharding support for entity persistence and added various utility classes and example workflows to demonstrate new capabilities like event replay and cancellation.

6 changes.

This period focused on building a new, isolated persistence module to manage state machine execution data. It introduced a comprehensive set of DAOs, managers, and query criteria to handle state machine entities, including support for database migrations and efficient storage of large objects.

A new data access layer for managing Client ELB records in the scheduler database has been introduced. The \ClientElbDAO\ interface and its \ClientElbDAOImpl\ implementation provide standard CRUD operations (create, find by ID, update URL, and delete) using Hibernate, allowing the scheduler component to persist and retrieve Client ELB data.

scheduler/src/main/java/com/flipkart/flux/clientelb · high confidence

Introduces the MessageDao class and the SmIdAndTaskIdWithExecutionVersion model to manage ScheduledMessage entities. The new DAO provides methods to save, bulk insert or update, count, retrieve oldest messages for polling, and delete messages by their state machine ID, task ID, and execution version. This supports the redriver job's ability to poll and redrive scheduled messages asynchronously.

scheduler/src/main/java/com/flipkart/flux/redriver/dao · high confidence

The dashboard now includes new FreeMarker templates and associated static resources to support Hystrix command and thread pool monitoring, as well as Finite State Machine (FSM) visualization. The \dashboard.ftl\ template integrates Hystrix monitoring scripts and styles, enabling users to view circuit breaker metrics and thread pool data. Additionally, \fsmview.ftl\ introduces a new interface for visualizing FSM graphs, displaying state information, event details, and audit data via modals and collapsible panels. The \header.ftl\ template is updated to include navigation links for both the main dashboard and the new FSM visualization page.

runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages · high confidence

A new example demonstrating a concurrent email marketing workflow has been added to the examples directory. The change introduces a complete set of classes—Email, EmailAcknowledgement, EmailDispatcher, EmailMarketingWorkflow, and RunEmailMarketingWorkflow—that illustrate how to implement and execute a workflow that dispatches emails concurrently using the Flux framework.

examples/src/main/java/com/flipkart/flux/examples/concurrent · high confidence

A new RAMContext class has been introduced in the model package, providing an in-memory implementation of the Context interface. This transient storage mechanism, which stores data in the JVM heap, is explicitly designed for testing purposes rather than production use.

model/src/main/java/com/flipkart/flux/impl · high confidence

Introduced the EventSchedulerDao class to handle database interactions for ScheduledEvent entities. This new data access object provides methods to save, delete, and retrieve scheduled events from the scheduler storage, enabling the event scheduler feature to persist and query event data.

scheduler/src/main/java/com/flipkart/flux/eventscheduler/dao · high confidence

Introduced a new service, EventSchedulerService, which periodically polls the database for scheduled events and triggers them based on their scheduled time. The service is configurable via batch read interval and batch size parameters, and integrates with the event scheduler registry to execute events.

scheduler/src/main/java/com/flipkart/flux/eventscheduler/service · high confidence

Introduced the IsolatedEnv annotation to support Guice bindings specific to the flux isolation mode, allowing interfaces to be bound to their isolated implementations.

client/src/main/java/com/flipkart/flux/client/guice · high confidence

A new MigrationsRunner class has been added to the persistence-mysql module. This component handles MySQL database migrations using Liquibase, allowing users to execute schema updates by running the application with the 'migrate' parameter. It reads configuration from YamlConfiguration and uses a FileSystemResourceAccessor to locate migration scripts.

persistence-mysql/src/main/java/com/flipkart/flux/migration · high confidence

Introduced SessionFactoryContextImpl to manage read-write and read-only session factories for database shards, along with a scheduler session factory. This implementation maintains mappings between shard keys and shard IDs, and uses a thread-local variable to track the current session within a transaction.

common/src/main/java/com/flipkart/flux/persistence/impl · high confidence

A new WorkflowExecutionDemo class has been added to the examples module. This helper allows users to run sample or user-defined workflows by specifying the module name and the fully qualified name of the workflow class. The tool automates the process of copying dependencies, creating a deployment unit structure, and invoking the workflow in a separate process, making it easier to test and demonstrate workflow execution.

examples/src/main/java/com/flipkart/flux/examples · high confidence

A new example workflow named CancelPathWorkflow has been added to demonstrate how to use FluxCancelPathException to cancel a path in a state machine. The example includes a main runner class that initializes the Flux client and executes the workflow, allowing users to observe the cancellation behavior in the FSM view dashboard.

examples/src/main/java/com/flipkart/flux/examples/cancelpath · high confidence

The runtime module now includes new classes to support configuration and task routing. A new \ConfigurationException\ provides a specific error type for configuration issues. The \FileLocator\ utility enables locating configuration files within the project root, supporting both file and directory searches with fallback to classpath resources. Additionally, \TaskRouterUtil\ is introduced to manage router names and concurrency settings for deployment units, utilizing Guice for dependency injection.

runtime/src/main/java/com/flipkart/flux/config · high confidence

Added shell scripts (run\_example.sh, run\_separate\_modes\_example.sh) and a Maven backup (pom.xml.versionsBackup) to the examples directory. The scripts automate building the project, copying dependencies, and launching the Flux runtime in combined or separate orchestrator/executor modes, with support for debug mode and color-coded output.

examples · high confidence

Added new example files (EventUpdateWorkflow.java and RunEventUpdateWorkflow.java) that demonstrate how to define and execute a workflow using the Flux framework, including task definitions, event handling, and Guice-based execution.

examples/src/main/java/com/flipkart/flux/examples/eventupdate · high confidence

Introduced LoggingUtils to manage MDC-based logging for state machine IDs, and added SearchUtil to perform breadth-first search on state machine graphs, enabling traversal path analysis for workflow execution.

common/src/main/java/com/flipkart/flux/utils · high confidence

A new example demonstrating a manual seller verification workflow has been added to the external events package. This includes the workflow definition, service classes, and supporting data models to show how to handle external events that pause and resume workflow execution.

examples/src/main/java/com/flipkart/flux/examples/externalevents · high confidence

Introduced new model classes in the \com.flipkart.flux.shard\ package to support sharded entity persistence. This includes the \ShardedEntity\ interface and \AbstractShardedEntity\ base class, along with supporting models like \ShardId\, \ShardPairModel\, and \MasterSlavePairList\ to define shard configurations and master-slave pairs.

model/src/main/java/com/flipkart/flux/shard · high confidence

A new example demonstrating a simple decision-making workflow for user verification has been added to the examples directory. This includes the main entry point (RunUserVerificationWorkflow), the workflow logic (UserVerificationWorkflow), and supporting services (NotificationService, UserDataService, UserVerificationService) along with their associated data models (UserId, UserData, UserVerificationStatus). This serves as a reference for implementing conditional logic within a Flux workflow.

examples/src/main/java/com/flipkart/flux/examples/decision · high confidence

The runtime now includes a CORS filter that adds standard cross-origin headers (e.g., Access-Control-Allow-Origin, Methods, Headers) to all API responses, and a request logging filter that logs incoming request paths and payloads for debugging. These filters are registered in the Guice modules for both the execution and orchestration API servers, ensuring consistent cross-origin support and observability across all endpoints.

runtime/src/main/java/com/flipkart/flux/guice · high confidence

A new Pair class has been added to the Flux utils package, providing a simple container for holding a key and a value. This utility enables developers to easily bundle two related objects together, with support for equality and hash code based on both the key and value.

api/src/main/java/com/flipkart/flux/utils · high confidence

The repository was initialized with essential project files, including a README describing Flux as an asynchronous, scalable state machine orchestrator, a CHANGELOG detailing version history, and a build script (build.sh) that automates Maven builds and database setup. The project is now licensed under the Apache License 2.0, and Git is configured to ignore IDE and build artifacts.

(repo-wide) · high confidence

A new interface, EventSchedulerRegistry, has been added to the common module. This interface defines the contract for scheduling, triggering, and deregistering events at specific future times, supporting features like state machine correlation and event source tracking.

common/src/main/java/com/flipkart/flux/task/eventscheduler · high confidence

Added FluxInitializer, a new entry point that bootstraps the Flux runtime using Polyguice dependency injection. It supports starting the runtime in three modes: 'orchestration', 'execution', or 'combined' (both), allowing users to run separate servers for orchestration (port 9998) and execution (port 9999) or a single combined instance. Additionally, it provides a 'migrate' command to run database migrations for 'flux' or 'flux\_scheduler' schemas.

runtime/src/main/java/com/flipkart/flux/initializer · high confidence

The Flux framework now supports running orchestration and execution modes within the same runtime via a new \FluxRuntimeRole\ enum that includes a \COMBINED\ state. This is supported by a new \Constants\ interface for shared configuration and mode identifiers, and new annotations (\@InjectFromRole\, \@ManagedEnv\) that enable dependency injection based on the active runtime role.

common/src/main/java/com/flipkart/flux · high confidence

The system now persists scheduled messages, scheduled events, and client ELB configurations in the database. New tables are created for \ScheduledMessages\, \ScheduledEvents\, and \ClientElb\, with additional columns for execution versioning and indexes on scheduled time fields to support the new scheduling capabilities.

_persistence-mysql/src/main/resources/flux\scheduler/migrations · high confidence

Added RedriverService, a singleton component that schedules periodic redrive operations using a fixed-delay scheduler and an async thread pool. The service retrieves oldest scheduled messages in batches, submits each redrive task to the thread pool, and waits for all async calls to complete before proceeding to the next batch.

scheduler/src/main/java/com/flipkart/flux/redriver/service · high confidence

A new constant class, ClientConstants, has been added to the client module to centralize string literals used in forming task and workflow identifiers. This includes a 'client' identifier and a specific 'flux\_runtime\_replay\_internal' constant for replay events, replacing previous inline string usage with a centralized configuration.

client/src/main/java/com/flipkart/flux/client/constant · high confidence

Adds the Executable interface and ExecutableRegistry interface to the client module, providing a standardized way for the core runtime to discover and execute client-side tasks and hooks. This establishes the foundation for dynamic task execution and hook invocation within the client environment.

client/src/main/java/com/flipkart/flux/client/registry · high confidence

Adds the RedriverRegistry interface, which defines the contract for executing stalled or zombie tasks that missed their scheduled execution due to node failures. This interface provides methods to register tasks for restart after a specified delay, cancel scheduled restarts, and manually re-drive tasks, laying the groundwork for the redriver functionality.

common/src/main/java/com/flipkart/flux/task/redriver · high confidence

A new Guice module, SchedulerModule, has been added to configure the scheduler's database layer. It sets up Hibernate configuration for the scheduler database, registers specific entity classes (ScheduledMessage, ScheduledEvent, ClientElb) and custom types, and applies a transactional interceptor to the DAO packages for message, event, and client ELB operations.

scheduler/src/main/java/com/flipkart/flux/module · high confidence

The persistence layer now supports selecting between read-write and read-only data sources via the new \@SelectDataSource\ annotation. This change introduces several new components in the \com.flipkart.flux.persistence\ package: a \DataSourceType\ enum to distinguish between \READ\_WRITE\ and \READ\_ONLY\ operations, a \Storage\ enum to differentiate between \SHARDED\ and \SCHEDULER\ storage types, and a \SessionFactoryContext\ interface to manage session factories for ongoing transactions. Additionally, a \CryptHashGenerator\ utility is added to generate SHA-256 hashes for state machine IDs. These additions enable the \TransactionInterceptor\ to route database calls to the appropriate data source based on annotations, supporting both sharded and scheduler-specific database interactions.

common/src/main/java/com/flipkart/flux/persistence · high confidence

Adds new Spring MVC controllers to expose the Flux dashboard and FSM (Finite State Machine) visualization UI. The DashboardController handles the main dashboard view, while the FSMVisualizationController serves the FSM view, dynamically injecting the runtime API host and URL into the model for the frontend. These controllers enforce role-based access, ensuring the dashboard is only available in EXECUTION mode and the FSM view is only available in ORCHESTRATION mode, returning a 'resource not available' view otherwise.

runtime/src/main/java/com/flipkart/flux/controller · high confidence

The task module now includes a local executable registry implementation that resolves and caches task methods for in-JVM execution, alongside an HTTP-based runtime connector that serializes and posts events and status updates to the Flux runtime. Additionally, domain models for audit records, client ELB, events, states, state machines, and traversal paths have been added or updated to support versioned workflows and execution tracking.

task · high confidence

The persistence layer now exposes a set of new DAO interfaces (AuditDAO, EventsDAO, StateMachinesDAO, StateTraversalPathDAO, and StatesDAO) along with their V1 counterparts and a generic DAO base interface. These interfaces define the contract for creating, updating, and retrieving entities such as AuditRecord, Event, StateMachine, StateTraversalPath, and State. This change isolates the persistence logic into a separate module and provides a generic update API interface in the DAO layer, enabling more structured and maintainable database interactions for state machine execution.

persistence/src/main/java/com/flipkart/flux/persistence/dao · high confidence

Adds four new services in the representation layer to handle data persistence and caching: StateMachinePersistenceService for creating and validating state machines (including replayable state constraints), EventPersistenceService for event storage, ReplayEventPersistenceService for processing replay events with transactional integrity and retry limits, and ClientElbPersistenceService which introduces an in-memory cache (via Google Guava) to optimize client ELB lookups. These changes support the ExecutionVersionedWorkflows feature by providing the underlying data access and caching mechanisms.

runtime/src/main/java/com/flipkart/flux/representation · high confidence

The API now includes new data transfer objects to support versioned workflows: \VersionedEventData\ and \AuditEvent\ carry an \executionVersion\ to track state and event versions; \EventAndExecutionData\ bundles versioned events with execution updates; \ClientElbDefinition\ and \StateMachineDefinition\ now include \clientElbId\ and \correlationId\ fields; \StateDefinition\ adds \replayable\ and \maxReplayableRetries\ properties; \ExecutionUpdateData\ exposes \currentRetryCount\ and \taskExecutionVersion\; and \Status\ includes \sidelined\ and \unsidelined\ states. These changes enable the system to manage, audit, and replay versioned workflow executions.

api/src/main/java/com/flipkart/flux/api · high confidence

The client module now includes a new interception framework located in \com.flipkart.flux.client.intercept\. This adds \TaskInterceptor\ and \WorkflowInterceptor\ classes that intercept method invocations to automatically register state machine definitions, track events, and submit workflows to the runtime. The change introduces supporting classes such as \MethodId\ for unique task identification, \ProxyEventCallbackFilter\ for dynamic proxy creation, and several custom exceptions (\IllegalInvocationException\, \IllegalSignatureException\, \MalformedIdentifierException\, \UnknownIdentifierException\, \VersionMismatchException\) to handle validation and error states during interception.

client/src/main/java/com/flipkart/flux/client/intercept · high confidence

Added new REST resources to manage cluster nodes and deployment units. The StatusResource exposes endpoints to control node rotation status (bring in/out of rotation) and allows nodes to leave the cluster. The DeploymentUnitResource provides APIs to load and unload deployment units, managing their lifecycle and associated task routers. The ExecutionApiResource introduces an endpoint to receive and process task execution messages, routing them to the appropriate Akka actors. Additionally, the StateMachineResource expands state machine management capabilities, while new model classes (FsmGraph, FsmGraphVertex, FsmGraphEdge) support state machine visualization. The ClientElbResource adds CRUD operations for client ELB configurations.

runtime/src/main/java/com/flipkart/flux/resource · high confidence

A new Java class, FluxClientConfiguration, has been added to the client configuration package. This class provides the configuration settings required to connect to the Flux runtime, including the runtime URL (defaulting to http://localhost:9998/), client ELB ID, and socket/connection timeouts. It is designed to be provided via a Guice module for dependency injection.

client/src/main/java/com/flipkart/flux/client/config · high confidence

Introduced two new Guice modules, FluxClientComponentModule and FluxClientInterceptorModule, to configure the Flux client. The component module wires the FluxRuntimeConnector, LocalContext, and ExecutableRegistry, while the interceptor module registers Task and Workflow interceptors for task execution.

client/src/main/java/com/flipkart/flux/client · high confidence

Added new example workflows and task classes for benchmarking purposes, including \ArithmeticOperations\, \ArithmeticOperationsExtended\, \LatentArithmeticOperations\, and \PaymentGatewayTasks\. These are wired into new workflows (\BenchmarkWorkFlowA\, \BenchmarkWorkFlowAExtended\, \BenchmarkWorkflowLatentSimulation\, \PaymentGatewayWF\) and a runner class (\RunBenchMarkWorkFlowA\) to simulate various computational and latent task scenarios.

examples/src/main/java/com/flipkart/flux/examples/benchmark · high confidence

The client runtime package now includes several new classes to handle workflow and event interactions. A new \EventProxyConnector\ class is introduced to manage the submission of regular, scheduled, and replay events to the core Flux runtime. The \FluxRuntimeConnector\ interface is added to define the contract for communicating with the runtime, including methods for submitting events, updating execution status, and redriving tasks. Additionally, \LocalContext\ is introduced to maintain thread-local state machine definitions and event names, while \RuntimeCommunicationException\ and \Stoppable\ are added to handle communication errors and resource cleanup.

client/src/main/java/com/flipkart/flux/client/runtime · high confidence

The model layer introduces new domain classes to support workflow execution tracking. A new Context class manages execution state, including a dependency graph that maps events to states and provides methods to retrieve initial or dependent states. Additionally, new enums define StateMachineStatus (active, cancelled) and Status (initialized, running, completed, cancelled, errored, sidelined, unsidelined, invalid) to represent the lifecycle and state of tasks and state machines.

model/src/main/java/com/flipkart/flux/domain · high confidence

Added example workflows in the \examples/src/main/java/com/flipkart/flux/examples/replayevents\ directory to demonstrate the use of replay events. These include \ReplayEventWorkflow\ and \ReplayEventWorkflow2\, which showcase tasks annotated with \@ReplayEvent\ and \isReplayable = true\, along with corresponding runner classes (\RunReplayEventWorkflow\) and additional examples for validating same/multiple replay events on states. These serve as reference implementations for integrating replay event functionality.

examples/src/main/java/com/flipkart/flux/examples/replayevents · high confidence

Two new exception classes have been added to the client library: FluxCancelPathException, which allows tasks to cancel the current execution path until a join node is reached, and FluxRetriableException, which signals the runtime to retry a task execution. These changes enable developers to implement dynamic conditional branching and configurable retry logic within their workflows.

client/src/main/java/com/flipkart/flux/client/exception · high confidence

The runtime module introduces three new interfaces to support dynamic deployment unit management. DeploymentUnitsManager provides methods to load and unload deployment units by name and version, and to retrieve all currently loaded units. DeploymentUnitUtil defines operations for listing and retrieving deployment units from the file system. ExecutableLoader handles the process of reading deployment units and registering their annotated methods into the executable registry for later execution.

runtime/src/main/java/com/flipkart/flux/deploymentunit/iface · high confidence

The client library introduces a set of new model classes and annotations to define and manage workflow execution. The \Task\ annotation marks methods as executable units of work with versioning, timeout, and retry policies. The \Workflow\ annotation declares workflow boundaries. New interfaces (\Event\, \FluxContext\, \Hook\) and annotations (\CorrelationId\, \ExternalEvent\, \ReplayEvent\) enable developers to specify external event dependencies, correlate execution contexts, and define pre/post-entry hooks for tasks.

client/src/main/java/com/flipkart/flux/client/model · high confidence

A new persistence module has been introduced to manage the storage of state machine execution data. This includes a generic \EntityManager\ base class and specific managers for \AuditRecord\, \Event\, \State\, \StateMachine\, and \StateTraversalPath\ entities. A \MultiEntityManager\ enables creating or updating multiple entity types within a single transactional scope, ensuring that all related state machine data is persisted together. The implementation includes validation logic to prevent invalid state machine configurations, such as multiple states depending on the same replay event.

persistence/src/main/java/com/flipkart/flux/persistence · high confidence

The runtime now supports loading, unloading, and managing deployment units at runtime. A new \DeploymentUnitsManager\ handles the lifecycle of \DeploymentUnit\ instances, which each maintain their own classloader (\DeploymentUnitClassLoader\) and object mapper. This enables dynamic registration and removal of workflow tasks without restarting the application.

runtime/src/main/java/com/flipkart/flux/deploymentunit · high confidence

A new BlobType implementation is introduced to store Java objects as compressed byte arrays in the database. This type automatically compresses serialized objects using GZIP before storage and decompresses them upon retrieval, significantly reducing the storage footprint for large binary data. Additionally, a StoreFQNType is added to persist and reconstruct class fully qualified names, supporting dynamic object instantiation from stored class names.

persistence-mysql/src/main/java/com/flipkart/flux/type · high confidence

A new RuntimeConstants class is added to centralize framework configuration, defining default values such as the internal event source for replay events (flux\_runtime\_replay\_internal), the maximum number of replayable retries (5), and the default ELB ID. It also establishes context paths for the admin dashboard and API, along with view names for the FSM visualization and error states.

runtime/src/main/java/com/flipkart/flux/constant · high confidence

The persistence layer has been isolated into a separate module, introducing a new \AbstractDAO\ base class and concrete implementations for \AuditRecord\, \Event\, \StateMachine\, \State\, and \StateTraversalPath\. These new DAOs provide generic update and create operations, enabling the management of state machine execution entities. The implementation supports both standard and V1 API interfaces, allowing for controlled migration and feature availability.

persistence-mysql/src/main/java/com/flipkart/flux/persistence · high confidence

The MySQL database schema has been updated to support execution versioning and event replaying. New columns \executionVersion\ and \replayable\ were added to the \States\ table, while \executionVersion\ was added to the \Events\ and \StateMachines\ tables. Additionally, the \States\ table now includes \maxreplayableRetries\ and \attemptedNumOfReplayableRetries\ to manage replay limits, and indexes were added to the \States\ and \StateMachines\ tables to improve query performance.

persistence-mysql/src/main/resources/flux/migrations · high confidence

The runtime module introduces several new, specific exception classes to replace generic or overly broad error handling. These include CreateStateMachineException, DuplicateDeploymentUnitException, IllegalEventException, RedriverException, ReplayEventException, ReplayableRetryExhaustException, TraversalPathException, and UnknownStateMachine. This change allows the system to distinguish between different failure modes—such as invalid state machine configurations, duplicate deployments, illegal events, redrive failures, exhausted replay retries, missing traversal paths, or unknown state machines—enabling more precise error handling and debugging for workflow execution.

runtime/src/main/java/com/flipkart/flux/exception · high confidence

Added new classes to support the persistence layer for state machine execution. In the common module, new key classes (EntityId, FSMId, FSMIdEntityId, FSMIdStateIds) define identifiers for state machines and their states. In the persistence module, new criteria classes (DependentEventCriteria, EventStatusCriteria, FSMNameCriteria, FSMStatusCriteria) provide query filters for retrieving state machine, event, and status data, enabling the isolation of the persistence logic.

common/src/main/java/com/flipkart/flux/persistence/key, persistence/src/main/java/com/flipkart/flux/persistence/criteria · high confidence

The application now allows Orchestration and Execution nodes to load their configuration from distinct files. By setting the JVM system properties 'flux.orchestration.configurationFile' and 'flux.execution.configurationFile', users can specify custom configuration file paths for each role, falling back to default resources if not provided. This enables independent configuration for each runtime mode.

common/src/main/java/com/flipkart/flux/guice · high confidence

Added SchedulerTestModule for test configuration; Added end-to-end and unit tests for the client-side workflow and task interception framework; Added integration tests for end-to-end workflow execution, cancellation paths, and event replay; Added test infrastructure for Flux client; Added test infrastructure for Guice-based dependency injection; Added test modules for deployment unit and runtime testing; Added test resources for state machine and event data; Added test utilities for database and state machine setup; Added test utilities for state machine validation; Added tests for LocalContext state and event name generation; Added tests for dynamic deployment unit loading and unloading; Added tests for message removal batching; Added unit tests for Akka and Scheduler Guice modules; Added unit tests for ClientElb DAO layer; Added unit tests for DAO layer components; Added unit tests for EventSchedulerDao; Added unit tests for EventSchedulerService; Added unit tests for LocalExecutableRegistryImpl; Added unit tests for MessageDao; Added unit tests for RedriverService; Added unit tests for persistence services; Added unit tests for resource endpoints; Added unit tests for the TransactionInterceptor; Added unit tests for the workflow execution controller.

The project has been restructured into a multi-module Maven build, introducing new modules for the API, client, common utilities, model, scheduler, task execution, and examples. The root \pom.xml\ now defines a parent POM with version 1.2.6-SNAPSHOT and manages dependencies for libraries including Hibernate, Guice, Akka, Hystrix, Log4j2, and Jackson. Specific module POMs (e.g., \persistence-mysql\, \runtime\, \task\) define their own dependencies, such as MySQL Connector/J 8.0.20, Liquibase 3.5.0, and various Akka and Kamon libraries, establishing the build and runtime environment for the new architecture.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 33 → 37 (+3.7)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 20 → 38 (+17.9)
• Architecture 96 → 94 (-2.7)
• Maturity 55 → 55 (+0.0)
• Readiness 37 → 40 (+3.2)
• Security 84 → 79 (-4.6)
• Domain Modelling 92 → 73 (-19.7)
• Accessibility 31 → 25 (-5.9)

• (anonymous) (cognitive 16) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous) (cognitive 18) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous) (cyclomatic 17) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous) (cyclomatic 18) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• Boundary-crossing change coupling: StateMachineResource.java ↔ RedriverRegistryImpl.java (runtime/src/main/java/com/flipkart/flux/resource/StateMachineResource.java)
• Boundary-crossing change coupling: TransactionInterceptor.java ↔ ParallelScatterGatherQueryHelper.java (common/src/main/java/com/flipkart/flux/guice/interceptor/TransactionInterceptor.java)
• Boundary-crossing change coupling: WorkFlowExecutionController.java ↔ FluxError.java (runtime/src/main/java/com/flipkart/flux/controller/WorkFlowExecutionController.java)
• Boundary-crossing change coupling: WorkFlowExecutionController.java ↔ RedriverRegistryImpl.java (runtime/src/main/java/com/flipkart/flux/controller/WorkFlowExecutionController.java)
• Change coupling: StateMachinesDAO.java ↔ StatesDAO.java (persistence/src/main/java/com/flipkart/flux/persistence/dao/iface/StateMachinesDAO.java)
• Change coupling: StatesDAOImpl.java ↔ StateMachinesDAO.java (persistence-mysql/src/main/java/com/flipkart/flux/persistence/dao/impl/StatesDAOImpl.java)
• Change coupling: TaskExecutor.java ↔ TaskRegistry.java (task/src/main/java/com/flipkart/flux/impl/task/TaskExecutor.java)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (api/src/main/java/com/flipkart/flux/api/ExecutionUpdateData.java)
• Duplicated block (10 lines × 2) (runtime/src/main/java/com/flipkart/flux/controller/WorkFlowExecutionController.java)
• Duplicated block (10 lines × 2) (runtime/src/main/java/com/flipkart/flux/guice/module/ExecutionContainerModule.java)
• Duplicated block (10 lines × 2) (runtime/src/main/java/com/flipkart/flux/guice/module/ExecutionContainerModule.java)
• Duplicated block (10 lines × 2) (runtime/src/main/java/com/flipkart/flux/resource/StateMachineResource.java)
• Duplicated block (10 lines × 2) (runtime/src/main/java/com/flipkart/flux/resource/StateMachineResource.java)
• Duplicated block (11 lines × 2) (api/src/main/java/com/flipkart/flux/api/StateDefinition.java)
• …and 68 more

• (anonymous)::(anonymous)::annotateString (cognitive 33) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous)::(anonymous)::annotateString (cyclomatic 19) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous)::(anonymous)::containsRect (cognitive 19) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous)::(anonymous)::createElement (cognitive 17) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous)::(anonymous)::findOrthogonalRoute (cognitive 31) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous)::(anonymous)::findOrthogonalRoute (cyclomatic 17) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous)::(anonymous)::findRoute (cognitive 40) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous)::(anonymous)::findRoute (cyclomatic 18) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous)::(anonymous)::parseTransformString (cognitive 21) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous)::(anonymous)::parseTransformString (cyclomatic 19) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous)::(anonymous)::router (cognitive 18) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous)::(anonymous)::text (cognitive 68) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous)::(anonymous)::text (cyclomatic 29) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous)::breakText (cognitive 48) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous)::breakText (cyclomatic 21) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous)::fitToContent (cognitive 27) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous)::fitToContent (cyclomatic 27) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous)::flattenObject (cognitive 17) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous)::getConnectionPoint (cognitive 39) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• (anonymous)::getConnectionPoint (cyclomatic 21) (runtime/src/main/resources/packaged/webapps/dashboard/WEB-INF/pages/resources/js/joint.js)
• …and 142 more

• Containers 0 added · 0 removed · contexts 6 added · 0 removed · edges 15 added · 0 removed

• client
• common
• model
• persistence-mysql
• runtime
• scheduler

• common → model
• persistence-mysql → common
• persistence-mysql → model
• runtime → client
• runtime → common
• runtime → model
• runtime → persistence-mysql
• runtime → scheduler
• runtime → task
• scheduler → common
• scheduler → model
• task → client
• task → common
• task → model
• task → scheduler

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

flipkart-incubator/flux 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.