apache/incubator-seata

This system is a distributed transaction coordination framework that manages global and branch transaction states across microservices. It provides mechanisms for transaction propagation over various RPC and messaging protocols, including gRPC, Dubbo, and HTTP, while supporting multiple storage backends and serialization formats. The architecture emphasizes extensibility through a service loader pattern and offers comprehensive integration with Spring Boot and popular configuration and registry centers.

163 changes.

This period marks the comprehensive migration of the Seata project to the Apache Software Foundation, involving a complete package namespace shift from io.seata to org.apache.seata. The codebase was refactored to support modern distributed transaction protocols, including a new RPC framework, enhanced serialization with security whitelists, and expanded support for configuration centers like Nacos, Apollo, and Consul. Additionally, the project introduced robust tooling, including Helm charts, database initialization scripts, and a visual designer for Saga state machines, while maintaining backward compatibility through a dedicated shim layer.

24 changes.

This period focused on modernizing the project's integration with the Spring Boot ecosystem through comprehensive auto-configuration and property binding. Simultaneously, extensive new features were added to support distributed transaction context propagation across various RPC frameworks, including gRPC, HTTP, bRPC, Dubbo, and HSF. The work also included expanding serialization support with Fory and Fastjson2, adding a benchmark CLI tool, and significantly increasing test coverage for core components.

Introduces a new ANTLR-based SQL parser implementation for MySQL, including grammar files (MySqlLexer.g4, MySqlParser.g4) and Java classes (e.g., AntlrMySQLDeleteRecognizer, AntlrMySQLInsertRecognizer, AntlrMySQLUpdateRecognizer, AntlrMySQLSelectRecognizer) that parse and recognize SQL operations (SELECT, INSERT, UPDATE, DELETE) using the ANTLR4 framework.

sqlparser/seata-sqlparser-antlr · high confidence

The project now includes standard Apache Software Foundation governance and compliance files to satisfy licensing and community requirements. This includes the Apache 2.0 license text, a NOTICE file, a DISCLAIMER, and a CODE\_OF\_CONDUCT.md. Additionally, a \.licenserc.yaml\ configuration is added to automate header checks, while \.asf.yaml\ configures GitHub repository settings such as required status checks and pull request reviews. The repository also introduces a \Makefile\ to standardize build, test, and license-check commands, alongside a Maven wrapper (\mvnw\) to ensure consistent Maven versions across all environments.

(repo-wide) · high confidence

Users can now store and retrieve Seata configuration data in a Consul cluster. This change introduces the \ConsulConfiguration\ and \ConsulConfigurationProvider\ classes, which implement the \Configuration\ and \ConfigurationProvider\ interfaces to enable Consul-based configuration management.

config/seata-config-consul/src/main · high confidence

The Seata framework now supports service discovery via HashiCorp Consul. This change introduces the \seata-discovery-consul\ module, which provides a \ConsulRegistryService\ implementation that registers, unregisters, and subscribes to service instances using the Consul HTTP API. Users can configure Consul as their registry center to enable dynamic service discovery and load balancing across Consul-backed microservices.

discovery/seata-discovery-consul/src/main/java, discovery/seata-discovery-eureka/src/main · high confidence

The framework now includes new compression modules for Deflater and Gzip algorithms. Users can compress and decompress data using these standard algorithms, which are registered via the \org.apache.seata.core.compressor.Compressor\ SPI file for automatic discovery. The implementation includes utility classes (\DeflaterUtil\, \GzipUtil\) and their corresponding compressor wrappers (\DeflaterCompressor\, \GzipCompressor\) with full test coverage.

compressor/seata-compressor-deflater · high confidence

A new entrypoint shell script (seata-naming-server-entrypoint.sh) has been added to the Docker resources for the naming server. This script configures the Java environment and launches the application using the Jib-generated classpath and main class, enabling direct containerized execution of the naming server.

namingserver/src/main/resources/docker · high confidence

A new English resource file, ErrorCode\_en.properties, has been added to the common module. This file defines error message templates, including a specific template for deserialization security errors, which supports improved error reporting and localization for English-speaking users.

common/src/main/resources · high confidence

Users can now use the Fastjson2 library for serializing and deserializing SEATA protocol messages. This change introduces the Fastjson2Serializer implementation, its factory, and the corresponding service provider configuration, enabling SEATA to leverage Fastjson2's JSONB format for improved performance and security. A dedicated test ensures concurrent reference deserialization does not drop fields, addressing a specific bug in the Fastjson2 library's handling of complex object graphs.

serializer/seata-serializer-fastjson2 · high confidence

The json-common-core module now includes a new Fastjson2 JSON serializer implementation that enforces a configurable allowlist for JSON deserialization, preventing unsafe class loading. The change introduces a \JsonAllowlistManager\ that validates deserialized types against built-in and user-defined allowlists, and integrates this check into the Fastjson2 serializer's auto-type handling. A warmup utility is also added to pre-initialize Fastjson2 object readers. Additionally, the \JsonSerializer\ interface and factory are updated to support Jackson3 and other serializers, with the factory falling back to Jackson if Jackson3 is unavailable. Tests are added to verify the allowlist behavior and serializer functionality.

json-common/json-common-core · high confidence

Users can now use the Fory serialization format for message encoding and decoding. This change introduces the ForySerializer implementation, a factory for managing the Fory instance with safe class registration and reference tracking, and registers the serializer via the Java SPI mechanism. A corresponding unit test verifies that Fory serialization works correctly for transaction-related messages.

serializer/seata-serializer-fory · high confidence

Introduced a new \seata-http\ extension that enables distributed transaction context propagation for HTTP requests in Spring MVC applications. The change adds an \AbstractHttpExecutor\ and \DefaultHttpExecutor\ to handle HTTP client operations, along with a \TransactionPropagationInterceptor\ that automatically binds and cleans up the Seata XID header in Spring MVC requests. A \SeataWebMvcConfigurer\ registers the interceptor, and a \HandlerInterceptorAdapter\ provides default Spring MVC lifecycle methods. Tests verify that the XID is correctly propagated and cleaned up during GET, POST, and exception scenarios.

extensions/rpc/seata-http · high confidence

The Seata Server can now be deployed to Kubernetes using the new Helm chart located in script/server/helm/seata-server. This includes the chart metadata, templates for the Deployment and Service, helper templates, and default values for image, service type, and environment variables, enabling users to install the Seata Server via Helm.

script/server/helm · high confidence

Introduced a new \seata-http-jakarta\ extension module containing \JakartaSeataWebMvcConfigurer\ and \JakartaTransactionPropagationInterceptor\. This adds support for propagating the Seata XID header in Jakarta Servlet-based Spring MVC applications, with corresponding unit tests verifying the interceptor's behavior.

extensions/rpc/seata-http-jakarta · high confidence

The codebase now includes a new Kryo-based serializer implementation (KryoSerializer, KryoInnerSerializer, and KryoSerializerFactory) that enables high-performance object serialization for Seata messages. Additionally, a custom registry provider (CustomRegistryProvider) has been added to the discovery module, allowing users to configure and load custom registry implementations via configuration. These changes introduce new capabilities for data serialization and service discovery configuration.

discovery/seata-discovery-custom/src/main, serializer/seata-serializer-kryo · high confidence

The Seata framework now includes a built-in LZ4 compressor implementation. Users can enable LZ4 compression for their transactions by configuring the appropriate compressor type. The change introduces the \Lz4Compressor\ class and its utility, registers the implementation via the \META-INF/services\ SPI file, and includes comprehensive unit tests for both the compressor and its underlying utility methods.

compressor/seata-compressor-bzip2, compressor/seata-compressor-zip, compressor/seata-compressor-lz4 · high confidence

Two new configuration files are added to the project: logstash-kafka.conf and logstash-logback.conf. These files define the pipeline for forwarding logs to Elasticsearch via Kafka and TCP inputs respectively, enabling users to integrate their application logs into a centralized logging system.

script/logstash · high confidence

Users can now serialize and deserialize Seata distributed transaction messages (including global and branch commit/rollback requests and responses) using the Protobuf format, or use the new gRPC-based serializer for more efficient binary encoding. This change introduces a complete set of Protobuf converters and serializers, enabling higher performance and cross-language compatibility for transactional messaging.

serializer/seata-serializer-protobuf/src/main/java · high confidence

The Seata framework introduces new classes to support HTTP/2 and improve RPC observability. A new RpcStatus class has been added to track active and total RPC counts per service, enabling better monitoring of service load. Additionally, an HttpContext class has been introduced to manage HTTP context information, including support for HTTP/2.0 versus HTTP/1.1, and handling of keep-alive and async states for network channels.

common/src/main/java/org/apache/seata/common/rpc · high confidence

Users can now use Redis as a backend for service discovery and registry. This change introduces the Redis implementation for the registry module, including the core service implementation, a provider for service loading, a listener interface for events, and the necessary SPI configuration to enable Redis-based discovery.

discovery/seata-discovery-redis/src/main · high confidence

The SOFA Registry integration is now available for service discovery. This change introduces the \SofaRegistryProvider\ and \SofaRegistryServiceImpl\ classes, which implement the \RegistryProvider\ interface to handle registration, unregistration, and subscription for services using the SOFA Registry. The provider is automatically discovered via the \META-INF/services\ SPI file, enabling users to configure \registry.sofa\ properties to connect to a SOFA Registry cluster.

discovery/seata-discovery-etcd3/src/main/java, discovery/seata-discovery-sofa · high confidence

Introduces a new Seata MQ producer and factory for RocketMQ, enabling distributed transaction support via a TCC (Try-Confirm-Cancel) pattern. The implementation includes a custom producer that intercepts message sends during global transactions, ensuring that messages are only committed or rolled back based on the global transaction status. A key behavioral change is the rejection of messages with delay time levels during Seata transactions, as indicated by the commit message and the explicit check in the code that throws an exception if a delay time level is set. This adds a new messaging integration point for users requiring transactional guarantees with RocketMQ.

extensions/messaging/seata-rocketmq · high confidence

The APM extension now includes a new SkyWalking plugin for Seata, enabling distributed transaction tracing. This adds interceptors for Seata's core components (DefaultCore, NettyRemoting, RemotingProcessor) to create and manage SkyWalking spans for global commit, rollback, and RPC operations. The plugin automatically extracts and tags the Seata XID in the distributed trace, allowing users to monitor Seata transaction flows alongside other microservices in their SkyWalking dashboard.

extensions, extensions/apm/apm-seata-skywalking-plugin · high confidence

Added \application.properties\ and \application.yml\ templates in \script/client/spring\ that provide default values for all Seata client and transport settings, including data source proxying, TCC/Saga options, Nacos/Etcd/ZooKeeper registry and config center parameters, and JSON serialization types.

script/client/spring · high confidence

Users can now configure Seata using Spring Cloud's environment properties. This change introduces a new \SpringCloudConfiguration\ implementation that reads configuration values from the Spring \Environment\ (e.g., \seata.\*\ properties), making it possible to manage Seata settings via Spring Cloud Config or standard Spring Boot configuration files. The module also includes a \SpringApplicationContextProvider\ to store the Spring context for internal access, and a \SpringCloudConfigurationProvider\ to register the new configuration source. Unit tests are added to verify the behavior of the configuration provider and the Spring context integration.

config/seata-config-etcd3, config/seata-config-spring-cloud · high confidence

A new compatibility layer has been introduced in the \io.seata.rm.tcc.interceptor\ package, providing \TccActionInterceptorHandler\ and \TccActionInterceptorParser\ classes. These components bridge the legacy \io.seata\ TCC API with the newer \org.apache.seata\ infrastructure, enabling existing TCC-based distributed transactions to function through the updated interceptor framework.

compatible/src/main/java/io/seata/rm/tcc/interceptor · high confidence

Users can now store and retrieve configuration data in a Zookeeper cluster. This change introduces the \ZookeeperConfiguration\ class and its provider, which use the Apache Curator client to manage configuration nodes. The implementation includes connection management, path checking, and data reading/writing via the Curator framework, enabling Seata to synchronize configuration state across distributed nodes using Zookeeper as the backend store.

config/seata-config-zk/src/main · high confidence

The codebase now includes a new Zookeeper registry implementation for service discovery. This adds the \ZookeeperRegisterServiceImpl\ which manages service registration and subscription via Apache Curator, along with the \ZookeeperRegistryProvider\ and its corresponding SPI service file, enabling users to configure Zookeeper as their registry center.

discovery/seata-discovery-zk/src/main · high confidence

The Seata framework now supports Zstandard (Zstd) compression. This change introduces the ZstdCompressor and its utility class, which use the ZstdInputStream for decompression, replacing the previous JNI-based approach. The service is registered via the META-INF/services file, enabling users to select Zstd as a compression algorithm.

compressor/seata-compressor-zstd/src/main · high confidence

The \metrics/seata-metrics-registry-compact\ module now includes a new \CompactRegistry\ and supporting classes (\CompactCounter\, \CompactGauge\, \CompactSummary\, \CompactTimer\, \SummaryValue\, \TimerValue\) that provide a lightweight, non-caching metrics registry implementation. The registry is registered via the \META-INF/services\ file, enabling it to be discovered and used as a metrics backend. Tests have been added to verify the behavior of these components.

metrics/seata-metrics-exporter-prometheus, metrics/seata-metrics-registry-compact · high confidence

New SQL initialization scripts have been added to support storing Seata transaction data in additional database engines. The diff shows the addition of \dm.sql\ (Dameng), \kingbase.sql\ (Kingbase), \oscar.sql\ (Oscar), and \sqlserver.sql\ (SQL Server). These files define the necessary schema objects (global\_table, branch\_table, lock\_table, distributed\_lock, and vgroup\_table) tailored to the specific SQL dialects of these databases, enabling users to persist session and lock data in these systems when using 'db' store mode.

script/server/db · high confidence

The \seata-saga-engine-store\ module now provides a relational database implementation for storing and retrieving state machine definitions and execution logs. New interfaces \StateLangStore\ and \StateLogStore\ define the contract for state machine and log operations, while \DbStateLangStore\ and \StateLogStoreSqls\ provide the SQL-based implementation. This change enables users to persist state machine metadata and runtime logs to a database, supporting features like querying state machines by name and tenant, and recording state machine and state instance lifecycle events.

saga/seata-saga-engine-store · high confidence

A new compatibility layer has been added to the \io.seata.saga.engine\ package, providing deprecated wrapper interfaces and classes (such as \AsyncCallback\, \StateMachineConfig\, \StateMachineEngine\, and various repository/store interfaces) that delegate to the underlying \org.apache.seata.saga.engine\ implementation. This allows existing code using the older \io.seata\ package to continue functioning, while signaling that these APIs are deprecated in favor of the new \org.apache.seata\ namespace.

compatible/src/main/java/io/seata/saga/engine · high confidence

New compatibility classes have been added to the \io.seata.spring.annotation\ package, including \GlobalLock\, \GlobalTransactional\, \GlobalTransactionScanner\, \ScannerChecker\, \AutoDataSourceProxyRegistrar\, and \EnableAutoDataSourceProxy\. These classes are marked as \@Deprecated\ and serve as wrappers or compatibility shims for the corresponding components in the \org.apache.seata\ package, ensuring that existing applications using the older package paths continue to function.

compatible/src/main/java/io/seata/spring · high confidence

New scripts and a Python utility are added to the Nacos config-center directory, providing users with multiple ways to initialize configuration data in a Nacos server. The package includes an interactive Python script (nacos-config-interactive.py) and shell script (nacos-config-interactive.sh) that prompt for connection details, and non-interactive counterparts (nacos-config.py and nacos-config.sh) that accept command-line arguments or environment variables to push configuration key-value pairs from a local file to Nacos.

script/config-center/nacos · high confidence

New interactive and script-based configuration upload scripts are added for Apollo, Consul, and ZooKeeper. The scripts read local configuration files and push them to the respective config centers, allowing users to initialize or update their configuration without manual API calls. For Apollo, both an interactive and a non-interactive script are provided. For Consul, both an interactive and a non-interactive script are provided. For ZooKeeper, both an interactive and a non-interactive script are provided.

script/config-center/apollo, script/config-center/consul, script/config-center/zk · high confidence

New data classes (Cluster, ClusterRole, ClusterWatchEvent, Instance, Metadata, MetadataResponse, Node) are added to the common metadata package, providing structured representations for cluster topology, node endpoints, and watch events to support Raft mode and naming server integration.

common/src/main/java/org/apache/seata/common/metadata · high confidence

The Seata protobuf serializer now includes a comprehensive set of Protocol Buffer definitions for transaction protocol messages, including global and branch operations such as begin, commit, rollback, and status reporting. These .proto files, along with the SPI registration for \ProtobufSerializer\ and \GrpcSerializer\, enable efficient serialization of distributed transaction data for clients and the TC (Transaction Coordinator).

serializer/seata-serializer-protobuf/src/main/resources · high confidence

New shell and batch scripts are added to the distribution/bin directory to support launching the Seata Naming Server and the main Seata Server. The scripts handle environment setup, JVM parameter configuration (including automatic memory calculation and SkyWalking APM integration), and command-line argument parsing for both Linux/macOS and Windows environments.

distribution/bin · high confidence

The Seata common module introduces three new Java enums—StoreMode, SessionMode, and LockMode—each defining FILE, DB, REDIS, and RAFT as supported storage backends. These enums provide a centralized, type-safe way to configure and validate storage modes for transactions, sessions, and distributed locks, enabling the system to select and verify the appropriate persistence mechanism for each component.

common/src/main/java/org/apache/seata/common/store · high confidence

The Seata runtime can now read configuration from an Apollo server. This change introduces the \ApolloConfiguration\ class, which connects to Apollo to fetch configuration properties and supports adding/removing listeners for configuration changes. The \ApolloConfigurationProvider\ and its SPI registration enable automatic discovery of this provider, allowing users to configure Seata using Apollo as a centralized configuration source.

config/seata-config-apollo/src/main · high confidence

Users can now configure Seata to use a Naming Server for service discovery and registration. This change introduces a new registry provider and implementation that allows clients to register instances, discover cluster nodes, and receive real-time updates about node status changes (online/offline) via the Naming Server. The feature includes a dedicated listener interface, exception handling, and a service provider registration to enable seamless integration with the existing Seata architecture.

discovery/seata-discovery-namingserver · high confidence

New Service Provider Interface (SPI) files have been added to register default interceptors for the Saga engine. Specifically, the system now automatically loads the ServiceTaskHandlerInterceptor, ScriptTaskHandlerInterceptor, LoopTaskHandlerInterceptor, and InSagaBranchHandlerInterceptor via the StateHandlerInterceptor SPI, and the EndStateRouterInterceptor via the StateRouterInterceptor SPI. This enables the engine to discover and apply these standard interception behaviors without manual configuration.

saga/seata-saga-engine/src/main/resources · medium confidence

The core module now includes Service Provider Interface (SPI) configuration files under META-INF/services, registering implementations for authentication (AuthSigner), context management (ContextCore), RPC hooks (RpcHook), and SQL store providers for distributed locks, logging, and other database operations. Additionally, a new gRPC protocol definition (grpcMessage.proto) is introduced to support the gRPC communication protocol.

core/src/main/resources · high confidence

New SQL scripts have been added to create the \tcc\_fence\_log\ table in MySQL, PostgreSQL, Oracle, and OceanBase databases. This table tracks transaction fence logs with columns for global ID, branch ID, action name, status, and timestamps, enabling TCC mode to support idempotency and anti-hanging mechanisms.

script/client/tcc · high confidence

New interfaces and implementations were added to the \io.seata.saga.statelang.domain\ package to provide a compatibility layer for the \org.apache.seata\ API. This includes domain models such as \State\, \StateInstance\, \StateMachine\, and \StateMachineInstance\, along with supporting enums like \StateType\, \ExecutionStatus\, and \RecoverStrategy\. These classes wrap the underlying Apache Seata objects, allowing the compatible module to interact with the state machine execution and configuration while maintaining API compatibility.

compatible/src/main/java/io/seata/saga/statelang · high confidence

Introduced new classes in the \org.apache.seata.core.lock\ package to support local database locking: the \Locker\ interface, the \AbstractLocker\ base class, the \LocalDBLocker\ implementation, and the \RowLock\ data model. These files define the structure for acquiring, releasing, and managing row-level locks within the core module.

core/src/main/java/org/apache/seata/core/lock · high confidence

Added new SQL scripts to initialize the AT mode undo\_log table for Dameng, Kingbase, OceanBase, Oscar, PostgreSQL, and SQL Server. These scripts provide the necessary schema definitions for each respective database system, enabling users to set up the required transactional state tracking tables on these platforms.

script/client/at · high confidence

New SQL scripts have been added to the \script/client/saga/db\ directory to initialize the \seata\_state\_machine\_def\, \seata\_state\_machine\_inst\, and \seata\_state\_inst\ tables. These scripts provide the necessary schema definitions for MySQL, H2, PostgreSQL, Oracle, DB2, and OceanBase, enabling the storage and management of state machine definitions and their runtime instances.

script/client/saga · high confidence

New gRPC interceptors have been added to the Seata gRPC integration module, enabling automatic propagation of transaction context (XID and branch type) across gRPC calls. The \ClientTransactionInterceptor\ injects the transaction ID and branch type into outgoing gRPC headers, while the \ServerTransactionInterceptor\ extracts these headers to restore the transaction context on the server side. This ensures that distributed transactions are correctly tracked and managed across gRPC service boundaries.

extensions/rpc/seata-grpc · high confidence

New shell scripts, etcd3-config-interactive.sh and etcd3-config.sh, were added to the etcd3 configuration center. These scripts automate the process of uploading configuration data to an etcd3 cluster via the REST API, supporting both interactive input and command-line argument modes. This allows users to easily initialize their etcd3 configuration without manual API calls.

script/config-center/etcd3 · high confidence

The core module now includes default logging configurations for both Log4j (log4j.properties) and Logback (logback.xml). These files establish baseline logging behaviors, with Log4j configured for console and rolling file appender outputs, while Logback is set to output to the console at the INFO level.

core/src/main · high confidence

Introduced new Java classes in the common module to support the NamingServer feature. The diff adds MetaResponse, NamingServerNode, and Unit, which define the data structures for cluster information, node status, and unit management. These models enable the system to handle metadata related to the naming server, including tracking terms, units, and instance lists.

common/src/main/java/org/apache/seata/common/metadata/namingserver · high confidence

A new \CallRm\ utility class was added to the mock server to facilitate remote procedure calls for branch commit, rollback, and undo log deletion. This provides a concrete implementation for interacting with the mock server's RM interface, supporting the removal of the dependency on the \seata-server\ module.

mock-server/src/main/java/org/apache/seata/mockserver/call · high confidence

The mock-server module now includes a complete Java implementation for a mock Seata server, including the main entry point (MockServer), a coordinator (MockCoordinator) that handles transaction requests and responses, and a Netty-based remoting server (MockNettyRemotingServer) that registers processors for various transaction message types. This provides a standalone, in-memory mock server for testing purposes.

mock-server/src/main/java/org/apache/seata/mockserver · high confidence

The mock server now includes new processor classes (MockHeartbeatProcessor, MockOnReqProcessor, MockOnRespProcessor, MockRegisterProcessor, and MockRemotingProcessor) that handle heartbeat, request, response, and registration RPC messages. This allows the mock server to process and respond to these specific message types during testing.

mock-server/src/main/java/org/apache/seata/mockserver/processor · high confidence

This change introduces new integration modules that enable automatic propagation of distributed transaction context (XID and branch type) across RPC boundaries for bRPC, Alibaba Dubbo, and HSF. For bRPC, client and server interceptors are added to attach and bind transaction context. For Alibaba Dubbo, consumer and provider filters are introduced to handle transaction context in the RPC header. For HSF, consumer and provider filters are added to propagate transaction context. Each module includes corresponding unit tests to verify the transaction propagation behavior.

(repo-wide) · high confidence

The integration-tx-api module now includes a new common fence mechanism to track and clean up transaction logs, along with a TCC hook system for intercepting TCC lifecycle events. This includes the \CommonFenceConfig\ for scheduled cleanup of expired fence records, the \FenceHandler\ interface and its default implementation for managing fence states, and the \TccHook\/\TccHookManager\ for registering and executing custom logic before and after TCC prepare, commit, and rollback phases. Additionally, the module introduces an \ActionContextUtil\ to extract and manage context data from method parameters, and an \ActionInterceptorHandler\ to process these actions.

integration-tx-api/src/main/java/org/apache/seata/integration · high confidence

The Seata codebase introduces a new centralized configuration system by adding \ConfigurationKeys.java\, \Constants.java\, and \DefaultValues.java\ in the common module. These files define all configuration property names, constant strings, and default values for client and server settings, replacing scattered or hardcoded configuration references. Additionally, new entity classes \GlobalLockParam\, \GlobalSessionParam\, \BranchSessionVO\, and \GlobalSessionVO\ are added to support the server console's data transfer and query operations for global and branch sessions.

common/src/main/java/org/apache/seata/common · high confidence

The codebase now includes database-specific SQL implementations for lock and log stores, supporting MySQL, Oracle, PostgreSQL, H2, SQL Server, Kingbase, DM, Oceanbase, Oscar, and PolarDB-X. This change introduces new classes such as \LockStoreSql\ and \LogStoreSqls\ interfaces along with their respective database-specific implementations (e.g., \MysqlLockStoreSql\, \OracleLockStoreSql\, \SqlServerLockStoreSql\, \KingbaseLockStoreSql\, \DmLockStoreSql\, \OceanbaseLockStoreSql\, \OscarLockStoreSql\, \PolarDBXLockStoreSql\, \PostgresqlLockStoreSql\, \H2LogStoreSqls\, \DmLogStoreSqls\, \KingbaseLogStoreSqls\). These classes provide tailored SQL statements for each database type, enabling the system to interact with various databases for distributed lock and transaction log storage.

core/src/main/java/org/apache/seata/core/store/db/sql · high confidence

The console now enforces authentication using a custom Spring Security configuration with JWT token handling. This includes a login endpoint at /api/v1/auth/login that issues JWTs, a filter to validate tokens on subsequent requests, and a security configuration that protects all endpoints by default while allowing specific paths to be ignored via configuration. Additionally, long values in JSON responses are serialized as strings to prevent JavaScript precision loss, and a REST client is configured for internal service calls.

console · high confidence

The RaftRegistryProvider and RaftRegistryServiceImpl classes have been added to the discovery module, enabling the system to discover and manage Raft cluster nodes through a dedicated registry service. This implementation handles authentication, token management, and metadata synchronization across the Raft cluster, supporting both HTTP/1 and HTTP/2 watch protocols for cluster state updates.

discovery/seata-discovery-raft/src/main/java · high confidence

Added the \SagaTransactionalTemplate\ interface and its \DefaultSagaTransactionalTemplate\ implementation in the \saga/seata-saga-spring\ module. This new template provides a standardized way to execute business logic with global transactions in SAGA mode, managing transaction lifecycle events such as begin, commit, and rollback, while also handling branch registration and reporting.

saga/seata-saga-spring/src/main/java/org/apache/seata/saga/engine/tm · high confidence

Added new interfaces and classes in the sqlparser-core module to support SQL parsing and recognition. This includes the \EscapeHandler\ interface and its factory for handling SQL keyword escaping, recognizer interfaces (\SQLRecognizer\, \SQLInsertRecognizer\, \SQLUpdateRecognizer\, etc.) for different SQL statement types, and structural model classes (\ColumnMeta\, \IndexMeta\, \SqlMethodExpr\) to represent database metadata and expressions.

sqlparser/seata-sqlparser-core · high confidence

The saga/seata-saga-rm module now provides the core runtime components for Saga transaction support, including the RMHandlerSaga handler, SagaResource, and SagaResourceManager. These classes implement the resource management and commit/rollback logic for SAGA branches, and are registered via the new META-INF/services files for automatic discovery.

saga/seata-saga-rm · high confidence

The \integration-tx-api\ module now includes new classes to support TCC (Try-Confirm-Cancel) transactional semantics. \BusinessActionContext\ and \BusinessActionContextUtil\ provide a thread-local context for sharing business data between the TCC try and confirm/cancel phases, including automatic tracking of context mutations. \BusinessActionContextParameter\ is a new annotation that allows method parameters to be automatically extracted and passed into the action context. \ParamType\ defines the source of the parameter (method argument or field).

integration-tx-api/src/main/java/org/apache/seata/rm · high confidence

Added a new eventing subsystem in the core module, defining a base Event interface and an EventBus interface with register, unregister, and post operations. Implemented the EventBus with a Guava-based GuavaEventBus that supports both synchronous and asynchronous posting via a thread pool. Introduced specific event classes: ExceptionEvent for error tracking, GlobalTransactionEvent for global transaction lifecycle and status updates, and RateLimitEvent for tracking rate-limiting scenarios with trace and application details.

core/src/main/java/org/apache/seata/core/event · high confidence

The metrics module now provides a foundational API for collecting and exporting metrics. New interfaces and classes have been added to support various metric types, including Counter, Gauge, Summary, and Timer, along with supporting types like Id, Measurement, and Clock. The Registry interface defines how metrics are stored and retrieved, while the Exporter interface handles the export of metric data. This establishes the core abstraction for metrics collection within the system.

metrics/seata-metrics-api · high confidence

The saga engine module now includes the foundational interfaces and implementations for the state machine engine, including \StateMachineEngine\, \StateMachineConfig\, and \AsyncCallback\. This adds support for starting, forwarding, and compensating state machine instances, with explicit support for asynchronous execution via callbacks. The implementation also introduces expression evaluation capabilities, allowing dynamic evaluation of expressions and exception matching within the state machine logic.

saga/seata-saga-engine/src/main/java · high confidence

A new \DbAndReportTcStateLogStore\ implementation is added to persist Saga state machine logs to a database and report status to the Transaction Coordinator (TC). This change enables durable, database-backed tracking of state machine instances and their transitions, ensuring that execution state is reliably stored and synchronized with the central transaction coordinator.

saga/seata-saga-spring/src/main/java/org/apache/seata/saga/engine/store · high confidence

The rm module now includes default implementations for resource management and event handling: AbstractRMHandler and AbstractResourceManager provide base logic for branch commit/rollback and registration/reporting, while DefaultRMHandler and DefaultResourceManager act as singletons that dynamically load all registered handlers and resource managers via the EnhancedServiceLoader. A new RMClient utility initializes the Netty remoting client with these defaults, and unit tests verify the routing and behavior of these components.

rm · high confidence

The common module now includes a new service loading mechanism via the \EnhancedServiceLoader\ and supporting classes (\ExtensionDefinition\, \LoadLevel\, \Scope\). This provides a structured way to load and manage extension points with support for singleton or prototype scopes and ordered loading, improving how the framework discovers and initializes components.

common/src/main/java/org/apache/seata/common/loader · high confidence

The discovery module now includes a new file-based registry implementation (FileRegistryProvider and FileRegistryServiceImpl) that reads service group mappings and cluster addresses from configuration files, enabling local file-based service discovery. Additionally, a MultiRegistryFactory has been added to support multiple registry centers simultaneously, allowing users to configure and use multiple registry types (such as Nacos, ZK, or file) in a single deployment. The RegistryType enum has been updated to include a 'Seata' type, and the RegistryService interface has been enhanced with methods for managing alive addresses and handling offline nodes.

discovery/seata-discovery-core/src/main/java/org/apache/seata/discovery/registry · high confidence

Added GlobalStatus enum to define the lifecycle states of global transactions (e.g., Committing, Rollbacking, Committed) and ServerTableColumnsName interface to standardize column names for global, branch, and lock tables. This provides a centralized reference for transaction state management and database schema mapping.

common/src/main/java/org/apache/seata/core · high confidence

The codebase now includes a comprehensive set of new classes for handling distributed transaction protocols. This includes base classes for transaction requests and responses (such as AbstractTransactionRequest, AbstractTransactionResponse, and their specific variants for global and branch operations), as well as concrete request/response pairs for operations like GlobalBegin, GlobalCommit, BranchRegister, BranchCommit, and BranchRollback. Additionally, utility classes for thread management and execution callbacks have been added to the common module. These changes expand the available API for managing transaction states and communicating with the transaction coordinator.

(repo-wide) · high confidence

The tm module now includes a complete set of new classes for managing global transactions, including the DefaultGlobalTransaction implementation, a TransactionManagerHolder for dependency injection, a TMClient for network communication, and a TransactionalTemplate for executing business logic within a transactional context. This change adds the foundational API for starting, committing, and rolling back global transactions, as well as handling failure scenarios and transaction propagation.

tm · high confidence

The core protocol package now includes a new set of abstract base classes (AbstractMessage, AbstractResultMessage, AbstractIdentifyRequest/Response) and concrete message types (e.g., RegisterRMRequest, UnregisterRMRequest, MergeMessage) to support multi-version Seata protocol communication. This change introduces a structured message hierarchy that enables version-aware serialization and deserialization, allowing the system to handle different protocol versions and message types (such as heartbeat, batch results, and merged messages) more robustly.

core/src/main/java/org/apache/seata/core/protocol · high confidence

The core module now includes a new protocol detection system that identifies incoming connections as either HTTP/2, HTTP/1.1, or the native Seata protocol. This enables the server to route traffic to the appropriate handler pipeline, supporting both HTTP/2 and HTTP/1.1 protocols alongside the existing Seata protocol.

core/src/main/java/org/apache/seata/core/protocol/detector · high confidence

The diff adds the core Java source files for the new NamingServer module, including the Spring Boot application entry point, web configuration, controllers for health checks and naming operations, and supporting business objects and value objects. This establishes the foundational structure for the naming server, enabling instance registration, discovery, and cluster monitoring capabilities.

namingserver/src/main/java · high confidence

The \seata-serializer-seata\ module now implements a new, version-aware serialization architecture. The \SeataSerializer\ class routes serialization and deserialization to version-specific implementations (V0, V1, V2), allowing the system to support multiple protocol versions simultaneously. This is supported by a new \MessageCodecFactory\ that selects the appropriate \MessageSeataCodec\ implementation based on the message type and protocol version. The diff introduces a comprehensive set of codecs for all core protocol messages, including \RegisterTM/RM\, \UnregisterRM\, and transactional requests like \GlobalBegin/Commit/Rollback\. This change enables clients and servers to negotiate and use different serialization versions, improving backward compatibility and allowing for future protocol enhancements without breaking existing deployments.

serializer/seata-serializer-seata · high confidence

Seata now supports running on Java virtual threads. A new SPI-based provider system allows the application to switch between platform and virtual thread pools at runtime. The \threadpool\ module introduces a \ThreadPoolProvider\ interface and a \ThreadPoolExecutorFactory\ that resolves the active provider. The \threadpool-loom\ module provides the \VirtualThreadPoolProvider\ implementation, which creates \VirtualThreadPoolExecutor\ and \VirtualScheduledThreadPoolExecutor\ instances backed by virtual threads. Users can configure the thread pool type (e.g., \auto\, \platform\, or \virtual\) to enable virtual threads on JDK 21+.

threadpool, threadpool-loom · high confidence

Users can now visually design and edit Seata Saga state machines using a new web-based editor. The update adds a complete visual designer featuring drag-and-drop state creation, automatic layout and connection routing, and the ability to import and export state machine definitions as JSON files.

saga/seata-saga-statemachine-designer · high confidence

Added new data objects and interfaces in the core store package to support transaction and locking operations. This includes the \GlobalTransactionDO\ and \BranchTransactionDO\ data models, along with the \LogStore\ interface for persisting global and branch transaction states. Additionally, the \LockDO\ data object and the \LockStore\ interface are introduced to manage lock states, while \DistributedLockDO\ and the \DistributedLocker\ interface provide a default implementation for distributed locking.

core/src/main/java/org/apache/seata/core/store · high confidence

The saga state language module now includes a comprehensive set of new domain interfaces and implementations that define the structure of state machines and their states. This includes core state types such as Choice, End, Loop, Script, and Service tasks, along with their corresponding implementation classes. The update also introduces enums for ExecutionStatus and StateType, constants for state machine configuration, and interfaces for managing state machine instances and their execution context. These changes provide the foundational data structures required to parse, validate, and execute complex saga workflows.

saga/seata-saga-statelang/src/main/java · high confidence

The server startup process has been refactored to use Spring Boot, enabling the use of \application.yaml\ for configuration and simplifying the boot sequence. This change introduces the \RaftServer\ component, which initializes the Raft consensus protocol for cluster mode, and adds SSL support for Raft node communication. Additionally, the \ClusterWatcherManager\ is introduced to handle cluster change events and manage HTTP/1.1 and HTTP/2 long-polling watchers for the watch API.

server · high confidence

The mock server now exposes a /help/health endpoint for status checks and /help/expect/result and /help/expect/retry endpoints to set expected transaction outcomes and retry counts, supported by new MockGlobalSession and MockBranchSession model classes.

mock-server/src/main/java/org/apache/seata/mockserver/controller, mock-server/src/main/java/org/apache/seata/mockserver/model · high confidence

The Nacos configuration implementation has been added to the Seata codebase, enabling users to store and retrieve configuration data from a Nacos server. This includes the core \NacosConfiguration\ class for interacting with Nacos, a \NacosConfigurationProvider\ for service discovery, and the necessary \META-INF/services\ registration file. This change allows Seata to use Nacos as a centralized configuration source.

config/seata-config-nacos/src/main · high confidence

Developers can now use the new @SagaTransactional annotation to mark services participating in Saga transactions, providing clearer semantic intent than the legacy @LocalTCC. This change introduces a dedicated annotation, along with the corresponding resource manager, interceptor, and parser implementations, enabling automatic proxy enhancement and compensation action support for Saga patterns.

saga/seata-saga-annotation · high confidence

A new command-line interface for running Seata transaction benchmarks is introduced in the test-suite. The tool supports multiple transaction modes including AT, TCC, XA, SAGA, and SAGA\_ANNOTATION, allowing users to measure performance metrics such as TPS, latency, and error rates. It provides options to configure server address, thread count, duration, and workload parameters, and can export benchmark results to CSV files.

test-suite/seata-benchmark-cli · high confidence

The Spring Boot autoconfigure module now includes a comprehensive set of new Java classes that enable automatic configuration of the Seata client. This includes a new \SeataClientEnvironmentPostProcessor\ that registers various property beans (such as \SeataProperties\, \RmProperties\, \TmProperties\, \LockProperties\, \UndoProperties\, and others) into the Spring environment. Additionally, new configuration classes like \SeataSpringFenceAutoConfiguration\ and property classes for Saga, TCC, and JSON serialization are added, along with corresponding Spring Boot metadata in \additional-spring-configuration-metadata.json\. This allows users to configure Seata client behavior via standard Spring Boot \application.properties\ or \application.yml\ files.

spring/seata-spring-autoconfigure/seata-spring-autoconfigure-client, spring/seata-spring-autoconfigure/seata-spring-autoconfigure-server · high confidence

The Spring module now includes new classes to support Spring's dependency injection and AOP infrastructure. This includes \SpringFenceConfig\ and \SpringFenceHandler\ for managing transaction fences, \GlobalTransactionScanner\ and related interceptors (e.g., \AspectTransactionalInterceptor\, \AdapterSpringSeataInterceptor\) for handling global transactions, and \SeataAutoDataSourceProxyCreator\ with its associated advisor and registrar to automatically wrap \DataSource\ beans with Seata proxies. These additions provide the necessary hooks for Spring to manage distributed transactions and data source proxying.

spring/seata-spring · high confidence

Added new classes in the \org.apache.seata.common.result\ package to standardize API responses: \Result\ provides a base structure with code and message; \SingleResult\ wraps a single data object; \PageResult\ handles paginated lists with page/size/total metadata; \Code\ defines standard response codes (200, 500, 401); and \BaseParam\ provides common pagination parameters. These classes replace the previous ad-hoc result handling with a consistent, reusable model for success and error responses across the application.

common/src/main/java/org/apache/seata/common/result · high confidence

The common module introduces two new utility classes: ObjectHolder, a singleton enum that provides a thread-safe map for storing and retrieving objects by key or class type, and FileLoader, a class that loads files from the file system by attempting multiple path strategies (project directory and system path). These additions provide new capabilities for managing shared state and accessing local files within the Seata framework.

common/src/main/java/org/apache/seata/common/holder, common/src/main/java/org/apache/seata/common/io · high confidence

The common module introduces a suite of new utility classes to improve code reuse and safety. A new ResourceLock class provides a try-with-resources compatible wrapper around ReentrantLock, simplifying lock management. A collection of utility classes (ArrayUtils, BeanUtils, BlobUtils, BufferUtils, CollectionUtils, CompressUtil, ConfigTools, CycleDependencyHandler, DateUtil, DurationUtil, HttpClientUtil, IOUtil, and IdWorker) are added to the org.apache.seata.common.util package, offering standardized implementations for array and collection handling, bean-to-map conversion, GZIP compression, RSA encryption/decryption, safe cyclic-reference handling in stringification, date/duration parsing, and HTTP/1.1 client operations via OkHttp. These utilities replace scattered or ad-hoc implementations with a consistent, reusable API across the Seata codebase.

common/src/main/java/org/apache/seata/common/util · high confidence

The codebase introduces new abstractions and implementations for configuration, data compression, and logging. In the config module, a new \ConfigNotFoundException\ is added, alongside interfaces and implementations (\FileConfig\, \SimpleFileConfig\, \YamlFileConfig\) that enable loading configuration from files, including YAML support. In the core module, a new \Compressor\ interface and \CompressorFactory\ are introduced, supporting multiple compression algorithms (GZIP, ZIP, SEVENZ, BZIP2, LZ4, DEFLATER, ZSTD) via a type enum. Additionally, a new \StackTraceLogger\ utility is added to the logging layer, which conditionally appends stack traces to log messages based on a configurable exception rate.

(repo-wide) · high confidence

Added new constant interfaces and classes to the core module, including ClientTableColumnsName for undo log database columns, ConfigurationKeys (now deprecated in favor of the common module), DBType for supported database types, DubboConstants for RPC context, RedisKeyConstants for transaction and lock keys, and RpcMessageConstants for RPC headers. These provide centralized string constants for internal use across the Seata framework.

core/src/main/java/org/apache/seata/core/constants · high confidence

Added new core model classes to the Seata framework, introducing enums for branch status (BranchStatus) and lock status (LockStatus), along with interfaces for resource management (ResourceManager, TransactionManager) and configuration (GlobalLockConfig). These changes provide the foundational data structures and interfaces needed to track the state of global and branch transactions, as well as distributed locks, enabling more robust transaction lifecycle management.

core/src/main/java/org/apache/seata/core/model · high confidence

Two new default configuration files, \file.conf\ and \registry.conf\, are added to \script/client/conf\. These provide out-of-the-box settings for transport, service groups, and registry options (file, Nacos, Zookeeper, Consul, etc.), allowing users to quickly configure the Seata client without manually creating these files.

script/client/conf · high confidence

The Seata Saga state machine designer has been refactored to use the diagram-js framework instead of the discontinued and vulnerable GGEditor. This change introduces a new visual designer for creating and editing state machines, with configuration files (.babelrc, .eslintrc.json, webpack.config.js) and documentation (README.md, README-zh.md) provided to support the new architecture. Users will experience improved security and a modernized development environment for state machine design.

saga · medium confidence

The core module now introduces a dedicated exception hierarchy under the \org.apache.seata.core.exception\ package to standardize error handling for distributed transactions. A new \TransactionException\ base class and specific subclasses (\GlobalTransactionException\, \BranchTransactionException\, \TmTransactionException\, \RmTransactionException\) provide structured error codes and messages for transactional failures. Additionally, an \AbstractExceptionHandler\ template is added to centralize RPC error handling, automatically mapping exceptions to appropriate response states and logging detailed error information for scenarios like lock key conflicts or RPC failures.

core/src/main/java/org/apache/seata/core/exception · high confidence

The discovery module now includes a new load balancing package with five implementations: ConsistentHashLoadBalance, LeastActiveLoadBalance, RandomLoadBalance, RoundRobinLoadBalance, and XIDLoadBalance, all implementing the LoadBalance interface and registered via LoadBalanceFactory. This provides users with multiple strategies to distribute requests across available service instances.

discovery/seata-discovery-core/src/main/java/org/apache/seata/discovery/loadbalance · high confidence

The saga module introduces a new set of core interfaces and implementations to manage process control, including \ProcessContext\, \ProcessController\, \ProcessRouter\, and \Instruction\. This change adds a hierarchical context for managing variables locally and globally, supports both synchronous and asynchronous event handling via \DirectEventBus\ and \AsyncEventBus\, and provides default handlers for routing and processing business logic. These components enable more flexible and extensible control flow for state machine execution within the SEATA Saga framework.

saga/seata-saga-processctrl · high confidence

The integration-tx-api module now registers specific interceptor and remoting parsers through Java SPI configuration files. The new file META-INF/services/org.apache.seata.integration.tx.api.interceptor.parser.InterfaceParser declares GlobalTransactionalInterceptorParser and CombineTransactionalInterceptorParser, while META-INF/services/org.apache.seata.integration.tx.api.remoting.RemotingParser declares DubboRemotingParser, SofaRpcRemotingParser, and HSFRemotingParser. This enables the framework to automatically discover and utilize these components for transaction interception and remote communication.

integration-tx-api/src/main/resources · high confidence

The Saga engine now supports Spring Expression Language (Spring EL) for evaluating expressions within the workflow. This change adds a new \SpringELExpression\ implementation and its corresponding \SpringELExpressionFactory\, enabling the engine to parse and evaluate Spring EL syntax. The factory configures a restricted evaluation context that denies all type lookups while allowing bean resolution from the Spring ApplicationContext, ensuring secure and controlled expression evaluation.

saga/seata-saga-spring/src/main/java/org/apache/seata/saga/engine/expression · high confidence

A new SpringBeanServiceInvoker class was introduced in the saga engine's invoker package. This component enables the Seata saga engine to invoke Spring-managed beans as service tasks, supporting both synchronous and asynchronous execution via a thread pool, along with configurable retry logic and method caching.

saga/seata-saga-spring/src/main/java/org/apache/seata/saga/engine/invoker · high confidence

The Seata Spring Boot starter now includes a new \SeataCoreAutoConfiguration\ that registers the \SpringApplicationContextProvider\ bean, and a \SeataCoreEnvironmentPostProcessor\ that initializes a mapping of configuration prefixes to their corresponding Spring \@ConfigurationProperties\ classes (such as \LogProperties\, \ShutdownProperties\, \TransportProperties\, and various config/registry property classes). Additionally, a \SeataPropertiesLoader\ is introduced to load old-style Seata configuration files and merge them into the Spring environment, while \StarterConstants\ defines the configuration key prefixes. This change enables automatic binding of Seata settings from \application.properties\ or \application.yml\ and ensures legacy configuration files are still respected during startup.

spring/seata-spring-autoconfigure/seata-spring-autoconfigure-core · high confidence

Users can now define and use custom configuration providers by implementing the ConfigurationProvider interface and registering it via the ServiceLoader mechanism. The diff introduces CustomConfigurationProvider, which loads a configuration based on a 'name' property, and includes test implementations (CustomConfigurationForTest, CustomConfigurationProviderForTest) to validate the new behavior. This allows for flexible, user-defined configuration sources beyond the built-in types.

config/seata-config-custom · high confidence

The TCC module now provides a complete implementation for managing TCC (Try-Confirm-Cancel) transactional resources. This includes new core classes such as TCCResource, TCCResourceManager, and RMHandlerTCC to handle resource registration and lifecycle. The system introduces the @LocalTCC and @TwoPhaseBusinessAction annotations to mark TCC services and define commit/rollback methods. A dynamic proxy mechanism via TccActionInterceptorHandler intercepts TCC calls to manage transaction contexts. Additionally, JSON parsing capabilities are provided through FastJsonParser, GsonJsonParser, and JacksonJsonParser, all of which are marked as deprecated in favor of a common core module. Service discovery is configured via SPI files for ResourceManager and InterfaceParser.

tcc · high confidence

The serialization module has been restructured with a new \Serializer\ interface and a \SerializerServiceLoader\ that dynamically loads serializer implementations. A \SerializerSecurityRegistry\ has been added to enforce a whitelist of allowed classes for deserialization, explicitly denying dangerous classes like \java.lang.Runtime\ and \javax.naming.InitialContext\ to mitigate deserialization vulnerabilities. The \SerializerType\ enum now includes entries for \FURY\ and \FORY\, and the loader supports aliasing \fury\ to \fory\. This change enhances security by restricting deserialized classes and provides a more flexible, extensible serialization framework.

core/src/main/java/org/apache/seata/core/serializer · high confidence

The Druid SQL parser module was refactored to improve classloader isolation and introduce a new base recognizer structure. A new \BaseRecognizer\ abstract class was added to handle common SQL parsing logic, including WHERE clause and LIMIT/OBJECT handling. The \DefaultDruidLoader\ was introduced to load the embedded Druid JAR, and a \DruidIsolationClassLoader\ was created to isolate Druid classes from the main application classpath, preventing potential conflicts. Additionally, a \DruidDbTypeAdapter\ was added to map database types (e.g., PolarisDB X to MySQL). The \DruidSQLRecognizerFactoryImpl\ was updated to use the new base classes and handle various SQL statement types, including Oracle multi-insert statements. The \SupportSqlWhereMethod\ class was added to manage supported SQL methods in WHERE clauses.

sqlparser/seata-sqlparser-druid · high confidence

The RPC core module has been refactored to introduce a new set of interfaces and implementations for message handling and remoting. New abstractions include \ClientMessageListener\, \ClientMessageSender\, \ServerMessageListener\, and \ServerMessageSender\ to decouple message processing logic. The \RemotingClient\ and \RemotingServer\ interfaces now define the primary communication contracts, while \AbstractNettyRemoting\ provides the base implementation for Netty-based remoting. Additionally, a \ShutdownHook\ utility was added to manage the lifecycle of disposable resources, and \RpcContext\ was introduced to manage RPC state per channel. These changes streamline the internal architecture, making the RPC layer more modular and easier to extend.

core/src/main/java/org/apache/seata/core/rpc · high confidence

The rm-datasource module has been refactored to introduce a new layered proxy architecture. A new base class, BaseDataSourceResource, has been added to manage resource states and caching. The existing DataSourceProxy and related classes have been restructured into abstract base classes (AbstractDataSourceProxy, AbstractConnectionProxy, AbstractStatementProxy, etc.) to support specific implementations. Additionally, new handlers (RMHandlerAT, RMHandlerXA) and a global lock execution template (GlobalLockTemplate) have been introduced to better separate AT and XA transaction handling and global lock execution logic.

rm-datasource/src/main/java · high confidence

New Service Provider Interface (SPI) configuration files have been added to enable compatibility with the Seata distributed transaction framework. Specifically, the system now registers \SagaResourceManager\ and \TCCResourceManager\ for resource management, \TccActionInterceptorParser\ and \GlobalTransactionalInterceptorParser\ for interceptor parsing, and \LocalTCCRemotingParser\ for remoting operations. These changes allow the application to automatically discover and utilize Seata's transactional capabilities without manual configuration.

compatible/src/main/resources · high confidence

A new \LocalTCCRemotingParser\ class has been added to the compatible module to maintain backward compatibility with Seata versions prior to 2.1. This parser enables the system to recognize and process the legacy \@LocalTCC\ annotation on service implementations and interfaces, ensuring that older TCC-based transactions continue to function correctly during upgrades.

compatible/src/main/java/io/seata/rm/tcc/remoting · high confidence

New adapter classes are added to the \io.seata.integration.tx\ package to bridge the legacy \io.seata\ API with the new \org.apache.seata\ implementation. This includes \ActionContextUtil\ and \ActionInterceptorHandler\ to handle TCC context extraction and annotation processing, \GlobalTransactionalInterceptorHandler\ and \GlobalTransactionalInterceptorParser\ to manage global transactional aspects, and thin interface wrappers for JSON and remoting parsers. These changes ensure backward compatibility for existing applications using the older Seata transaction APIs.

compatible/src/main/java/io/seata/integration/tx · high confidence

A new TCC resource manager implementation is added to the compatible module, providing a bridge that converts the newer io.seata.rm.tcc.api.BusinessActionContext into the legacy io.seata.rm.tcc.api.BusinessActionContext. This ensures that components relying on the older context class continue to function correctly during the transition, resolving the incompatibility issue.

compatible/src/main/java/io/seata/rm/tcc · medium confidence

The \compatible\ module now includes a set of new Java classes in the \io.seata.tm\ and \io.seata.tm.api\ packages, including \TMClient\, \DefaultFailureHandlerImpl\, \DefaultGlobalTransaction\, \FailureHandler\, \GlobalTransaction\, \GlobalTransactionContext\, \GlobalTransactionRole\, \TransactionalTemplate\, \Propagation\, and \SuspendedResourcesHolder\. All these classes are marked as \@Deprecated\ and serve as compatibility wrappers that delegate to the corresponding \org.apache.seata\ implementations, ensuring backward compatibility for existing users of the \io.seata\ package namespace.

compatible/src/main/java/io/seata/tm · high confidence

The config module now introduces a new processor architecture in the \org.apache.seata.config.processor\ package to handle configuration files. A \ConfigDataType\ enum and \ConfigProcessor\ utility were added to resolve and route configuration data based on file type (YAML or properties). New \Processor\ interface and implementations (\ProcessorProperties\, \ProcessorYaml\) enable standardized parsing of these formats, with YAML processing secured via \SafeConstructor\ to prevent unsafe deserialization vulnerabilities.

config/seata-config-core/src/main/java/org/apache/seata/config/processor · high confidence

The \compatible\ module now includes a set of deprecated wrapper classes and interfaces that delegate to the \org.apache.seata\ equivalents. This includes \AuthSigner\, \Compressor\, \DubboConstants\, \ContextCore\, \RootContext\, \TransactionException\, \TransactionExceptionCode\, \BranchType\, \GlobalStatus\, \ResourceManager\, \RmNettyRemotingClient\, \TmNettyRemotingClient\, \Serializer\, \LockStoreSql\, \LogStoreSqls\, and \RMClient\. These wrappers are intended to maintain backward compatibility for existing codebases while encouraging migration to the new \org.apache.seata\ package.

compatible/src/main/java/io/seata/core · high confidence

New files were added to the common module to provide backward compatibility: a deprecated \LockStrategyMode\ enum and a \StringUtils\ utility class. The \StringUtils\ class acts as a compatibility layer for the \dubbo-filter-seata\ integration, delegating all string operations to the corresponding methods in \org.apache.seata.common.util.StringUtils\. These additions support lower versions of SPI and ensure compatibility with the integration-tx-api and spring modules.

compatible/src/main/java/io/seata/common · high confidence

The distribution package now includes the full text of several open-source licenses to ensure compliance and transparency. Specifically, the repository adds license files for Apache-1.1, CDDL+GPL-1.1, CDDL-1.0, EPL-1.0, EPL-2.0, HdrHistogram-BSD-2-Clause, LatencyUtils-BSD-2-Clause, and Python-2.0. These files provide the legal terms under which these respective components are distributed, allowing users to review the licensing conditions for each component.

distribution/licenses · high confidence

The \DbStateMachineConfig\ class was added to \saga/seata-saga-spring\, providing a Spring-based configuration for database-backed state machines, including initialization of the state log store, state language store, and transactional template. Additionally, \ResourceUtil\ was added to \saga/seata-saga-spring\ to handle Spring resource loading for state language files. These changes support the removal of Spring dependencies from the core engine by moving Spring-specific wiring and resource handling into the Spring module.

saga/seata-saga-spring/src/main/java/org/apache/seata/saga/engine/config, saga/seata-saga-spring/src/main/java/org/apache/seata/saga/engine/utils · medium confidence

The configuration-related classes in the io.seata.config package, including the Configuration interface, AbstractConfiguration, FileConfiguration, and related event/listener types, are now marked as @Deprecated. This signals that the existing configuration API is being phased out in favor of a newer, non-deprecated configuration system.

config/seata-config-core/src/main/java/io · high confidence

The \io.seata.rm.tcc.api\ package now includes \BusinessActionContext\, \BusinessActionContextParameter\, \LocalTCC\, and \TwoPhaseBusinessAction\ as deprecated wrappers or annotations. These additions provide a compatibility layer for existing TCC (Try-Confirm-Cancel) implementations, ensuring that older code relying on these specific classes and annotations continues to function while signaling that these APIs are superseded.

compatible/src/main/java/io/seata/rm/tcc/api · high confidence

Added deprecated wrapper classes in the \io.seata.integration.http\ package (\DefaultHttpExecutor\, \SeataWebMvcConfigurer\, \TransactionPropagationInterceptor\, \JakartaSeataWebMvcConfigurer\, and \JakartaTransactionPropagationInterceptor\) that delegate to the corresponding \org.apache.seata\ implementations. These shims maintain backward compatibility for existing code while signaling that the \io.seata\ package is deprecated in favor of the \org.apache.seata\ namespace.

compatible/src/main/java/io/seata/integration/http · high confidence

The \compatible\ module now includes a set of deprecated wrapper classes and interfaces that delegate to the new \org.apache.seata\ package. Specifically, \DataSourceProxy\, \DataSourceProxyXA\, \InsertExecutor\, \JacksonSerializer\, \KryoTypeSerializer\, and \ProtostuffDelegate\ are added to the \io.seata.rm.datasource\ hierarchy. These classes implement the corresponding interfaces from \org.apache.seata.rm.datasource\, providing a compatibility layer for existing users while the main implementation has moved to the new package.

compatible/src/main/java/io/seata/rm/datasource · high confidence

Added deprecated wrapper interfaces in the \io.seata.discovery\ package (\LoadBalance\, \RegistryProvider\, and \RegistryService\) that extend the corresponding \org.apache.seata\ interfaces. These changes provide backward compatibility for existing SPI implementations while signaling that the \io.seata\ package is deprecated in favor of the new \org.apache.seata\ namespace.

compatible/src/main/java/io/seata/discovery · high confidence

The legacy gRPC interceptor classes, ClientTransactionInterceptor and ServerTransactionInterceptor, have been marked as deprecated. These classes now extend the corresponding implementations from the org.apache.seata package, indicating a migration path for users to adopt the updated API.

compatible/src/main/java/io/seata/integration/grpc · high confidence

The project now enforces structured thread pool management by prohibiting direct creation of \Thread\, \Executors\, or \ThreadPoolExecutor\ instances in production code, requiring the use of \ThreadPoolExecutorFactory\ instead. Additionally, new Checkstyle rules and an IDE code style configuration have been added to standardize naming conventions, formatting, and suppress rules for generated parser files.

style · medium confidence

The rm-datasource module now registers service providers for a broader range of databases and serialization formats. New database support includes Kingbase, OceanBase, and Shentong, alongside existing MySQL, Oracle, PostgreSQL, SQL Server, MariaDB, PolarDB-X, DM, and Oscar. Additionally, the system now supports Fastjson2, Jackson, Gson, and Fory for JSON serialization, and introduces Fory and Fastjson2 as undo log parsers, enabling more flexible data handling and storage options.

rm-datasource/src/main/resources · high confidence

The Hessian serializer module now includes a new FieldCountCappingDeserializer that rejects excessively large field counts to mitigate out-of-memory risks from malicious Hessian class definitions. Additionally, the HessianSerializerFactory enforces a serialization whitelist and blacklist via the SerializerSecurityRegistry, restricting which classes can be deserialized. These changes improve the security posture of the Hessian serialization path by limiting dangerous class loading and preventing resource exhaustion attacks.

serializer/seata-serializer-hessian · high confidence

The database store module now uses a dedicated classloader to load MySQL JDBC drivers, addressing issues where drivers could not be found or loaded correctly. This change ensures that the appropriate database driver dependencies are properly recognized, resolving previous errors related to missing or misconfigured MySQL driver classes.

core/src/main/java/org/apache/seata/core/store/db · medium confidence

The Nacos registry functionality has been restructured into two new classes: NacosRegistryProvider, which implements the RegistryProvider interface to supply the Nacos registry service, and NacosRegistryServiceImpl, which implements the RegistryService interface to handle Nacos-specific registration, unregistration, subscription, unsubscription, and lookup operations. This change introduces a provider-based architecture for the Nacos discovery module.

discovery/seata-discovery-nacos/src/main/java · high confidence

The configuration core module has been refactored to introduce a new \ConfigurationCache\ that wraps the original configuration implementation with a proxy, enabling automatic caching of configuration values. This change introduces new interfaces such as \ConfigurationChangeListener\ and \ConfigChangeListener\ to handle configuration change events, and adds an \AbstractConfiguration\ base class to standardize type-specific getter methods (short, int, long, boolean, duration). The \ConfigurationFactory\ now builds a cached configuration instance by default, which should improve performance for repeated configuration reads while maintaining backward compatibility with existing configuration sources like file-based configs.

config/seata-config-core/src/main/java/org/apache/seata/config · medium confidence

The core context storage mechanism has been refactored to support pluggable implementations for managing thread-local state. A new \ContextCore\ interface and \ContextCoreLoader\ allow the runtime to select between \ThreadLocalContextCore\ and \FastThreadLocalContextCore\ (leveraging Netty's \FastThreadLocal\) for storing transaction identifiers and configuration. This change provides a more flexible and potentially higher-performance way to access global lock configurations and transaction IDs (\XID\) across the application.

core/src/main/java/org/apache/seata/core/context · high confidence

The Seata Spring Boot starter has been refactored to replace the previous monolithic auto-configuration with four distinct, specialized components: SeataAutoConfiguration, SeataDataSourceAutoConfiguration, SeataHttpAutoConfiguration, and SeataSagaAutoConfiguration. This change improves compatibility with Spring Boot 4.x by explicitly supporting the new \org.springframework.boot.jdbc.autoconfigure.DataSourceAutoConfiguration\ alongside the existing Spring Boot 2.x/3.x \DataSourceAutoConfiguration\. Users will see these four auto-configuration classes being registered via \spring.factories\ and \AutoConfiguration.imports\, each handling a specific aspect of Seata integration: core transaction scanning, data source proxying, HTTP interceptor, and Saga state machine engine setup.

spring/seata-spring-boot-starter · high confidence

A new DefaultStateMachineConfig class has been added to the saga engine, providing Spring-specific initialization that registers the Spring EL expression factory and Spring Bean service invoker, enabling seamless integration with the Spring application context.

saga/seata-saga-spring/src/main/java/org/apache/seata/saga/engine/impl · medium confidence

The project now enforces a consistent build environment and tooling setup. A new .mvn/jvm.config file sets the PMD language to English, ensuring consistent diagnostic messages. Additionally, the Maven wrapper is configured to use a specific, pinned version of Maven (3.9.5) and the Maven wrapper JAR (3.1.1), ensuring all developers and CI systems use the same build tool version.

.mvn · high confidence

The \org.apache.seata.common.exception\ package has been restructured with a new, standardized exception hierarchy. A central \FrameworkException\ class now serves as the base for most framework-level errors, utilizing a new \FrameworkErrorCode\ enum to provide structured error codes and messages. This change introduces several new specific exception types, including \AuthenticationFailedException\, \DataAccessException\, \EurekaRegistryException\, \JsonParseException\, \NotSupportYetException\, \ParseEndpointException\, \RedisException\, \RepeatRegistrationException\, \RetryableException\, \SeataRuntimeException\, \ShouldNeverHappenException\, \SkipCallbackWrapperException\, and \StoreException\. Additionally, utility classes \ExceptionUtil\ and \ResourceBundleUtil\ have been added to support error message formatting and resource bundle management.

common/src/main/java/org/apache/seata/common/exception · high confidence

The saga state language module now supports multiple JSON serialization and parsing implementations. Users can choose between Fastjson, Fastjson2, Jackson, and Gson for serializing state machine definitions, and between Fastjson and Jackson for parsing. Additionally, rule-based validation for state machine definitions is now explicitly registered via service provider interfaces, ensuring that state name existence, finite termination, and no recursive sub-state-machine rules are automatically applied.

saga/seata-saga-statelang/src/main/resources · medium confidence

The distribution directory now includes updated LICENSE and NOTICE files for the main project, naming server, and server components. These files contain the Apache License 2.0 text and attribution notices for third-party dependencies such as Spring Boot, Netty, and Jackson. The update ensures proper legal compliance and accurate copyright attribution for all included software.

distribution · high confidence

The META-INF/services files for config, processor, registry, and load balance components have been updated to reference the new org.apache.seata package structure. This change aligns the service provider interfaces with the reorganized package names, ensuring the framework can correctly discover and load the appropriate implementations for configuration, processing, and service discovery.

(repo-wide) · high confidence

Add unit tests for Zookeeper registry service; Add unit tests for the Code class; Added English error code resource file for testing; Added Nacos configuration integration tests; Added Nacos registry and config test resources; Added comprehensive unit tests for RaftRegistryServiceImpl; Added mock implementations for JDBC components; Added test configuration files and service provider definitions for Nacos config module; Added test configuration files for Raft-based discovery; Added test configuration files for Seata config-core; Added test configuration files for Seata discovery and datasource modules; Added test configuration files for core module unit tests; Added test configuration files for discovery and config backends; Added test configuration files for integration tests; Added test coverage for custom registry provider; Added test resources for service provider interfaces; Added test resources for the Hello SPI interface; Added test support for RegistryFactory; Added tests for Oracle data types and MySQL update joins; Added tests for ResourceIdInitializer; Added tests for the Seata Saga Spring module; Added unit and integration tests for Nacos configuration; Added unit and integration tests for the etcd3 discovery module; Added unit tests for ConsoleRemotingFilter; Added unit tests for Consul configuration; Added unit tests for Consul registry service; Added unit tests for JdbcUtils and XAUtils; Added unit tests for Nacos registry implementation; Added unit tests for ObjectHolder and file-based configuration readers; Added unit tests for RPC status tracking; Added unit tests for SQL parsing and metadata structures; Added unit tests for Seata common exception classes; Added unit tests for Zookeeper configuration; Added unit tests for common utility classes; Added unit tests for configuration processing components; Added unit tests for core module components; Added unit tests for data source executors; Added unit tests for discovery and load balancing components; Added unit tests for low-coverage saga engine components; Added unit tests for protobuf serialization converters; Added unit tests for rm-datasource components; Added unit tests for the Apollo configuration module; Added unit tests for the ResourceLock class; Added unit tests for the Seata Saga state language module; Added unit tests for the compatible module.

This change updates the Maven build configuration and dependency management for the Seata project. The \build/pom.xml\ file defines the base build structure, including plugin versions and properties, while \bom/pom.xml\ serves as a Bill of Materials to manage transitive dependency versions. The \all/pom.xml\ aggregates all Seata modules into a single artifact, and \compatible/pom.xml\ provides a compatibility layer for the \io.seata\ namespace. Additionally, the \compressor/pom.xml\ and its sub-modules (e.g., \seata-compressor-all\, \seata-compressor-bzip2\) are updated to manage compression-related dependencies. These changes ensure consistent dependency versions and build settings across the project.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 48.

• Code Health 74
• Architecture 99
• Maturity 70
• Readiness 49
• Security 52
• Domain Modelling 100
• Accessibility 37

• 300 commits — 218 feature/other, 82 fixes

• changes/en-us — 75 commits
• rm-datasource/src — 30 commits
• core/src — 19 commits
• console/src — 18 commits
• server/src — 18 commits
• (root) — 14 commits
• .github/workflows — 11 commits
• common/src — 9 commits
• namingserver/src — 8 commits
• compatible/src — 7 commits
• integration-tx-api/src — 7 commits
• test-suite/seata-benchmark-cli — 6 commits
• build/pom.xml — 4 commits
• saga/seata-saga-engine — 3 commits
• seata-spring-autoconfigure/seata-spring-autoconfigure-server — 3 commits
• serializer/seata-serializer-fury — 3 commits
• compatible/README.md — 2 commits
• config/seata-config-core — 2 commits
• console/pom.xml — 2 commits
• discovery/seata-discovery-etcd3 — 2 commits

• fix: bugfix : fastjson2 JSONB concurrent ref deserialization (#8160)
• fix: bugfix: fix comma missing (#7856)
• fix: bugfix: Avoid null advice during AOT proxy creation (#8106)
• fix: bugfix: Github Action workflow does not run the corresponding Kotlin test (#7482)
• fix: bugfix: Use xaActive to determine whether xaResource needs to execute the end method (#7708)
• fix: bugfix: adjust the order of org.apache.seata.saga.rm.SagaResourceManage (#7622)
• fix: bugfix: consoleApiService that could not be found (#7960)
• fix: bugfix: correct server port and naming server port (#7879)
• fix: bugfix: different element order in two lists causes failure to set the index as primary key index (#7965)
• fix: bugfix: empty jacoco report on local when jdk above 17 (#7956)
• fix: bugfix: ensure the Jakarta-related package paths are correct (#7940)
• fix: bugfix: ensure visibility of rm and The methods in MockTest are executed in order (#7662)
• fix: bugfix: fix Byte[] type to ensure the correct primary key value. (#7761)
• fix: bugfix: fix DM transaction rollback not using database auto-increment primary keys (#7643)
• fix: bugfix: fix Groovy dependency conflict causing saga test failure (#8134)
• fix: bugfix: fix IllegalArgumentException when GET request has request body (#8035)
• fix: bugfix: fix KingbaseUndoLogManager INSERT_UNDO_LOG_SQL error (#7929)
• fix: bugfix: fix NPE when server-side filter is disabled and filter chain is null. (#7563)
• fix: bugfix: fix PK extraction for batch inserts with SQL functions (#8124)
• fix: bugfix: fix SerialArray equals() method for multi-dimensional array comparison (#7471)
• …and 280 more

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

apache/incubator-seata 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.