apache/dolphinscheduler

This system is Apache DolphinScheduler, a distributed, extensible platform for orchestrating complex data workflow pipelines. It provides a comprehensive API and UI for managing workflow definitions, executing tasks across diverse data sources and compute engines, and handling alert notifications through a pluggable architecture. The platform supports high-availability deployments via multiple registry backends and offers robust observability, security, and cloud-native integration capabilities.

94 changes.

This period marks the migration from EasyScheduler to Apache DolphinScheduler, involving a complete codebase restructuring into a multi-module Maven project with a Vue 3 frontend. It introduces a comprehensive plugin-based architecture for tasks, data sources, and alerts, alongside a new service layer and robust API surface with standardized authentication and security features.

89 changes.

This period focused on significantly broadening the platform's capabilities by introducing a wide array of new task, datasource, and alert plugins for data integration, MLOps, and cloud services. Concurrently, the project modernized its underlying architecture by implementing modular storage, registry, and DAO plugins to support diverse cloud providers and database backends. These changes were complemented by a comprehensive restructuring of the frontend API service layer and the introduction of RPC-based extraction services to improve scalability and observability.

29 changes.

This period focused on introducing a standardized, annotation-driven audit logging framework for API operations and refactoring the workflow execution layer with dedicated delegates and RPC interfaces. It also expanded the platform by adding new task plugins for gRPC, Amazon EMR Serverless, and Alibaba Cloud Serverless Spark, alongside significant improvements to the in-process event bus and centralized plugin configuration.

The API server now exposes health status and operational metrics. A new health indicator reports the API server's status as UP or DOWN based on its connection to the registry service. Additionally, Micrometer-based metrics are now available to track API request counts, HTTP response status codes (2xx through 5xx), resource upload and download sizes, and uncached exceptions.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/metrics · high confidence

This change introduces a new task plugin for managing AWS DataSync tasks within DolphinScheduler. It adds the \DatasyncTask\ implementation, which handles creating, starting, canceling, and tracking the status of DataSync task executions via the AWS SDK. The plugin includes \DatasyncParameters\ to define task configurations such as source/destination location ARNs, schedules, and file filter rules, and registers itself via \DatasyncTaskChannelFactory\ under the name "DATASYNC". Unit tests are provided to verify parameter parsing and hook interactions.

dolphinscheduler-task-plugin/dolphinscheduler-task-datasync · high confidence

Users can now execute AWS Database Migration Service tasks within DolphinScheduler workflows. This change introduces a new task type that allows users to create, start, stop, and delete DMS replication tasks, as well as test endpoint connections. The plugin supports both standard parameter configuration and JSON-based parameter input, enabling flexible setup of source/target endpoints, migration types, and CDC settings. Unit tests are included to verify the hook and task logic.

dolphinscheduler-task-plugin/dolphinscheduler-task-dms · high confidence

Introduces a new EMR task plugin that enables users to submit tasks to AWS Elastic MapReduce. The plugin supports two program types: running a new job flow (EmrJobFlowTask) and adding steps to an existing cluster (EmrAddStepsTask). It includes the task channel factory for registration, parameter validation, and unit tests for both task types.

dolphinscheduler-task-plugin/dolphinscheduler-task-emr · high confidence

Users can now configure and manage AWS SageMaker connections within the Connection Center. This change introduces the SageMaker datasource plugin, which handles connection parameters (AWS access key, secret key, and region) and validates connectivity by checking SageMaker notebook instances. Note that this plugin does not support ad-hoc SQL queries or pooled database connections; it is designed specifically for managing the SageMaker connection lifecycle for use in other task types.

dolphinscheduler-datasource-plugin/dolphinscheduler-datasource-sagemaker · high confidence

Introduces a new task plugin for executing Spark jobs on Alibaba Cloud Serverless Spark. This change adds the core implementation classes (AliyunServerlessSparkTask, AliyunServerlessSparkParameters), the task channel factory for registration, and unit tests to verify job submission, state polling, and cancellation workflows.

dolphinscheduler-task-plugin/dolphinscheduler-task-aliyunserverlessspark · high confidence

Users can now send alert notifications via voice calls using the Alibaba Cloud Voice service. This new plugin, registered as 'AliyunVoice', requires configuration of the Alibaba Cloud AccessKey ID and Secret, the API endpoint address, the target phone number, and a TTS (Text-to-Speech) code. The implementation handles the creation of the Alibaba Cloud client, constructs the voice call request, and reports success or failure based on the API response.

dolphinscheduler-alert/dolphinscheduler-alert-plugins/dolphinscheduler-alert-aliyunVoice/src/main · high confidence

Users can now execute jobs on Amazon EMR Serverless applications directly from DolphinScheduler workflows. This new task type allows you to submit Spark or Hive jobs by specifying the application ID, IAM execution role, and a StartJobRun request JSON, with the plugin handling job submission, status tracking, cancellation, and failover recovery.

dolphinscheduler-task-plugin/dolphinscheduler-task-emr-serverless · high confidence

This change introduces the Apache Doris datasource plugin for DolphinScheduler, enabling users to connect to and execute SQL tasks against Doris databases. The plugin provides the necessary infrastructure including a \DorisDataSourceProcessor\ for handling connection parameters and SQL execution (leveraging MySQL-compatible syntax for statement splitting and comment removal), a \DorisDataSourceChannel\ for managing ad-hoc and pooled data source clients, and associated parameter DTOs. It also includes unit tests to verify the correct creation of data source channels and processing of connection parameters.

dolphinscheduler-datasource-plugin/dolphinscheduler-datasource-doris, dolphinscheduler-task-plugin/dolphinscheduler-task-linkis · high confidence

Users can now store and manage resources in Azure Blob Storage. This change introduces the AbsStorageOperator and its factory, which handle file uploads, downloads, directory creation, and deletion against an Azure container using the provided connection string and account name.

dolphinscheduler-storage-plugin/dolphinscheduler-storage-abs · high confidence

Users can now log in to DolphinScheduler using Casdoor as a Single Sign-On provider. This change introduces the CasdoorAuthenticator component, which handles the OAuth2 flow by validating the login state, exchanging the authorization code for a token, and parsing the user's JWT to retrieve identity details. It automatically creates new user accounts in DolphinScheduler upon first login and assigns administrative privileges if the Casdoor username matches the configured admin user setting.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/security/impl/sso · high confidence

This change introduces a new ChunJun task type to Apache DolphinScheduler, enabling users to execute data synchronization jobs via the ChunJun engine. The plugin includes the core task implementation (ChunJunTask), parameter handling (ChunJunParameters) for configuring sources, targets, and deployment modes (local, standalone, yarn-session, yarn-per-job), and the necessary SPI channel factory to register the task. It also adds unit tests for the constants and parameter validation logic.

dolphinscheduler-task-plugin/dolphinscheduler-task-chunjun · high confidence

Introduces a new DVC (Data Version Control) task plugin that enables users to manage data assets within their workflows. This new task supports three operations: initializing a DVC repository, uploading data to a remote storage, and downloading data from a remote storage, allowing for better integration of data versioning into machine learning pipelines.

dolphinscheduler-task-plugin/dolphinscheduler-task-dvc · high confidence

Introduces a new Dameng (DM) database datasource plugin, enabling users to connect to and execute SQL tasks against Dameng databases. The plugin includes the DamengDataSourceProcessor for connection management and SQL splitting (using Druid), DamengDataSourceChannel for client creation, and associated parameter DTOs, along with unit tests for the new components.

dolphinscheduler-datasource-plugin/dolphinscheduler-datasource-dameng · high confidence

Introduces a new Dinky task type that allows users to execute FlinkSQL jobs by connecting to a remote Dinky instance via its Open API. The plugin supports both Dinky 0.6.5 and 1.0.0 versions, handling task submission, status tracking, and parameter validation through the new DinkyTask and DinkyParameters classes.

dolphinscheduler-task-plugin/dolphinscheduler-task-dinky · high confidence

The API module now includes a new ExecuteType enum to define workflow and task operation codes (such as repeat running, resume, stop, and execute task), and introduces a Status enum to standardize API response codes and bilingual (English/Chinese) error messages for operations like user management, project handling, and workflow execution.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/enums · high confidence

Users can now configure Google Cloud Storage (GCS) as a backend for the Resource Center. This change introduces the GcsStorageOperator and its factory, enabling file upload, download, deletion, and copying operations against a specified GCS bucket using service account credentials.

dolphinscheduler-storage-plugin/dolphinscheduler-storage-gcs · high confidence

Users can now store and manage resources in Huawei Cloud Object Storage Service (OBS). This change introduces the ObsStorageOperator and its factory, enabling file upload, download, deletion, copying, directory creation, and listing within an OBS bucket configured via access keys and endpoint settings.

dolphinscheduler-storage-plugin/dolphinscheduler-storage-obs · high confidence

Introduces a new Kubeflow task plugin that enables users to submit, track, and cancel Kubeflow jobs (such as TFJobs) within DolphinScheduler workflows. The plugin accepts a Kubernetes cluster configuration and a job YAML definition as parameters, writes them to local files, and executes kubectl commands (apply, get, delete) to manage the job lifecycle. It polls the job status via kubectl get, mapping Kubernetes phases to success or failure states, and supports parameter substitution in the YAML content before execution.

dolphinscheduler-task-plugin/dolphinscheduler-task-kubeflow · high confidence

The K8S datasource plugin now allows users to configure and validate connections to Kubernetes clusters. This change introduces the K8sDataSourceProcessor, which handles parameter validation (kubeConfig and namespace), generates unique datasource identifiers, and performs connectivity checks against the cluster. The plugin registers itself via AutoService and provides the necessary channel factory, though ad-hoc and pooled SQL data clients are currently unsupported for this datasource type.

dolphinscheduler-datasource-plugin/dolphinscheduler-datasource-k8s · high confidence

Users can now authenticate against an LDAP server. This change introduces the LdapAuthenticator and LdapService components, which handle LDAP connection, user search, and credential validation. It supports configurable LDAP URLs, base DNs, SSL/TLS encryption, and admin user filtering. Additionally, it allows automatic creation of local user accounts for LDAP users who do not already exist in the system, based on the configured 'not-exist-action' setting.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/security/impl/ldap · high confidence

The API module now includes a new logging infrastructure with LocalLogClient, RemoteLogClient, and LogClientDelegate components. LocalLogClient handles log retrieval from local storage via the ILogService, while RemoteLogClient fetches logs from remote storage using LogUtils. LogClientDelegate orchestrates these clients, attempting to fetch logs locally first and falling back to remote storage if the local node does not exist or the local fetch fails. This enables the API to retrieve both complete and partial task instance logs from either local or remote sources.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/executor/logging · high confidence

The project now includes a Maven Wrapper, allowing developers to build the project without manually installing Maven. The configuration file specifies the use of Maven version 3.8.4 and the Maven Wrapper JAR version 3.1.0, ensuring consistent build environments across different machines.

.mvn · high confidence

Users can now send alerts to a Prometheus AlertManager instance. This change introduces the \PrometheusAlertChannel\ implementation and its factory, which registers a new alert type named "Prometheus AlertManager". The plugin accepts configuration for the AlertManager URL, optional annotations, and an optional generator URL, then formats and sends alert payloads to the \/api/v2/alerts\ endpoint. Unit tests are included to verify the factory's parameter structure and channel creation.

dolphinscheduler-alert/dolphinscheduler-alert-plugins/dolphinscheduler-alert-prometheus · high confidence

Introduces a new Remote Shell task type that allows users to execute shell scripts on remote hosts via SSH. The plugin includes the task implementation (RemoteShellTask), parameter handling (RemoteShellParameters), and an SSH execution engine (RemoteExecutor) that manages connection, script upload, remote process tracking, and exit code retrieval. It is registered via a TaskChannelFactory so it can be selected in the workflow UI, and unit tests are added to verify the executor's behavior.

dolphinscheduler-task-plugin/dolphinscheduler-task-remoteshell · high confidence

This change introduces a new plugin for connecting to SAP HANA databases. It adds the necessary implementation classes, including the connection parameter models, the data source processor for handling JDBC URL construction and driver management, and the channel factory to instantiate the appropriate client. This enables users to configure and use SAP HANA as a data source within the platform.

dolphinscheduler-datasource-plugin/dolphinscheduler-datasource-hana · high confidence

Introduces a new SageMaker task plugin that allows users to orchestrate AWS SageMaker ML pipelines directly within DolphinScheduler workflows. The implementation includes the core task execution logic (SagemakerTask), parameter handling (SagemakerParameters), and pipeline status tracking utilities (PipelineUtils), enabling users to start, monitor, and cancel SageMaker pipeline executions as part of their data science MLOps processes.

dolphinscheduler-task-plugin/dolphinscheduler-task-sagemaker · high confidence

Users can now configure Slack as an alert channel. This change introduces the SlackAlertChannel and its factory, allowing users to provide a Slack webhook URL and bot name to receive notifications. The implementation sends alert messages via HTTP POST to the specified webhook, formatting content as markdown tables when necessary, and includes retry logic for failed requests.

dolphinscheduler-alert/dolphinscheduler-alert-plugins/dolphinscheduler-alert-pagerduty/src/main, dolphinscheduler-alert/dolphinscheduler-alert-plugins/dolphinscheduler-alert-slack/src/main, dolphinscheduler-alert/dolphinscheduler-alert-plugins/dolphinscheduler-alert-telegram/src/main · high confidence

Users can now store and manage resources using Tencent Cloud COS. This change introduces the \dolphinscheduler-storage-cos\ module, which provides the \CosStorageOperator\ for uploading, downloading, copying, and listing files in a COS bucket. Configuration is handled via properties prefixed with \resource.tencent.cloud\ (including bucket name, region, and access keys), and the plugin is automatically registered via \CosStorageOperatorFactory\.

dolphinscheduler-storage-plugin/dolphinscheduler-storage-cos · high confidence

New Terraform configuration files have been added to deploy/terraform/aws to enable rapid provisioning of DolphinScheduler environments on AWS. This includes Packer scripts to build custom Amazon Machine Images (AMIs) from either official distribution tarballs or local builds, and Terraform modules to orchestrate the creation of the underlying VPC, subnets, EC2 instances for all components (master, worker, alert, API, standalone), and associated security groups. The configuration supports both standalone and cluster modes, with variables to control component replicas, instance types, and storage volumes, along with documentation in the README files to guide users through the setup process.

deploy/terraform · high confidence

This change introduces a new Trino datasource plugin for Apache DolphinScheduler, enabling users to connect to and execute SQL tasks against Trino clusters. The plugin includes the core implementation classes (TrinoDataSourceProcessor, TrinoDataSourceChannel, TrinoAdHocDataSourceClient, TrinoPooledDataSourceClient) and configuration parameter objects (TrinoConnectionParam, TrinoDataSourceParamDTO) required to manage Trino connections, handle JDBC URL construction, and perform SQL splitting and comment removal. Unit tests are also added to verify the factory creation, channel client instantiation, and processor parameter handling.

(repo-wide) · high confidence

Users can now send alert notifications to Cisco Webex Teams. This change introduces the Webex Teams alert channel, allowing configuration of a bot access token and message destination (room ID, person email, or person ID), with support for mentioning users in room messages.

dolphinscheduler-alert/dolphinscheduler-alert-plugins/dolphinscheduler-alert-webexteams/src/main · high confidence

Users can now configure and manage Apache Zeppelin instances as external datasources within the connection center. This change introduces the Zeppelin datasource plugin, which handles connection parameters (REST endpoint, username, password), validates connectivity against the Zeppelin server, and enables Zeppelin tasks to interact with these external connections.

dolphinscheduler-datasource-plugin/dolphinscheduler-datasource-zeppelin · high confidence

DolphinScheduler now supports etcd as a registry center for storing master/worker metadata and handling server registration. This new plugin includes an etcd-based registry implementation with SSL/TLS support, connection state monitoring, lease-based keep-alive management, and configurable retry policies. Users can enable this by setting registry.type=etcd in their configuration.

dolphinscheduler-registry/dolphinscheduler-registry-plugins/dolphinscheduler-registry-etcd · high confidence

A new micro-benchmark module has been added to measure RPC throughput and hot-path utility performance using JMH. This includes an RPC benchmark that exercises the Netty-based RPC framework (via \dolphinscheduler-extract-base\) with a ping/pong service, and an enum lookup benchmark comparing old iteration-based lookups against new HashMap-based lookups. The module provides a JUnit-triggered JMH runner for convenient execution and is excluded from release artifacts.

dolphinscheduler-microbench · high confidence

Users can now configure and connect to Alibaba Cloud EMR Serverless Spark clusters within DolphinScheduler. This change introduces the AliyunServerlessSparkDataSourceProcessor and related components (connection parameters, client wrapper, and channel factory) to handle authentication via AccessKey ID/Secret and region configuration. The implementation allows users to validate connectivity to the serverless Spark service, enabling these clusters to be used as execution engines or data sources in workflows.

dolphinscheduler-datasource-plugin/dolphinscheduler-datasource-aliyunserverlessspark · high confidence

Introduced new Data Transfer Objects, Instance.java and TreeViewDto.java, in the api dto treeview package to support the workflow tree view API. These classes define the structure for workflow instances (including status, timing, and host information) and the hierarchical tree structure (name, type, code, and nested children/instances), enabling the API to serialize and return detailed execution tree data to users.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/dto/treeview · high confidence

The alert extraction layer now exposes an RPC contract via the new IAlertOperator interface, defining methods for both standard alert dispatch and a new test-send capability. To support this, the module adds request and response DTOs (AlertSendRequest, AlertSendResponse, AlertTestSendRequest) that structure the data exchanged for sending alerts and verifying alert instance configurations, enabling external consumers to trigger and validate alert notifications through the extracted service boundary.

dolphinscheduler-extract/dolphinscheduler-extract-alert · high confidence

The alert server now exposes an RPC interface for handling alert operations. This includes a new \AlertOperatorImpl\ service that implements the \IAlertOperator\ interface to process standard alert sends and test alert sends, and an \AlertRpcServer\ that starts a Netty-based RPC server on the configured alert port to expose these methods.

dolphinscheduler-alert/dolphinscheduler-alert-server/src/main/java/org/apache/dolphinscheduler/alert/rpc · high confidence

The alert server now exposes operational visibility through a new health indicator and Micrometer-based metrics. A Spring Boot HealthIndicator checks the availability of the alert registry client to support high-availability monitoring, while new metrics track alert send success/failure counts, heartbeat activity, pending alert volume, and uncached exceptions, enabling better observability and troubleshooting of the alerting system.

dolphinscheduler-alert/dolphinscheduler-alert-server/src/main/java/org/apache/dolphinscheduler/alert/metrics · high confidence

Actuator endpoints (such as /actuator/ and /dolphinscheduler/actuator/) are now protected by HTTP Basic authentication when the new management.security.enabled property is set to true. By default, security is disabled and endpoints remain public. When enabled, users must provide the configured management.security.username and management.security.password, which are validated against an in-memory user store with the ACTUATOR role. Specific endpoints can be excluded from authentication via the management.security.exclude list (e.g., health, info, prometheus). CSRF protection is disabled for these endpoints to support monitoring tools and scripts. Tests verify that authentication works correctly with and without a context path, and that excluded endpoints remain accessible without credentials.

dolphinscheduler-authentication/dolphinscheduler-actuator-authentication · high confidence

This change introduces the Hive datasource plugin module, providing the core components required to connect to and manage Hive data sources within DolphinScheduler. It includes the \HiveDataSourceProcessor\ for handling connection parameters and SQL splitting via Druid, \HiveDataSourceChannel\ and \HiveDataSourceChannelFactory\ for creating ad-hoc and pooled clients, and specific client implementations (\HiveAdHocDataSourceClient\, \HivePooledDataSourceClient\) that manage Kerberos authentication and connection pooling. The module also adds unit tests for these components to ensure correct behavior.

dolphinscheduler-datasource-plugin/dolphinscheduler-datasource-hive, dolphinscheduler-datasource-plugin/dolphinscheduler-datasource-oracle · high confidence

This change introduces the complete Helm chart for deploying DolphinScheduler on Kubernetes, providing a structured way to install and manage the platform. It includes templates for all core components (API, Master, Worker, Alert) with support for configurable database backends (PostgreSQL, MySQL, external), storage options (Minio, S3), and ingress routing. Key features include KEDA-based autoscaling for workers, schema initialization via Helm hooks, and configurable health probes with security support.

deploy/kubernetes/dolphinscheduler/templates · high confidence

This change introduces a new end-to-end testing module (\dolphinscheduler-e2e\) that uses Selenium 4 and Testcontainers to run browser-based tests against a full DolphinScheduler stack. The framework employs a Page Object Model pattern, abstracting UI elements into classes like \LoginPage\ and \NavBarPage\, and manages the test environment via JUnit 5 extensions that orchestrate Docker Compose containers. It includes documentation and configuration files to support running these tests locally or in CI, including specific support for Apple Silicon (M1) chips and local development modes.

dolphinscheduler-e2e · high confidence

This change introduces the first official Helm chart for deploying Apache DolphinScheduler on Kubernetes. The chart (version 3.1.0) bundles the API, Master, Worker, and Alert server components, along with optional dependencies for PostgreSQL, MySQL, ZooKeeper, and Minio. It provides a comprehensive set of configurable values for environment variables, resource limits, persistence, and service exposure, enabling users to install and manage the scheduler via standard Helm workflows.

deploy/kubernetes/dolphinscheduler · high confidence

The alert server now starts via a new AlertServer class that initializes the RPC server, plugin manager, registry client, and high-availability (HA) server. It registers a status change listener to start the bootstrap service when becoming active and gracefully close resources when switching to standby, ensuring proper lifecycle management and HA failover behavior.

dolphinscheduler-alert/dolphinscheduler-alert-server/src/main/java/org/apache/dolphinscheduler/alert · high confidence

This change adds a new storage plugin for Alibaba Cloud OSS, enabling users to use Alibaba Cloud Object Storage Service as a resource center. The implementation includes the \OssStorageOperator\ for core storage operations (upload, download, delete, copy), a factory (\OssStorageOperatorFactory\) registered via \@AutoService\, and supporting classes for connection configuration (\OssConnection\) and client building (\OssClientFactory\). Users can now configure OSS credentials and bucket details via properties to store and manage resources in Alibaba Cloud OSS.

dolphinscheduler-storage-plugin/dolphinscheduler-storage-oss · high confidence

This change adds the SeaTunnel task plugin to DolphinScheduler, enabling users to execute Apache SeaTunnel data integration jobs. The plugin supports three execution backends: the native SeaTunnel Engine (with configurable deploy modes like cluster or client), Apache Spark, and Apache Flink. It allows users to provide configurations either via custom inline scripts or by selecting files from the Resource Center, and correctly passes global and local workflow parameters to the SeaTunnel process while ensuring safe bash quoting of values.

dolphinscheduler-task-plugin/dolphinscheduler-task-seatunnel · high confidence

The e2e-core module now provides the foundational Java classes for running end-to-end tests, including a JUnit 5 extension that manages Docker Compose containers and Selenium browser instances. This update adds specific support for Apple M1 chips by selecting the appropriate Selenium image and configuring host file system bindings for Chrome downloads. It also introduces configurable timeouts, a WebDriver holder for test access, and a logging configuration to stabilize test execution across different environments.

dolphinscheduler-e2e/dolphinscheduler-e2e-core · high confidence

The HDFS storage plugin now includes a new HdfsStorageOperator that automatically refreshes Kerberos TGTs at configurable intervals to prevent authentication failures during long-running tasks, and registers itself via the StorageOperatorFactory SPI. To ensure reliability, the release adds integration tests that spin up a local Hadoop cluster using Docker Compose to validate core storage operations.

dolphinscheduler-storage-plugin/dolphinscheduler-storage-hdfs · high confidence

Adds a new Hive CLI task type to DolphinScheduler, allowing users to execute Hive commands via the \hive -f\ shell command. The task supports two execution modes: running a SQL script provided directly in the task parameters (SCRIPT) or executing a SQL file stored in the Resource Center (FILE). It also allows passing additional Hive CLI options (e.g., \--verbose\) and handles parameter placeholder substitution within the SQL content.

dolphinscheduler-task-plugin/dolphinscheduler-task-hivecli · high confidence

Adds a new Java task plugin that allows users to execute Java applications within their workflows. The plugin supports two execution modes: running a fat JAR directly via \java -jar\ or running a specific class via \java -cp\ with a configurable classpath. Users can configure the main JAR, main class, JVM arguments, and main arguments, and the system automatically extracts the main class from the JAR manifest if not explicitly provided. The implementation includes the task channel factory, parameter definitions, and unit tests to verify command construction and parameter passing.

dolphinscheduler-task-plugin/dolphinscheduler-task-java · high confidence

This change adds a new Jupyter task plugin that allows users to execute Jupyter notebooks within workflow tasks. The plugin supports running notebooks using a local conda environment, a pre-packaged conda environment (tar.gz), or by dynamically creating a temporary environment from a requirements.txt file. It leverages the papermill engine to execute notebooks, passing parameters, kernel selection, and execution timeouts as configurable options.

dolphinscheduler-task-plugin/dolphinscheduler-task-jupyter · high confidence

The API module now includes K8sManager and K8sClientService to manage Kubernetes client instances per cluster. K8sManager handles creating, caching, and updating Kubernetes clients based on cluster configuration retrieved via ClusterConfUtils, while K8sClientService provides a high-level API to validate namespace existence in the target Kubernetes cluster before operations. This enables the system to support multi-cluster environments by routing Kubernetes operations to the correct cluster context.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/k8s · high confidence

This change adds a new K8S task plugin that allows users to execute tasks as Kubernetes pods. The plugin supports configuring the container image, pull policy, and pull secrets, as well as setting resource limits (CPU and memory). Users can also define custom labels for the pods and apply node selectors to target specific nodes. The task execution context is managed via a connection center, and the plugin includes unit tests to verify parameter parsing and command building.

dolphinscheduler-task-plugin/dolphinscheduler-task-k8s · high confidence

Adds a new MLflow task plugin that enables users to run MLflow Projects (including preset Basic Algorithm and AutoML jobs, as well as custom projects) and deploy MLflow Models via MLflow serving or Docker containers. The plugin registers a new 'MLFLOW' task channel, defines task parameters for tracking URIs, repositories, algorithms, and deployment ports, and executes the corresponding mlflow and docker commands on the worker.

dolphinscheduler-task-plugin/dolphinscheduler-task-mlflow · high confidence

This change adds a new Python task plugin to DolphinScheduler, enabling users to execute Python scripts as part of their workflow. The implementation includes the core task logic (PythonTask), parameter handling (PythonParameters), and the necessary SPI channel components (PythonTaskChannel, PythonTaskChannelFactory) to register the task type. It also includes unit tests for the command building logic.

dolphinscheduler-task-plugin/dolphinscheduler-task-python · high confidence

Adds the S3 storage operator implementation, including the factory, properties configuration, and unit tests using MinIO, enabling users to store resources in Amazon S3-compatible buckets.

dolphinscheduler-storage-plugin/dolphinscheduler-storage-s3 · high confidence

This change adds the Zeppelin task plugin, enabling users to execute Apache Zeppelin notebooks or specific paragraphs directly from DolphinScheduler workflows. The implementation includes the core task handler, parameter model, and channel factory, supporting features such as Zeppelin authentication, parameter passing, and production-mode note cloning for stability. Unit tests are also added to verify task execution and status mapping.

dolphinscheduler-task-plugin/dolphinscheduler-task-zeppelin · high confidence

The \dolphinscheduler-extract-base\ module now provides a foundational RPC layer that allows services to be called via Java dynamic proxies. Developers can mark interfaces with \@RpcService\ and methods with \@RpcMethod\ (supporting configurable timeouts and retry strategies) to automatically generate client proxies. The \Clients\ factory simplifies instantiation, while the underlying \NettyRemotingClient\ handles serialization, connection management, and synchronous request-response cycles with built-in metrics and exception handling.

dolphinscheduler-extract/dolphinscheduler-extract-base · high confidence

The alert server now uses a new AlertPluginManager component to automatically discover, register, and manage alert plugins at startup. This component scans for available AlertChannelFactory implementations, creates corresponding alert channels, stores their definitions in the plugin database, and maintains an in-memory map for efficient retrieval, simplifying the integration of new alert types.

dolphinscheduler-alert/dolphinscheduler-alert-server/src/main/java/org/apache/dolphinscheduler/alert/plugin · high confidence

The \dolphinscheduler-common\ module now includes a comprehensive set of new enumeration types that define the core data models for the system. This adds \AlertEvent\, \AlertPluginInstanceType\, \AlertStatus\, \AlertType\, and \AlertWarnLevel\ to support the new alert plugin architecture and status tracking. It introduces \AuditModelType\ and \AuditOperationType\ to standardize the audit log model, covering resources like workflows, tasks, and security entities. Workflow execution is defined by \CommandType\ (covering start, pause, stop, and complement data), \ExecutionOrder\, \RunMode\, and \FailureStrategy\. Additional enums such as \PluginType\, \TaskGroupQueueStatus\, \ScheduleMissedFirePolicy\, and \ListenerEventType\ provide the necessary constants for plugin management, task scheduling, and event listening.

dolphinscheduler-common/src/main/java/org/apache/dolphinscheduler/common/enums · high confidence

A new \dolphinscheduler-standalone-server\ module has been added to provide a single-JVM deployment that embeds the master, worker, API, and alert server components along with an H2 in-memory database. This module is designed for local development, smoke testing, and lightweight demonstrations rather than production use. It includes a dedicated entry point (\StandaloneServer\), configuration files (\application.yaml\, \logback-spring.xml\), startup scripts (\start.sh\, \jvm\_args\_env.sh\), and an assembly descriptor to package the necessary resources. The setup uses an H2 database in MySQL compatibility mode (\MODE=MySQL\) to ensure correct SQL generation by MyBatis-Plus, and it excludes configuration files from the JAR to allow runtime editing. This change simplifies the local development experience by providing a self-contained, easy-to-start environment without requiring a full distributed cluster setup.

dolphinscheduler-standalone-server · high confidence

The new dolphinscheduler-task-executor module centralizes the task execution framework, defining how a worker runs, tracks, and reports task instances independent of specific task types. It introduces the TaskEngine facade for submitting and controlling tasks, along with execution containers (ExclusiveThread and SharedThread) that manage thread allocation and task lifecycle. The module also provides an in-process event bus for lifecycle transitions and a repository for tracking running tasks, ensuring consistent state management and reporting back to the master.

dolphinscheduler-task-executor · high confidence

The API security module now supports OpenID Connect (OIDC) as a configurable authentication type alongside existing password, LDAP, and Casdoor SSO methods. Administrators can enable OIDC via the \security.authentication.oidc\ configuration prefix, defining multiple providers with issuer URIs, client credentials, and scopes. The system handles the OIDC authorization code flow, validates ID tokens, and can automatically create local user accounts for first-time OIDC logins based on configured group-to-admin mappings.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/security · high confidence

Added a new local, in-process event bus module to decouple internal components (master, worker, task-executor, alert) without requiring a distributed message broker. The module provides an \IEvent\ marker interface, an \IEventBus\ contract for publishing and polling events, and an \AbstractDelayEventBus\ implementation backed by a \DelayQueue\ to support delayed event firing. This allows subsystems to define domain-specific event hierarchies and process them asynchronously within the same JVM.

dolphinscheduler-eventbus · high confidence

The application now uses a new \dolphinscheduler-dao-plugin\ module structure that replaces the previous monolithic DAO layer with a pluggable, Spring Boot auto-configuration-based architecture. This change introduces a common API (\DaoPluginConfiguration\, \DatabaseDialect\, \DatabaseMonitor\) and specific implementations for H2, MySQL, and PostgreSQL databases. Each database type is now encapsulated in its own sub-module (e.g., \dolphinscheduler-dao-h2\, \dolphinscheduler-dao-mysql\, \dolphinscheduler-dao-postgresql\) with dedicated auto-configuration classes and Spring factories, allowing the system to dynamically select the appropriate database driver and monitoring logic based on the active Spring profile. This modularization enables easier extension for future database types and cleaner separation of database-specific logic.

(repo-wide) · high confidence

The HTTP alert plugin has been refactored into a new implementation (\HttpAlertChannel\) that supports GET, POST, and PUT request methods, configurable content types (JSON or form-urlencoded), custom headers, and a numeric timeout parameter (defaulting to 120 seconds). This change replaces the previous implementation, ensuring that alert messages are correctly sent via HTTP with proper validation of URL, body parameters, and request types, while also fixing issues related to nested JSON body handling and timeout unit consistency.

dolphinscheduler-alert/dolphinscheduler-alert-plugins/dolphinscheduler-alert-http/src/main · high confidence

Added a new visitor pattern implementation within the API resource DTO layer to construct hierarchical resource trees. The new \Visitor\ interface and \ResourceTreeVisitor\ class enable the system to traverse a flat list of storage entities and assemble them into a nested directory/file structure (\ResourceComponent\ tree) based on path relationships, facilitating the backend support for resource tree display.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/dto/resources/visitor · high confidence

Added a new server lifecycle module containing a ServerStatus enum (RUNNING, STOPPED), a ServerLifeCycleManager to track the current status and startup time, and a ServerLifeCycleException. This provides a centralized mechanism for master and worker servers to manage and query their operational state.

dolphinscheduler-common/src/main/java/org/apache/dolphinscheduler/common/lifecycle · high confidence

The common module now includes a Spring configuration class that explicitly scans the \org.apache.dolphinscheduler.common\ package for components, alongside a new \IStoppable\ interface defining a \stop(String cause)\ method for services. This provides a standardized contract for stopping services and ensures common components are automatically discovered by the Spring context.

dolphinscheduler-common/src/main/java/org/apache/dolphinscheduler/common · high confidence

The API layer now includes a new \AuditType\ enum that defines specific audit events for workflows, tasks, schedules, resources, and other system entities. This change establishes the backend structure for tracking operations such as creating, updating, deleting, and executing workflows, as well as managing resources like files, folders, and datasources, enabling more granular audit trails for these actions.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/audit/enums · high confidence

A new \DAG\ class has been added to the \dolphinscheduler-common\ module, providing a generic, thread-safe Directed Acyclic Graph structure. This implementation supports adding nodes and edges, checking for containment, and retrieving node information, while internally using a \ReentrantReadWriteLock\ to ensure thread safety during concurrent modifications and reads. It also includes logic to prevent the creation of cycles when adding edges, returning false if such an operation would violate the DAG property.

dolphinscheduler-common/src/main/java/org/apache/dolphinscheduler/common/graph · high confidence

A new service layer module has been added to sit between the data access (DAO) and server components (API, Master, Worker). This module centralizes core orchestration logic, including workflow lifecycle management via ProcessServiceImpl, command queue processing, cron scheduling using the cron-utils library, alert dispatching, and parameter expansion. It also introduces a Spring ApplicationContext helper for bean retrieval and standardizes component scanning for the service package.

dolphinscheduler-service · high confidence

The API module introduces a set of new Data Transfer Objects (DTOs) to support expanded functionality in the user-facing interface. These include AuditDto and audit-specific types (AuditModelTypeDto, AuditOperationTypeDto) to expose audit log details and model/operation hierarchies, ScheduleParam to handle scheduling configurations including timezone and missed-fire policies, and resource management DTOs (ClusterDto, EnvironmentDto, FavTaskDto, TaskCodeVersionDto) to support cluster/environment operations, task favorites, and code versioning. Additionally, LdapLoginResult and ProductInfoDto are added to support LDAP login responses and product version information, while PageQueryDto and CommandStateCount provide standard pagination and command state aggregation structures.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/dto · high confidence

The API module now includes three new interceptors: LoginHandlerInterceptor handles user authentication by validating tokens or session cookies, checks user account status, and manages timezone context; LocaleChangeInterceptor supports language switching via request headers; and RateLimitInterceptor enforces both global and per-tenant request quotas to prevent API abuse. These components centralize cross-cutting concerns for the API server.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/interceptor · high confidence

This change introduces new Data Transfer Objects (DTOs) in the API module to support RESTful operations for tasks and their relations. Specifically, it adds TaskFilterRequest for querying tasks by project, name, and type, alongside TaskRelationCreateRequest, TaskRelationFilterRequest, and TaskRelationUpdateUpstreamRequest to handle the creation, filtering, and upstream updates of workflow task relations. These DTOs provide the structured input models required for the corresponding API endpoints.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/dto/taskRelation · high confidence

The API module introduces new service implementations to manage core system resources. AccessTokenServiceImpl provides the backend logic for creating, querying, updating, and deleting access tokens, including permission checks to ensure users can only manage their own tokens or all tokens if they are administrators. AlertGroupServiceImpl handles the creation, modification, and listing of alert groups, enforcing role-based access control so that general users can only view groups they own. Additionally, AuditServiceImpl is added to record and query system audit logs, supporting filtering by operation type and user, which enhances the platform's security and compliance tracking capabilities.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl · high confidence

The UI now includes dedicated service modules for fetching Monitor and Log data, introducing new API endpoints for querying database states, listing Master/Worker/Alert server nodes (including their busy/normal status), and retrieving active workflow and task executors for specific nodes. Additionally, a new log service provides a function to query detailed log entries by task instance ID, supporting pagination via limit and skip parameters.

dolphinscheduler-ui/src/service/modules/monitor · high confidence

The UI service layer has been expanded with new API integration modules for managing environments, tenants, access tokens, and user logout. These additions provide the frontend with the necessary client-side functions and TypeScript type definitions to interact with the corresponding backend endpoints, enabling features such as environment creation and listing, tenant management, token generation and rotation, and session termination.

(repo-wide) · high confidence

A new \dolphinscheduler-aws-authentication\ module has been added, providing a unified way to configure and instantiate AWS clients for S3, EMR, SageMaker, DMS, and DataSync. This module introduces an \AWSCredentialsProviderFactor\ that supports both static access-key/secret-key authentication and IAM instance-profile authentication. It includes specific client factories for each AWS service, allowing users to configure custom endpoints and regions (particularly useful for S3 with path-style access and custom endpoints) via a new \aws.yaml\ configuration file.

dolphinscheduler-authentication/dolphinscheduler-aws-authentication · high confidence

A new \BusinessTimeUtils\ class has been added to the common placeholder utilities to standardize how business dates and times are calculated for workflow parameters. This utility handles logic for various command types (such as scheduling, complement data, and task recovery) to ensure that business date variables are correctly derived from the run or schedule time, addressing previous inconsistencies in how these values were computed across different execution contexts.

dolphinscheduler-common/src/main/java/org/apache/dolphinscheduler/common/utils/placeholder · high confidence

The dolphinscheduler-dao module now includes a CLAUDE.md guide clarifying that new code must use the repository layer rather than calling MyBatis mappers directly, and introduces the AlertDao, PluginDao, and DaoConfiguration classes. These additions provide the data-access logic for alert plugin instances, plugin definitions, and MyBatis/MyBatis-Plus configuration, supporting the alert plugin system and ensuring proper database dialect handling.

dolphinscheduler-dao · high confidence

A new Data Transfer Object, DynamicTaskInfo, has been added to the API layer to represent metadata for dynamic task types. This class exposes fields for the task's name, hover text, icon, and associated JSON configuration, enabling the API to transmit structured information about available dynamic tasks to the frontend.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/dto/taskType · high confidence

This change introduces a new Flink Stream task type (FLINK\_STREAM) within the task-plugin module, enabling users to execute continuous Flink jobs. The implementation includes the FlinkStreamTask and FlinkStreamParameters classes to handle task execution and configuration, along with a FlinkStreamTaskChannelFactory to register the new task channel. The plugin supports parameter replacement in scripts, allowing dynamic values like business dates to be injected into Flink SQL or programmatic scripts at runtime. Tests verify command-line generation for various deployment modes (Application, Cluster, Local) and confirm that time-based placeholders are correctly resolved.

dolphinscheduler-task-plugin/dolphinscheduler-task-flink-stream · high confidence

Added GanttDto and Task classes in the dolphinscheduler-api module to structure Gantt chart data for API consumers. GanttDto provides a container for task lists, task name identifiers, and status mappings, while Task defines the specific fields (names, start/end dates, execution times, status, and duration) required to render Gantt visualizations.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/dto/gantt · high confidence

DolphinScheduler now supports a JDBC-based registry center, allowing users to store master and worker metadata in a MySQL database instead of relying solely on external systems like ZooKeeper. This new plugin includes the core \JdbcRegistry\ implementation, a Spring Boot auto-configuration that sets up the necessary data sources, MyBatis mappers, and transaction management, and supporting components for client identification, heartbeat tracking, and data change event handling. Users can enable this feature by setting the registry type to 'jdbc' in their configuration.

dolphinscheduler-registry/dolphinscheduler-registry-plugins/dolphinscheduler-registry-jdbc · high confidence

This change introduces a new Procedure task plugin that allows users to execute database stored procedures within their workflows. The plugin includes a new \ProcedureParameters\ class to define the database type, datasource ID, and procedure name, along with a \ProcedureTask\ implementation that handles the execution via JDBC \CallableStatement\, supports input/output parameter mapping, and allows task cancellation. A \ProcedureTaskChannel\ and \ProcedureTaskChannelFactory\ are added to register the new task type with the system, enabling users to add and configure procedure tasks in their DAGs.

dolphinscheduler-task-plugin/dolphinscheduler-task-procedure · high confidence

The API module introduces dedicated REST controllers to manage access tokens, alert groups, alert plugin instances, and audit logs. The new AccessTokenController exposes endpoints for creating, generating, querying, updating, and deleting access tokens, while the AlertGroupController and AlertPluginInstanceController provide full CRUD operations and a test-send capability for alert configurations. Additionally, the AuditLogController adds a paginated query endpoint for system audit trails, filtering by model type, operation type, user, and date range. These controllers standardize the API surface for these subsystems, replacing or supplementing previous ad-hoc endpoints.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller · high confidence

The master extract module introduces a set of new RPC service interfaces to standardize communication with the master node. IWorkflowControlClient exposes methods for triggering workflows (manual, schedule, backfill), repeating runs, and recovering from failures or suspensions. ILogicTaskExecutorOperator provides RPC methods to dispatch, kill, and pause tasks, as well as acknowledge lifecycle events. ITaskExecutorEventListener defines the contract for receiving task lifecycle events (dispatched, running, success, failure, etc.) from executors, while TaskExecutorEventRemoteReporterClient implements the client-side logic to report these events to the master. Additionally, ITaskInstanceController handles task group slot acquisition notifications, IWorkflowExecutorQueryClient allows querying active workflow executors, and IMasterContainerService exposes a method to refresh worker groups. These interfaces, along with their associated command parameters and transport objects, form the new communication layer for workflow and task management.

dolphinscheduler-extract/dolphinscheduler-extract-master · high confidence

The dolphinscheduler-spi module now exposes the core extension-point interfaces and data models that enable the new datasource plugin architecture and dynamic configuration forms. It defines the datasource SPI hierarchy (DataSourceClient, PooledDataSourceClient, AdHocDataSourceClient, DataSourceChannel, and DataSourceChannelFactory) so plugin modules can register and provide database connections, and it introduces the PluginParams model (including FormType, Validate, and specific input builders) that allows the frontend to render plugin configuration UIs dynamically from JSON templates.

dolphinscheduler-spi · high confidence

The dolphinscheduler-common module now includes a new SQL processing package containing a SqlScriptParser interface, a ClasspathSqlScriptParser implementation, and a SqlScriptRunner. The parser reads SQL scripts from the classpath, handling UTF-8 encoding, skipping comments and license headers, and supporting custom delimiters for stored procedures. The runner executes the parsed SQL statements against a provided DataSource, enabling standardized SQL script execution within the application.

dolphinscheduler-common/src/main/java/org/apache/dolphinscheduler/common/sql · high confidence

The Dolphin Scheduler UI has been replaced with a new frontend application built on Vue 3, Vite, and TypeScript, utilizing Naive UI for components and AntV X6 for the DAG editor. This change introduces a modern development environment with ESLint and Prettier configurations, environment-specific settings for local and production backend URLs, and a new build process that generates a \dist/\ directory bundled into the release tarball. Users will experience significantly improved interface performance, type safety, and support for dark/light themes, while developers must use Node 16.x and pnpm 7.x to build and run the new UI.

dolphinscheduler-ui · high confidence

The new dolphinscheduler-yarn-aop module introduces an AspectJ aspect that automatically captures the ApplicationId of every YARN application submitted by the worker. By weaving into Hadoop's YarnClientImpl, the module writes these IDs to an appInfo.log file in the worker's working directory, enabling operators to track and kill running YARN jobs associated with specific task instances. This capability is provided through compile-time or load-time weaving and includes mock tests to verify the aspect's behavior without requiring a live YARN cluster.

dolphinscheduler-yarn-aop · high confidence

A new Zookeeper-based registry plugin has been added to DolphinScheduler, allowing users to configure Zookeeper as the registry center by setting \registry.type=zookeeper\. This implementation includes a Spring Boot auto-configuration (\ZookeeperRegistryAutoConfiguration\) that automatically initializes the registry, supporting configurable properties such as connection strings, namespace, retry policies, and timeouts. It introduces connection state monitoring (connected, disconnected, reconnected, suspended) and supports subscribing to data changes with configurable scopes (path-only, children-only, or all). The plugin is designed to integrate seamlessly with the existing registry API and includes integration tests using Testcontainers.

dolphinscheduler-registry/dolphinscheduler-registry-plugins/dolphinscheduler-registry-zookeeper · high confidence

The alert module introduces a new plugin API layer in the \dolphinscheduler-alert-api\ module, defining core interfaces such as \AlertChannel\ and \AlertChannelFactory\ to standardize how alert plugins are created and invoked. It adds data models like \AlertInfo\ and \AlertResult\ to structure alert payloads and outcomes, along with \AlertInputTips\ to provide UI hints for plugin configuration fields. Additionally, an \HttpServiceRetryStrategy\ is implemented to automatically retry HTTP-based alert requests on transient network failures, improving reliability for plugins like Webhook and HTTP.

dolphinscheduler-alert/dolphinscheduler-alert-plugins/dolphinscheduler-alert-api · high confidence

The API module now uses a new aspect-oriented logging system to automatically record operator actions. Developers can annotate controller methods with @OperatorLog to trigger audit trails, which are handled by OperatorLogAspect to capture request parameters, user context, and execution latency before persisting the logs via AuditService. This replaces previous manual logging approaches with a standardized, declarative mechanism for tracking system changes.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/audit · high confidence

The API module now includes a new exception handling infrastructure consisting of the ApiException annotation, the ServiceException class, and the ApiExceptionHandler. This allows controllers to declare expected error conditions using the @ApiException annotation, which the handler intercepts to return structured error responses with appropriate HTTP status codes and error messages, improving consistency and clarity in API error reporting.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/exceptions · high confidence

The \dolphinscheduler-common\ module now includes a set of new model classes to support internal communication and storage integrations. This includes a heartbeat framework (\BaseHeartBeat\, \HeartBeat\, \BaseHeartBeatTask\) with specific implementations for Master, Worker, and Alert servers, enabling detailed status reporting (CPU, memory, disk, JVM metrics) and server status tracking. Additionally, models for Alibaba Cloud OSS integration (\OssConnection\, \OssClientFactory\) and OkHttp request/response handling (\OkHttpRequestHeaders\, \OkHttpResponse\, \OkHttpRequestHeaderContentType\) have been added to support resource center storage and external HTTP task plugins.

dolphinscheduler-common/src/main/java/org/apache/dolphinscheduler/common/model · high confidence

The dolphinscheduler-extract-common module introduces the ILogService interface and its LogServiceImpl implementation, enabling the extraction of task instance logs via RPC. This includes capabilities to download entire log files as byte arrays, perform paginated queries of log content, and remove log files, supported by new request/response transport objects (such as TaskInstanceLogFileDownloadRequest and TaskInstanceLogPageQueryRequest) and a LogResponseStatus enum.

dolphinscheduler-extract/dolphinscheduler-extract-common · high confidence

Added three new shell scripts to streamline server management and plugin deployment. The \dolphinscheduler-daemon.sh\ script provides a unified interface to start, stop, and check the status of individual server components (api, master, worker, alert, and standalone servers), including logic to overwrite server-specific environment files with a central \bin/env/dolphinscheduler\_env.sh\ if present. The \script/env/dolphinscheduler\_env.sh\ file serves as the centralized environment configuration source. Additionally, \install-plugins.sh\ automates the download and installation of required plugins from Maven repositories based on the configuration in \conf/plugins\_config\, supporting custom version specification.

script · high confidence

The \dolphinscheduler-common\ module now ships with three new default configuration files: \common.properties\, \remote-logging.yaml\, and \resource-center.yaml\. These files provide out-of-the-box settings for the resource center, supporting storage backends such as Tencent Cloud COS, Azure Blob Storage, Alibaba Cloud OSS, Google Cloud Storage, and Huawei Cloud OBS, as well as configuring remote logging targets like OSS and GCS. Users deploying with these defaults will have these storage and logging options pre-configured, though specific credentials and endpoints must be updated in the YAML files to match their environment.

dolphinscheduler-common/src/main/resources · high confidence

The \dolphinscheduler-common\ module now includes three new exception classes: \BaseException\ serves as the root exception for the application, \FileOperateException\ extends \BaseException\ to handle file operation errors, and \StorageOperateNoConfiguredException\ extends \RuntimeException\ to indicate when storage operations fail due to missing configuration. These classes provide a structured way to handle and distinguish between general errors, file-specific issues, and storage configuration problems within the common library.

dolphinscheduler-common/src/main/java/org/apache/dolphinscheduler/common/exception · high confidence

The UI now exposes a dedicated service module for executor operations, introducing functions to execute workflows, execute specific tasks within a workflow, and start new workflow instances. This change adds the necessary TypeScript type definitions for request payloads (such as execution types, failure strategies, and priority levels) and HTTP client wrappers, enabling the frontend to interact with the backend's executor endpoints for running and managing workflow instances.

dolphinscheduler-ui/src/service/modules/executors · high confidence

A new gRPC task plugin has been added to DolphinScheduler, allowing workflows to invoke remote gRPC services. The plugin accepts a JSON-formatted protobuf service definition and a JSON message, dynamically constructs the gRPC channel (supporting both insecure and TLS credentials), and executes the specified RPC method. Users can configure connection timeouts and define validation conditions for the response, such as checking for a default OK status, a custom status code, or a specific description string. The task output is exposed as a workflow variable containing the JSON-serialized response from the gRPC call.

dolphinscheduler-task-plugin/dolphinscheduler-task-grpc · high confidence

The new dolphinscheduler-meter module provides automatic metrics collection and Prometheus exposure for all server types (master, worker, API, and alert). It introduces a Spring Boot auto-configuration that registers Micrometer-based system metrics (CPU, memory, disk) and a server-load protection mechanism that can reject new tasks when system thresholds are exceeded. The module also includes example Grafana dashboards and a Docker Compose setup to demonstrate how to visualize these metrics in a Prometheus and Grafana stack.

dolphinscheduler-meter · high confidence

The UI service layer for projects has been restructured into a new module, introducing dedicated API functions for project management. This includes standard CRUD operations (create, update, delete, query) and new endpoints specifically for authorization management, such as querying projects by authorized level, listing authorized/unauthorized projects for a user, and fetching projects created and authorized by the current user. Additionally, a dedicated endpoint is provided to list all projects for dependent node selection, enabling users to reference projects they do not own but have access to.

dolphinscheduler-ui/src/service/modules/projects · high confidence

The \tools\ area now includes a Python-based release automation suite (\tools/release/\) and a license compliance check script (\tools/dependencies/check-LICENSE.sh\). The release tool (\release.py\) automates the release process by allowing maintainers to auto-cherry-pick merged pull requests, generate structured changelogs, and list contributors based on GitHub milestones. The license script extracts third-party dependencies from the binary distribution and compares them against \known-dependencies.txt\ to ensure all licenses are accounted for.

tools · high confidence

Added AbstractShell and ShellExecutor classes to the dolphinscheduler-common module, providing a base class for running Unix commands with timeout and environment support, and a concrete executor for simple shell command execution that returns output as a string.

dolphinscheduler-common/src/main/java/org/apache/dolphinscheduler/common/shell · high confidence

A new \dolphinscheduler-tools\ module has been introduced to package CLI utilities as separate Spring Boot applications, distributed via shell scripts (\bin/upgrade-schema.sh\, \bin/migrate-lineage.sh\, \bin/migrate-resource.sh\). This separates operational tasks from the main server: the schema tool handles database initialization and versioned upgrades (e.g., V3.2.0) using dialect-aware SQL scripts; the lineage tool migrates dependent task relationships into the new lineage tables; and the resource tool moves unmanaged resources to a specified tenant. This modularization simplifies deployment and maintenance of these critical data operations.

dolphinscheduler-tools · high confidence

The UI service layer for user management has been reorganized into a dedicated module under \src/service/modules/users\. This change introduces a new \index.ts\ file that exports specific API request functions for user operations, including activation, creation, deletion, information retrieval, and various permission grants (data source, resource, project, and namespace). It also adds corresponding TypeScript type definitions in \types.ts\ to strongly type the request and response payloads for these endpoints, ensuring type safety for user-related interactions within the application.

dolphinscheduler-ui/src/service/modules/users · high confidence

The API module now includes a new \IExecutorDelegate\ interface and a set of concrete delegate classes in \dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/executor/workflow\ to handle workflow execution and control operations. These include \TriggerWorkflowExecutorDelegate\ for manual workflow triggering, \BackfillWorkflowExecutorDelegate\ for backfilling historical data (supporting serial and parallel modes with dependent expansion), and delegates for instance control: \PauseWorkflowInstanceExecutorDelegate\, \StopWorkflowInstanceExecutorDelegate\, \RecoverFailureTaskInstanceExecutorDelegate\, \RecoverSuspendedWorkflowInstanceExecutorDelegate\, and \RepeatRunningWorkflowInstanceExecutorDelegate\. A new \ExecutorClient\ component provides a unified entry point to access these delegates. All control operations utilize the \IWorkflowControlClient\ to communicate with the master server, ensuring consistent handling of workflow state transitions and task recovery.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/executor/workflow · high confidence

The Presto datasource plugin has been re-introduced to the plugin module, providing the specific implementation classes required to connect to Presto databases. This includes a new \PrestoDataSourceProcessor\ that handles connection parameter parsing, JDBC URL construction, and driver management, alongside \PrestoDataSourceChannel\ and \PrestoDataSourceChannelFactory\ to instantiate ad-hoc and pooled client instances. The change also adds corresponding parameter DTOs (\PrestoDataSourceParamDTO\, \PrestoConnectionParam\) and unit tests to verify the new plugin components.

dolphinscheduler-datasource-plugin/dolphinscheduler-datasource-presto · high confidence

The Python gateway functionality, previously hosted in a separate worker module, is now embedded directly within the API server via the new PythonGateway component. This change allows Python-based workflow definitions to interact with core services (such as workflow, project, and resource management) through a unified interface, simplifying deployment and enabling features like online scheduling and resource management from Python scripts.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/python · high confidence

The Quartz scheduler plugin now supports configurable missed-fire policies (Skip Missed, Fire Once Now, and Fire All Missed) to control how cron triggers behave when they fail to fire on time, and allows users to configure a separate database datasource for Quartz via the \scheduler-plugin.quartz.using-separate-datasource\ property to isolate scheduling data from the main application database.

dolphinscheduler-scheduler-plugin/dolphinscheduler-scheduler-quartz · high confidence

The binary and source distribution tarballs now bundle the full text of third-party licenses (including Apache 2.0, MIT, BSD, and Eclipse Public License 2.0) in the \release-docs/licenses/\ directory, alongside the main \LICENSE\ and \NOTICE\ files. This ensures that all dependency license terms are readily available for compliance and audit purposes without requiring external lookups.

dolphinscheduler-dist · high confidence

The repository has been initialized with the Apache DolphinScheduler codebase, replacing the previous 'EasyScheduler' identity. This change introduces the core project structure including the Maven multi-module build system (with mvnw wrapper), a Vue 3 frontend, and backend services (API, Master, Worker, Alert). It also establishes essential governance and developer experience files such as \.asf.yaml\ for GitHub metadata, \SECURITY.md\ for vulnerability reporting, \CLAUDE.md\/\AGENT.md\ for project documentation, and pre-commit hooks for code formatting.

(repo-wide) · high confidence

The Spark SQL datasource plugin is restored in the datasource plugin module, providing the necessary infrastructure to connect to and execute queries against Spark clusters. This change introduces the \SparkDataSourceProcessor\ to handle connection parameter mapping and JDBC URL construction (leveraging the Hive JDBC driver), alongside \SparkAdHocDataSourceClient\ and \SparkPooledDataSourceClient\ to support both immediate ad-hoc execution and connection pooling. The plugin is registered via \SparkDataSourceChannelFactory\ using AutoService, enabling the system to discover and utilize Spark as a valid database type for data source operations.

dolphinscheduler-datasource-plugin/dolphinscheduler-datasource-spark · high confidence

The Sqoop task plugin has been restructured to support distinct source and target data types (MySQL, Hive, HDFS, Oracle, HANA, SQL Server) via a new generator architecture. This change introduces specific generator classes for each source and target type, allowing the task to dynamically build Sqoop commands based on the selected data source and destination. It also adds support for custom SQL queries and column mapping, enhancing flexibility for data import and export operations.

dolphinscheduler-task-plugin/dolphinscheduler-task-sqoop · high confidence

The system now supports writing task logs to remote object storage, enabling centralized log management and retrieval. This change introduces a new remote logging infrastructure in the common module, including a factory and service layer that routes log operations to specific handlers. Users can now configure the logging target to use Alibaba Cloud OSS, Amazon S3, Google Cloud Storage (GCS), Azure Blob Storage (ABS), or Tencent Cloud COS. The implementation handles asynchronous log sending and retrieval, ensuring that task logs are persisted to the configured cloud bucket while maintaining local fallback capabilities.

dolphinscheduler-common/src/main/java/org/apache/dolphinscheduler/common/log · high confidence

The common configuration module now introduces a new property resolution mechanism that allows configuration values to be sourced from environment variables, JVM system properties, and standard property files, with environment variables taking precedence. This change adds new classes (IPropertyDelegate, ImmutablePriorityPropertyDelegate, ImmutablePropertyDelegate, ImmutableYamlDelegate) to handle this priority-based lookup, enabling users to override default settings via environment variables or JVM arguments without modifying configuration files. Additionally, a YamlPropertySourceFactory is provided to support YAML-based property sources within the Spring environment.

dolphinscheduler-common/src/main/java/org/apache/dolphinscheduler/common/config · high confidence

The API service layer now exposes a set of new, strongly-typed service interfaces (including AccessToken, AlertGroup, AlertPluginInstance, Audit, Base, Cloud, Cluster, DataAnalysis, DataSource, Environment, EnvironmentWorkerGroupRelation, and Executor services). These interfaces define the specific contracts for managing access tokens, alert configurations, audit logs, data source connections, cluster/environment settings, and workflow execution, replacing previous generic return types with precise entity and DTO structures to improve API reliability and clarity.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service · high confidence

The task-api module now implements a new Service Provider Interface (SPI) for task plugins, introducing a \TaskChannelFactory\ and \TaskChannel\ abstraction that allows task types to be registered and discovered dynamically. This change adds core execution classes such as \AbstractTask\, \AbstractRemoteTask\, \AbstractYarnTask\, and \AbstractCommandExecutor\ to standardize how tasks are created, parameterized, and executed. It also introduces \TaskExecutionContext\ to unify the data passed between the master and worker, and \TaskPluginManager\ to handle the loading and retrieval of these plugin channels.

dolphinscheduler-task-plugin/dolphinscheduler-task-api · high confidence

The dolphinscheduler-master module has been reorganized to improve cluster coordination and deployment. A new ClusterManager component now handles the initialization and subscription of master and worker clusters via the registry, replacing previous ad-hoc logic. The startup process is now driven by a new start.sh script that sources JVM arguments from a dedicated jvm\_args\_env.sh file, enabling consistent configuration of memory, GC, and timezone settings. Additionally, a CLAUDE.md file has been added to document the master server's architecture, entry points, and testing procedures for developers.

dolphinscheduler-master · high confidence

The storage plugin API has been restructured to introduce a cleaner Service Provider Interface (SPI) for storage backends. This change adds a new \StorageOperator\ interface and a \StorageOperatorFactory\ mechanism, allowing storage implementations to be discovered and instantiated via Java's \ServiceLoader\. A new \LocalStorageOperator\ provides the default local file-system storage capability, backed by a \StorageConfiguration\ that wires the factory to Spring. Additionally, new data models \ResourceMetadata\ and \StorageEntity\ are introduced to standardize resource information, and \StorageConstants\ centralizes configuration keys for various cloud providers (HDFS, S3, GCS, Azure, etc.).

dolphinscheduler-storage-plugin/dolphinscheduler-storage-api · high confidence

The resource management API in the DolphinScheduler API module has been refactored to use a structured validator and transformer pattern. New abstract base classes, AbstractResourceValidator and AbstractResourceTransformer, now centralize common checks for resource paths, file existence, and user permissions, while specific validators (e.g., CreateFileDtoValidator, DeleteResourceDtoValidator) and transformers handle operation-specific logic. This change improves code consistency and ensures that resource operations like file creation, deletion, and renaming are properly validated against storage paths and user tenant permissions before execution.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/validator/resource · high confidence

The API server's configuration and resource files have been consolidated into a new \application.yaml\ alongside dedicated files for logging (\logback-spring.xml\), task type definitions (\task-type-config.yaml\, \dynamic-task-type-config.yaml\), and API documentation (\swagger.properties\). This change introduces configurable session timeouts, enables the Python gateway by default (disabled), exposes specific actuator endpoints (health, metrics, prometheus) while excluding sensitive ones, and defines a comprehensive list of supported task types including cloud, logic, data integration, and machine learning variants. Additionally, a startup banner has been added to improve launch visibility.

dolphinscheduler-api/src/main/resources · high confidence

The API module now includes localized documentation notes (in English and Chinese) for various operations, including workflow instance management, alert plugin instances, worker groups, data sources, queues, tenants, resources, and user permissions. These notes provide context for API endpoints related to scheduling, batch execution, and project authorization.

dolphinscheduler-api/src/main/resources/i18n · high confidence

The alert server's registry heartbeat mechanism has been updated to provide richer operational visibility. The new AlertHeartbeatTask now includes the server's host and port, along with a breakdown of CPU and memory usage into JVM-specific and system-level metrics (such as jvmCpuUsage, systemCpuUsage, jvmMemoryUsage, and systemMemoryUsage). This change supports high-availability monitoring by allowing consumers to distinguish between JVM load and overall system load, and to identify the specific network address of the alert server instance.

dolphinscheduler-alert/dolphinscheduler-alert-server/src/main/java/org/apache/dolphinscheduler/alert/registry · high confidence

The alert server's internal processing pipeline has been restructured into a decoupled fetch-process-send model to improve reliability and support high availability. Alerts are now fetched from the database by an \AlertEventFetcher\ (which uses a transaction to ensure data consistency in master/slave setups), queued in a bounded \AlertEventPendingQueue\, and processed by a dedicated \AlertEventLoop\ using a configurable thread pool. This change isolates the sending logic in \AlertSender\, which now correctly updates alert statuses (success, failure, partial success) in the database after sending, and integrates with \AlertHAServer\ to ensure only the active node processes alerts.

dolphinscheduler-alert/dolphinscheduler-alert-server/src/main/java/org/apache/dolphinscheduler/alert/service · high confidence

A new \AuditLogConstants\ class has been introduced in the API module to centralize string constants used for audit log fields (such as \code\, \version\, \workflowDefinitionCode\, \userId\, etc.). This change standardizes the field names referenced in audit logging, ensuring consistency across the backend audit implementation.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/audit/constants · high confidence

The API audit logging system now includes dedicated operator implementations for all major resource types—including workflows, tasks, projects, datasources, users, tenants, clusters, and queues. These new operators ensure that audit logs accurately resolve and record human-readable object names (such as workflow names or user names) instead of opaque IDs, providing clearer and more actionable audit trails for administrators.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/audit/operator/impl · high confidence

The API module now uses a consolidated configuration structure under \api.configuration\. \ApiConfig\ centralizes settings for session timeouts, traffic control, and the Python gateway, while \AppConfiguration\ manages MVC interceptors, CORS, and static resource routing. Authentication is now configurable via \OAuth2Configuration\ for external providers. API documentation is unified under \SwaggerConfiguration\, which exposes both v1 and v2 endpoints via SpringDoc OpenAPI and dynamically injects the application version. Additionally, \TaskTypeConfiguration\ and \DynamicTaskTypeConfiguration\ externalize task type definitions and dynamic task metadata from YAML files, enabling more flexible task management.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/configuration · high confidence

Users can now configure DataX tasks to read the job definition from an attached resource file instead of only using inline JSON. When custom configuration is enabled, the task validates that exactly one JSON resource is present in the attached files to serve as the job definition, resolving ambiguity when multiple resources (such as auxiliary keytabs) are uploaded. This change also improves validation by treating empty or blank inline JSON fields as absent, ensuring the task fails clearly if neither inline JSON nor a valid resource file is provided.

dolphinscheduler-task-plugin/dolphinscheduler-task-datax · high confidence

The DingTalk alert plugin has been rewritten to follow the new AlertChannel plugin interface, introducing a factory-based initialization model. This change adds support for Markdown message types alongside the existing text format, allows users to configure HTTP proxy settings (host, port, credentials) for restricted networks, and enables @mentioning specific users via mobile numbers or DingTalk IDs. The plugin now also supports secret-based signature verification for webhook security and includes retry logic for failed HTTP requests.

dolphinscheduler-alert/dolphinscheduler-alert-plugins/dolphinscheduler-alert-dingtalk/src/main · high confidence

The email alert plugin has been rewritten to implement the new AlertChannel and AlertChannelFactory interfaces, introducing a structured configuration model for SMTP settings (host, port, auth, TLS/SSL) and alert display modes (table, text, attachment). A key behavioral improvement is the new ExcelUtils component, which generates .xlsx attachments using Apache POI and explicitly truncates cell content exceeding the Excel 2007 character limit to prevent sending failures, addressing previous issues where long alert contents caused exceptions.

dolphinscheduler-alert/dolphinscheduler-alert-plugins/dolphinscheduler-alert-email/src/main/java/org/apache/dolphinscheduler/plugin/alert/email · high confidence

The API module now validates user permissions for specific task-level resources before allowing operations. New permission checkers ensure that users have access to datasources referenced by task definitions and possess write permissions for the projects containing sub-workflows referenced by tasks. This prevents unauthorized access to data sources and cross-project workflow execution.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/permission · high confidence

The Feishu alert plugin has been restructured into a new modular implementation (FeiShuAlertChannel, FeiShuAlertChannelFactory, FeiShuSender) that introduces configurable HTTP proxy support (enabling proxy, host, port, and authentication) and integrates an HTTP retry strategy for failed requests. The plugin now defines specific input parameters for these proxy settings and uses a dedicated sender class to handle message formatting and transmission, replacing the previous implementation.

dolphinscheduler-alert/dolphinscheduler-alert-plugins/dolphinscheduler-alert-feishu/src/main · high confidence

The Flink task plugin has been rewritten to support four deploy modes (local, cluster, application, standalone) and to allow parameter replacement in Flink SQL scripts. The new implementation introduces dedicated utility classes (FileUtils, FlinkArgsUtils, FlinkConstants) to generate SQL script files and build run commands based on the selected deploy mode and Flink version. It also adds a new FlinkParameters model to handle task configuration, including yarn queue support, and includes unit tests to verify command line generation for different modes and parameter substitution in SQL scripts.

dolphinscheduler-task-plugin/dolphinscheduler-task-flink · high confidence

The HTTP task plugin has been refactored to support configurable TCP keepalive on the request socket, allowing users to enable SO\_KEEPALIVE for persistent connections. The task now uses a structured parameter model (HttpParameters) that explicitly defines HTTP methods (GET, POST, PUT, DELETE), connection timeouts, and response validation conditions (default status code, custom status code, body contains, body not contains). This change introduces a new HttpCheckCondition enum and HttpConstants for cleaner validation logic, and ensures that task outputs are properly serialized and available for downstream tasks.

dolphinscheduler-task-plugin/dolphinscheduler-task-http · high confidence

This change introduces a new base thread class, BaseDaemonThread, and a utility class, ThreadUtils, to standardize how threads are created and managed within DolphinScheduler. All threads now extend BaseDaemonThread or are created via ThreadUtils, ensuring they are marked as daemon threads so they do not prevent the JVM from shutting down, and are equipped with a DefaultUncaughtExceptionHandler to log unexpected errors instead of causing silent hangs. Additionally, a ThreadLocalContext utility is added to safely manage per-thread timezone settings, helping to prevent memory leaks and context pollution in multi-threaded environments.

dolphinscheduler-common/src/main/java/org/apache/dolphinscheduler/common/thread · high confidence

The API security module now includes a new \AbstractAuthenticator\ base class that centralizes common login logic, including user validation, session creation, and session expiration checks, along with an \AbstractSsoAuthenticator\ for SSO implementations and a concrete \PasswordAuthenticator\ for standard username/password logins. This refactoring consolidates authentication behavior, ensuring consistent session handling and error reporting across different authentication types.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/security/impl · high confidence

The alert server now uses a new AlertConfig class to manage settings such as port, wait timeout, heartbeat interval, and sender parallelism. This configuration is validated on startup, ensuring the heartbeat interval is positive, sender parallelism is greater than zero, and the alert server address is automatically derived from the port if not explicitly set. The configuration values are logged at startup for visibility.

dolphinscheduler-alert/dolphinscheduler-alert-server/src/main/java/org/apache/dolphinscheduler/alert/config · high confidence

This change adds a suite of new Value Objects (AlertPluginInstanceVO, DataSourceSimpleInfoVO, ResourceItemVO, ScheduleVO, TaskDefinitionVO, TaskInstanceCountVO, UserSimpleInfoVO, WorkflowDefinitionCountVO, WorkflowInstanceCountVO, WorkflowInstanceSummaryVO, FetchFileContentResponse) to the API layer. Most notably, WorkflowInstanceSummaryVO replaces the full WorkflowInstance entity in list, top-N, and trigger queries, intentionally omitting heavy database-backed fields (commandParam, globalParams, historyCmd, varPool, stateHistory) and transient fields (stateDescList, dagData, locations, etc.) to improve query performance. This is an incompatible API change for consumers relying on those fields in list responses; they must now use the detail endpoint to retrieve them. Other VOs provide simplified or specialized data structures for alert plugins, resources, scheduling, and counting operations.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/vo · high confidence

The email alert plugin now uses a new \AlertTemplate\ interface and \DefaultHTMLTemplate\ implementation to format alert messages. This change ensures that alert content is consistently rendered as HTML tables, supporting both tabular data and text-based alerts, which improves readability and structure in email notifications.

dolphinscheduler-alert/dolphinscheduler-alert-plugins/dolphinscheduler-alert-email/src/main/java/org/apache/dolphinscheduler/plugin/alert/email/template · high confidence

The MySQL datasource plugin has been restructured to align with a new plugin architecture. This change introduces a \MySQLDataSourceChannelFactory\ and \MySQLDataSourceChannel\ to manage datasource channels, replacing previous direct client instantiation patterns. It adds \MySQLAdHocDataSourceClient\ and \MySQLPooledDataSourceClient\ to handle ad-hoc and pooled connections respectively, leveraging the new \BaseAdHocDataSourceClient\ and \BasePooledDataSourceClient\ base classes. The \MySQLDataSourceProcessor\ has been updated to use Druid for SQL splitting and comment removal, and enforces security by filtering sensitive JDBC parameters like \autoDeserialize\ and \allowLoadLocalInfile\. Additionally, connection parameter handling is now managed through dedicated \MySQLConnectionParam\ and \MySQLDataSourceParamDTO\ classes, and unit tests have been migrated to JUnit 5.

dolphinscheduler-datasource-plugin/dolphinscheduler-datasource-mysql · high confidence

This change introduces several new utility classes in the API layer to standardize input validation, response formatting, and data security. CheckUtils now provides dedicated methods for validating usernames, emails, passwords, phone numbers, and time zones, replacing ad-hoc checks. A new PageInfo class standardizes pagination query results, ensuring consistent total page counts in API responses. SensitivePropertyUtils implements masking logic for sensitive properties (replacing values with '\\\\\\' in HTTP responses) and handles placeholder restoration during updates and workflow starts. Additionally, Result simplifies API response construction, RegexUtils centralizes regex patterns, and WorkflowUtils adds helpers for parsing workflow backfill parameters.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/utils · high confidence

The API layer now includes dedicated validator components to enforce data integrity before workflow operations proceed. Global and start parameters are validated to ensure keys are non-empty and unique, preventing duplicate or missing parameter definitions. Additionally, a new tenant validator ensures that the specified tenant code exists in the system before allowing workflow creation or updates.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/validator · high confidence

A new constant class, ApiFuncIdentificationConstant, has been added to define granular permission keys for API endpoints. This file establishes a unified mapping for security resources (such as tokens, alert groups, tenants, and worker groups), project management operations (including workflow definitions, instances, and task executions), data source management, resource task groups, and monitoring views. It also includes a static map linking execution types to their corresponding permission identifiers, providing the foundational permission strings used by the API layer.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/constants · high confidence

A new \config/plugins\_config\ file has been introduced to centrally manage and resolve plugin artifact IDs for DolphinScheduler. This configuration file explicitly lists available plugins across four categories: alert, datasource, storage, and task. Notable additions include the DolphinDB datasource (\dolphinscheduler-datasource-dolphindb\) and the gRPC task (\dolphinscheduler-task-grpc\), while the PyTorch task type is not present in this list, reflecting the removal mentioned in the commit history. This file serves as the mapping source for loading the correct JAR packages without version numbers.

config · high confidence

The UI service layer for cluster management has been reorganized into a dedicated module under \src/service/modules/cluster\. This change introduces a new \index.ts\ file that centralizes API calls for creating, deleting, updating, verifying, and listing clusters (including paging and all-list queries), along with a \types.ts\ file defining the request and response interfaces. This structure supports the broader multi-cluster environment capabilities by providing a clean, typed interface for cluster operations.

dolphinscheduler-ui/src/service/modules/cluster · high confidence

The API layer now introduces three new data transfer objects in the workflowInstance package to replace generic return types: WorkflowExecuteResponse for execution results, WorkflowInstanceTaskListDTO for retrieving task lists along with workflow state, and WorkflowInstanceVariablesDTO for accessing global and local workflow parameters. These changes provide structured, type-safe responses for workflow instance operations, improving API clarity and reducing the need for client-side casting of generic maps.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/dto/workflowInstance · high confidence

The API layer now uses dedicated, strongly-typed Data Transfer Objects for key workflow operations. A new WorkflowBackFillRequest DTO replaces generic parameter passing for backfill tasks, explicitly defining fields such as start/end dates, parallelism, and execution order. Similarly, WorkflowDefinitionVariablesDTO provides structured access to global and local workflow parameters, and WorkflowTriggerRequest standardizes the inputs for triggering workflow instances. These changes improve API clarity and type safety for users interacting with workflow backfill, variable viewing, and triggering endpoints.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/dto/workflow · high confidence

The API layer now enforces stricter validation and structured transformation for workflow trigger and backfill requests. New validator components ensure that workflows are in an ONLINE state before triggering, validate tenant existence, and check start parameters. For backfill operations, the system now explicitly requires the execution type to be COMPLEMENT\_DATA and validates backfill date ranges and parallelism settings. Request transformers handle the conversion of incoming API requests into internal DTOs, including resolving workflow definitions by code and processing sensitive start parameters.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/validator/workflow · high confidence

The PostgreSQL datasource plugin has been refactored to use a new channel-based architecture, introducing dedicated AdHoc and Pooled SQL data source clients, a DataSourceChannel, and a DataSourceChannelFactory to manage connections. Additionally, the PostgreSQLDataSourceProcessor now utilizes Druid for SQL splitting and includes custom logic to correctly preserve PostgreSQL PL/pgSQL DO blocks (dollar-quoted strings) during statement separation, preventing execution errors for scripts containing these constructs.

dolphinscheduler-datasource-plugin/dolphinscheduler-datasource-postgresql · high confidence

The \dolphinscheduler-common\ module has reorganized its global constants into specific, focused classes (\CommandKeyConstants\, \Constants\, \DateConstants\, \SystemConstants\, \TenantConstants\) to improve code clarity and maintainability. This change introduces Lombok annotations, such as \@UtilityClass\ in \Constants\ and \@Slf4j\ in \SystemConstants\, to reduce boilerplate and standardize initialization patterns. For users, this is a structural cleanup that consolidates configuration keys, date formats, and system parameters into a more organized package structure without altering external API behavior.

dolphinscheduler-common/src/main/java/org/apache/dolphinscheduler/common/constants · high confidence

The API server startup process now uses a dedicated \jvm\_args\_env.sh\ file to define JVM arguments, including memory settings, GC logging, and error handling options like \ExitOnOutOfMemoryError\. The \start.sh\ script has been updated to source this new configuration file, allowing for easier management of JVM parameters. Additionally, the startup script now explicitly handles Docker environments by disabling container support when the \DOCKER\ environment variable is set to true, and it correctly constructs the classpath to include plugin directories for datasources, storage, and tasks.

dolphinscheduler-api/src/main/bin · high confidence

The alert server startup script (start.sh) now reads JVM configuration from a dedicated jvm\_args\_env.sh file, allowing for easier management of memory settings (1g heap, 512m young gen) and GC logging. This change introduces specific JVM flags including -XX:+ExitOnOutOfMemoryError for immediate termination on OOM, -XX:-OmitStackTraceInFastThrow to preserve stack traces, and timezone support via ${SPRING\_JACKSON\_TIME\_ZONE}. The script also handles Docker-specific container support flags and ensures plugin paths are correctly added to the classpath.

dolphinscheduler-alert/dolphinscheduler-alert-server/src/main/bin · high confidence

The datasource API module has been restructured to introduce a centralized plugin management system and standardized connection handling. A new DataSourcePluginManager now loads and registers DataSourceProcessors and DataSourceChannels via SPI, replacing previous direct instantiation patterns. Connection retrieval is now routed through DataSourceClientProvider, which implements a Guava-based cache for pooled clients (with configurable expiration) and provides dedicated accessors for ad-hoc connections. The module introduces base client implementations (BaseAdHocDataSourceClient and BasePooledDataSourceClient) that standardize connection lifecycle management, and a new DataSourceConstants class centralizes driver names, JDBC URL prefixes, validation queries, and configuration keys for supported databases. Input validation in AbstractDataSourceProcessor has been enhanced to check for malicious parameters and enforce stricter host/database patterns, while utility classes like DataSourceUtils and CommonUtils provide consolidated helpers for parameter building, connection retrieval, and Kerberos configuration loading.

dolphinscheduler-datasource-plugin/dolphinscheduler-datasource-api · high confidence

The registry API module has been refactored to introduce a new \Registry\ SPI interface, replacing the previous implementation. This change adds support for connection state tracking via \ConnectionListener\ and \ConnectionState\, structured event notifications through the \Event\ class, and configurable subscription scopes (\PATH\_ONLY\, \CHILDREN\_ONLY\, \ALL\) via \SubscribeListener\. It also introduces a dedicated \RegistryLock\ handle for safer lock management and a new \HAServer\ abstraction with \AbstractHAServer\ to facilitate high-availability leader election and status change notifications for master, worker, and alert server nodes.

dolphinscheduler-registry/dolphinscheduler-registry-api · high confidence

The script alert plugin has been restructured to use a new \ScriptAlertChannel\ and \ScriptAlertChannelFactory\ that define parameters for script path, type, and user-defined inputs. Execution is now handled by a dedicated \ScriptSender\ and \ProcessUtils\ class, which validates that the script exists, is a file, and ends with \.sh\ before running it via \ProcessBuilder\. The implementation now uses \lombok @Slf4j\ for logging and \commons-collections4\ for map utilities, replacing previous approaches with a more robust and structured execution flow.

dolphinscheduler-alert/dolphinscheduler-alert-plugins/dolphinscheduler-alert-script/src/main · high confidence

The Resource Center API now uses a new set of data transfer objects (DTOs) and request models in the \dolphinscheduler-api\ module to handle resource operations. This change introduces specific classes for creating directories and files (including from content), updating files, deleting resources, renaming directories and files, downloading files, and fetching file content. These new models replace previous ad-hoc parameter handling, providing a structured interface for resource management actions such as upload, download, and tree navigation.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/dto/resources · high confidence

The frontend service layer for the Resource Center has been reorganized into a dedicated module under \src/service/modules/resources\. This change introduces a new \index.ts\ file that centralizes API calls for resource management (such as listing, creating, updating, and viewing resources) and a \types.ts\ file defining the request and response interfaces. For users, this represents a structural improvement to how resource-related data is fetched and managed in the UI, ensuring consistent typing and clearer separation of concerns for resource operations.

dolphinscheduler-ui/src/service/modules/resources · high confidence

The utility classes in the common module have been completely rewritten to improve reliability and maintainability. DateUtils now uses the Java 8 java.time API for timezone-aware formatting, resolving previous display mismatches. JSONUtils has been migrated to Jackson with explicit configuration for unknown properties and enums, and now throws exceptions on parse failures instead of returning null. HttpUtils now enforces secure SSL context validation and validates HTTP response status codes. NetUtils has been updated to properly support IPv6 addresses and allows filtering of network interfaces. Additionally, new utilities include CodeGenerateUtils for unique ID generation, EncryptionUtils for MD5 hashing, and MaskUtils for sensitive data masking.

dolphinscheduler-common/src/main/java/org/apache/dolphinscheduler/common/utils · high confidence

The SQL Server datasource plugin has been restructured to support the new datasource channel and client model. This change introduces dedicated AdHoc and Pooled data source clients (SQLServerAdHocDataSourceClient and SQLServerPooledDataSourceClient) and a corresponding channel factory, enabling the system to use AdHoc clients for SQL tasks. The SQLServerDataSourceProcessor now leverages Druid for SQL splitting and comment removal, ensuring correct statement termination. Connection parameter handling has been updated to use the new SQLServerConnectionParam and SQLServerDataSourceParamDTO classes, and tests have been migrated to JUnit 5.

dolphinscheduler-datasource-plugin/dolphinscheduler-datasource-sqlserver · high confidence

The SQL task implementation has been refactored to support loading SQL content from resource files when the SQL parameter is empty, and to split SQL statements using a configurable delimiter (defaulting to semicolon) to allow execution of multiple statements in a single task. The refactoring introduces a new SqlBinds model to encapsulate SQL strings and their bound parameters, and updates the task execution flow to process pre-statements, main statements, and post-statements separately. Additionally, the task now supports cancellation of running SQL statements and improves parameter handling for list and global/local parameters.

dolphinscheduler-task-plugin/dolphinscheduler-task-sql · high confidence

The shell task plugin has been rewritten to use the new TaskChannel SPI, introducing a dedicated ShellParameters model for script and resource configuration, a ShellTaskChannel for task instantiation, and a ShellTaskChannelFactory for service discovery. This change modernizes the plugin's structure and improves parameter handling, though it represents a significant internal refactor of how shell tasks are defined and executed.

dolphinscheduler-task-plugin/dolphinscheduler-task-shell · medium confidence

The Spark task plugin has been rewritten to support submitting Spark tasks directly on Kubernetes (via the \namespace\ parameter and \k8s://\ master prefix) and to allow defining the YARN queue for submissions. The plugin now uses a new \SparkParameters\ model and \ProgramType\ enum to distinguish between SQL, Java, Scala, and Python programs, and includes a \SparkTaskChannelFactory\ for SPI registration. Users can now configure Kubernetes-specific options like driver labels and namespaces, and explicitly select YARN queues, while the task execution logic has been consolidated into \SparkTask\ to handle both \spark-submit\ and \spark-sql\ commands with the new parameter structure.

dolphinscheduler-task-plugin/dolphinscheduler-task-spark · high confidence

The project now enforces consistent Java code style through new configuration files in the \style\ directory. Developers will see automatic organization of imports (prioritizing \org.apache.dolphinscheduler\, then \org.apache\, \java\, \javax\, \org\, and \com\) and standardized formatting (4-space indentation, 120-character line limits, and specific spacing rules) applied via the Spotless plugin. Additionally, the license header template and Eclipse formatter profile are now explicitly defined to ensure uniform code structure across the codebase.

style · high confidence

The API server entry point has been consolidated into a new \ApiApplicationServer\ class that explicitly imports core configuration modules (DAO, common, service, storage, and registry) and registers a custom uncaught exception handler for better error logging. Upon application readiness, the server now explicitly triggers the loading of data source and task plugins into the database, ensuring these components are initialized immediately at startup rather than relying on implicit or deferred loading mechanisms.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api · high confidence

The WeChat alert plugin has been rewritten to support sending alerts to both individual users (APP) and group chats (APPCHAT) via a new send type parameter. The plugin now uses a factory pattern for instantiation and defines specific input parameters for Enterprise WeChat credentials (Corp ID, Secret, Agent ID) and message display formats (Markdown or Text). Message payloads are structured into distinct classes for app and app-chat targets, enabling proper routing to the correct WeChat API endpoints.

dolphinscheduler-alert/dolphinscheduler-alert-plugins/dolphinscheduler-alert-wechat/src/main · high confidence

The Worker server has been restructured to delegate physical task execution to the new dolphinscheduler-task-executor module, replacing the previous internal task queue and looper logic. This change introduces a new startup flow via WorkerServer that initializes the PhysicalTaskEngineDelegator, WorkerRpcServer, and WorkerRegistryClient, and exposes worker configuration (such as listen port, heartbeat interval, and load protection thresholds) through Spring Boot's @ConfigurationProperties in application.yaml. The worker now uses a dedicated JVM args file (jvm\_args\_env.sh) for memory and GC settings, and includes a new assembly descriptor to package the worker server with its dependencies and configuration files.

dolphinscheduler-worker · high confidence

Added API test cases for dependent, EMR Serverless, and gRPC tasks; Added API test coverage for core DolphinScheduler components and authentication; Added API test page objects for security resources; Added API test page objects for workflow execution, scheduling, and definition management; Added Docker test environments for Hive, MySQL, and S3 file management; Added Docker-based OIDC login test environment; Added SQL test resources for MySQL schema and data validation; Added core test infrastructure for API and E2E testing; Added end-to-end tests for security, resource, and data source management; Added integration test suite for registry implementations; Added test resource configurations for common properties, logging, and remote logging; Added test utility classes for API testing; Added tests for ClasspathSqlScriptParser; Added unit tests for API configuration and interceptors; Added unit tests for API controllers; Added unit tests for API exception handling; Added unit tests for API permission checks; Added unit tests for API service layer components; Added unit tests for API utility classes; Added unit tests for API validator components; Added unit tests for Aliyun Voice alert plugin; Added unit tests for Azure Blob Storage remote logging and log path handling; Added unit tests for Cluster, Environment, and Workflow Lineage services; Added unit tests for ExecuteType and Status enums; Added unit tests for HTTP alert plugin components; Added unit tests for K8sManager; Added unit tests for ListenerEventType and WorkflowExecutionStatus enums; Added unit tests for PythonGateway; Added unit tests for ResourceTreeVisitor; Added unit tests for ThreadUtils daemon thread creation and exception handling; Added unit tests for WeChat alert plugin factory and sender; Added unit tests for config property delegates; Added unit tests for email HTML template rendering; Added unit tests for local and delegated log client logic; Added unit tests for security authentication configuration and providers; Added unit tests for the DAG graph implementation; Added unit tests for the Webex Teams alert plugin; Added unit tests for the email alert plugin; Added unit tests for the script alert plugin; Added unit tests for workflow backfill and stop execution delegates.

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

• CAI 38 → 39 (+1.1)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 59 → 85 (+26.2)
• Architecture 56 → 59 (+2.3)
• Maturity 64 → 64 (-0.3)
• Readiness 34 → 35 (+1.2)
• Security 36 → 34 (-1.2)
• Accessibility 36 → 36 (+0.0)

• Change coupling: DbType.java ↔ types.ts (dolphinscheduler-spi/src/main/java/org/apache/dolphinscheduler/spi/enums/DbType.java)
• Change coupling: DbType.java ↔ use-form.ts (dolphinscheduler-spi/src/main/java/org/apache/dolphinscheduler/spi/enums/DbType.java)
• Change coupling: K8sTask.java ↔ use-k8s.ts (dolphinscheduler-task-plugin/dolphinscheduler-task-k8s/src/main/java/org/apache/dolphinscheduler/plugin/task/k8s/K8sTask.java)
• Change coupling: K8sTaskExecutor.java ↔ K8sTask.java (dolphinscheduler-task-plugin/dolphinscheduler-task-api/src/main/java/org/apache/dolphinscheduler/plugin/task/api/k8s/impl/K8sTaskExecutor.java)
• Change coupling: K8sTaskExecutor.java ↔ K8sTaskParameters.java (dolphinscheduler-task-plugin/dolphinscheduler-task-api/src/main/java/org/apache/dolphinscheduler/plugin/task/api/k8s/impl/K8sTaskExecutor.java)
• Change coupling: project.ts ↔ types.ts (dolphinscheduler-ui/src/locales/zh_CN/project.ts)
• Change coupling: project.ts ↔ use-spark.ts (dolphinscheduler-ui/src/locales/zh_CN/project.ts)
• CodeEditor.content (cognitive 20) (dolphinscheduler-e2e/dolphinscheduler-e2e-case/src/test/java/org/apache/dolphinscheduler/e2e/pages/common/CodeEditor.java)
• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (dolphinscheduler-ui/pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (dolphinscheduler-ui/pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (dolphinscheduler-ui/pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (tools/release/requirements.txt)
• Critical CVE: [GHSA redacted] (dolphinscheduler-ui/pnpm-lock.yaml)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (dolphinscheduler-alert/dolphinscheduler-alert-plugins/dolphinscheduler-alert-telegram/src/main/java/org/apache/dolphinscheduler/plugin/alert/telegram/TelegramSender.java)
• Duplicated block (10 lines × 2) (dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/dto/treeview/Instance.java)
• Duplicated block (10 lines × 2) (dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/ProjectParameterServiceImpl.java)
• Duplicated block (10 lines × 2) (dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/TaskGroupServiceImpl.java)
• Duplicated block (10 lines × 2) (dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/UsersServiceImpl.java)
• …and 232 more

• Boundary-crossing change coupling: WorkflowInstanceDaoImpl.java ↔ DependentExecute.java (dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/repository/impl/WorkflowInstanceDaoImpl.java)
• CI installs an unverified third-party binary (.github/workflows/e2e-k8s.yml)
• Change coupling: K8sTaskExecutor.java ↔ use-k8s.ts (dolphinscheduler-task-plugin/dolphinscheduler-task-api/src/main/java/org/apache/dolphinscheduler/plugin/task/api/k8s/impl/K8sTaskExecutor.java)
• Change coupling: NettyRemotingClient.java ↔ NettyRemotingServer.java (dolphinscheduler-extract/dolphinscheduler-extract-base/src/main/java/org/apache/dolphinscheduler/extract/base/client/NettyRemotingClient.java)
• Change coupling: TaskDefinitionController.java ↔ TaskDefinitionServiceImpl.java (dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller/TaskDefinitionController.java)
• Change coupling: common.ts ↔ project.ts (dolphinscheduler-ui/src/common/common.ts)
• Change coupling: types.ts ↔ project.ts (dolphinscheduler-ui/src/common/types.ts)
• Change coupling: use-k8s.ts ↔ format-data.ts (dolphinscheduler-ui/src/views/projects/task/components/node/fields/use-k8s.ts)
• Change-coupling hub: DbType.java → types.ts, use-form.ts, use-datasource.ts (dolphinscheduler-spi/src/main/java/org/apache/dolphinscheduler/spi/enums/DbType.java)
• Change-coupling hub: K8sTask.java → K8sTaskExecutor.java, project.ts, use-k8s.ts, format-data.ts, types.ts (dolphinscheduler-task-plugin/dolphinscheduler-task-k8s/src/main/java/org/apache/dolphinscheduler/plugin/task/k8s/K8sTask.java)
• Change-coupling hub: K8sTaskParameters.java → K8sTaskExecutor.java, project.ts, use-k8s.ts, format-data.ts, types.ts (dolphinscheduler-task-plugin/dolphinscheduler-task-api/src/main/java/org/apache/dolphinscheduler/plugin/task/api/parameters/K8sTaskParameters.java)
• Change-coupling hub: project.ts → K8sTaskParameters.java, K8sTask.java, common.ts, types.ts, use-k8s.ts, use-spark.ts, types.ts (dolphinscheduler-ui/src/locales/zh_CN/project.ts)
• ClassTooLong: ProcessServiceImpl (dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessServiceImpl.java)
• ClassTooLong: Status (dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/enums/Status.java)
• ClassTooLong: UsersServiceImpl (dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/UsersServiceImpl.java)
• ClassTooLong: WorkflowDefinitionServiceImpl (dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/WorkflowDefinitionServiceImpl.java)
• ClassTooLong: WorkflowInstanceServiceImpl (dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/WorkflowInstanceServiceImpl.java)
• Coverage not measured — no coverage collector is wired up
• Critical CVE: [GHSA redacted] (tools/release/requirements.txt)
• Critical CVE: [GHSA redacted] (dolphinscheduler-ui/pnpm-lock.yaml)
• …and 778 more

• 47 commits — 23 feature/other, 24 fixes

• dolphinscheduler-api/src — 15 commits
• dolphinscheduler-master/src — 5 commits
• dolphinscheduler-dao/src — 4 commits
• docs/configs — 3 commits
• docs/docs — 3 commits
• (root) — 2 commits
• dolphinscheduler-common/src — 2 commits
• dolphinscheduler-e2e/dolphinscheduler-e2e-case — 2 commits
• dolphinscheduler-ui/src — 2 commits
• .github/workflows — 1 commit
• deploy/kubernetes — 1 commit
• docs/img — 1 commit
• dolphinscheduler-authentication/dolphinscheduler-actuator-authentication — 1 commit
• dolphinscheduler-registry/dolphinscheduler-registry-plugins — 1 commit
• dolphinscheduler-storage-plugin/dolphinscheduler-storage-abs — 1 commit
• dolphinscheduler-storage-plugin/dolphinscheduler-storage-oss — 1 commit
• dolphinscheduler-task-plugin/dolphinscheduler-task-api — 1 commit
• dolphinscheduler-task-plugin/dolphinscheduler-task-datax — 1 commit

• fix: [Chore] Fix ci error in FileManageE2ETest (#18638)
• fix: [Chore][Doc] Fix duplicated characters in Chinese docs (#18650)
• fix: [Doc-18474][Upgrade] Fix zh/en incompatible upgrade docs out of sync (#18478)
• fix: [Doc-18579] Fix malformed links in datasource and configuration docs (#18578)
• fix: [Doc-18617][README] Fix broken Python SDK documentation link (#18615)
• fix: [Doc-18618][Doc] Fix broken Python SDK documentation links in README_zh_CN and docs (#18619)
• fix: [Fix-17883] Fix K8s Alert HTTP test sending failed by using IP for non-StatefulSet pods (#17883) (#18574)
• fix: [Fix-18389][DataX] Read job definition from attached resource file when custom json is empty (#18434)
• fix: [Fix-18538][Master] Schedule task retry at endTime + retryInterval (#18539)
• fix: [Fix-18540][Master] Reset the runtime state when recreating a failed task instance (#18541)
• fix: [Fix-18543][DAO] Return only the valid task instance per task code (#18544)
• fix: [Fix-18559][API] Align workflow mutations with project write permissions (#18561)
• fix: [Fix-18565][API] Validate datasource access for task definitions (#18566)
• fix: [Fix-18570][Master] Detect wrapped CommandDuplicateHandleException in bootstrapError (#18570) (#18573)
• fix: [Fix-18576][TaskPlugin] Fix parsing for ALL dependent tasks (#18605)
• fix: [Fix-18582][Authentication] Align actuator endpoint matching (#18583)
• fix: [Fix-18596][API] Enforce permission checks for sub-workflow references (#18597)
• fix: [Fix-18601][Alert] Align Alert Script test-send behavior (#18602)
• fix: [Fix-18604][Master] Preserve forced-success state when recovering failed workflows (#18608)
• fix: [Fix-18624][Master] Make WorkflowSerialCoordinator restartable after HA failover- #18623 (#18623)
• …and 27 more

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

apache/dolphinscheduler 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.