[jira] [Commented] (GSOC-334) Exploring a Lightweight Runtime and Designing a Pluggable Architecture for Apache Dubbo-Go

["Maxim Solodovnik (Jira)" <ji...@apache.org>]

    [ https://issues.apache.org/jira/browse/GSOC-334?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=18069336#comment-18069336 ] 

Maxim Solodovnik commented on GSOC-334:
---------------------------------------

Hello [~alexstocks], 
I beleive this JIRA should be moved to https://issues.apache.org/jira/browse/DUBBO project
(according to the rules GSOC project should be used ONLY in case PMC don't have JIRA ....)

> Exploring a Lightweight Runtime and Designing a Pluggable Architecture for Apache Dubbo-Go
> ------------------------------------------------------------------------------------------
>
>                 Key: GSOC-334
>                 URL: https://issues.apache.org/jira/browse/GSOC-334
>             Project: Comdev GSOC
>          Issue Type: Wish
>            Reporter: Alex Stocks
>            Priority: Major
>              Labels: Dubbo, dubbo-go, gsoc, gsoc2026
>   Original Estimate: 2,688h
>  Remaining Estimate: 2,688h
>
> h2. Abstract
> Dubbo-Go has evolved into a feature-rich RPC framework with a large ecosystem of extensions covering service discovery, registry, protocols, and governance. However, its current design favors “out-of-the-box” usability, where most components are implicitly enabled, resulting in unnecessary runtime overhead and limited flexibility.
> This project aims to introduce a controllable and extensible plugin mechanism to Dubbo-Go, enabling explicit loading and unloading of components and supporting a lightweight runtime mode. By defining a clear SPI (Service Provider Interface) layer, restructuring the startup process, and decoupling core runtime from optional features, this project will significantly improve modularity, maintainability, and deployment flexibility.
> The outcome will allow Dubbo-Go to support minimal runtime configurations, on-demand extension loading, and more scalable evolution of its ecosystem.
> h2. Detailed Description
> Dubbo-Go is a high-performance RPC framework in the Apache Dubbo ecosystem, providing a wide range of capabilities such as service discovery, registry integration, protocol implementations, and governance features.
> Currently, Dubbo-Go is designed for convenience: most extensions are automatically registered and enabled via mechanisms such as blank imports and {{init()}} functions. While this simplifies initial usage, it introduces several issues:
>  * *All plugins are implicitly enabled* Users cannot explicitly disable unnecessary components.
>  * *Complex runtime dependencies and long startup paths* Even simple RPC scenarios may trigger initialization of registry, governance, and configuration subsystems.
>  * *Tight coupling between core runtime and extensions* Many extensions reside in the main repository, blurring boundaries and increasing maintenance cost.
> Previous refactoring efforts have removed some low-usage extensions (e.g., Consul registry), but due to the lack of a unified plugin framework and stable SPI layer, these extensions cannot be reintroduced cleanly as optional components.
> Therefore, the core problem is not merely whether to introduce plugins, but:
> {quote}*How to design a controllable, modular, and backward-compatible plugin system that enables Dubbo-Go to support a lightweight runtime mode.*
> {quote}
> h2. Deliverables
> h3. Core Enhancements (Priority P0)
>  * Design and implement a *pluggable architecture*
>  ** Explicit plugin enable/disable mechanism
>  ** Replace implicit {{init()}}-based activation model
>  * Define a stable *SPI (Service Provider Interface) layer*
>  ** Clear extension points and boundaries
>  ** Reduce dependency on internal runtime structures
>  * Refactor Dubbo-Go *startup process*
>  ** Separate minimal runtime from optional components
>  ** Enable lightweight runtime mode
> h3. Ecosystem and Validation (Priority P1)
>  * Establish a new repository: *{{dubbo-go-extensions}}*
>  ** Host non-core plugins as independent Go modules
>  * Adapt multiple extensions (≥ 5)
>  ** Validate plugin mechanism generality
>  ** Ensure compatibility with lightweight runtime
>  * Restore at least one *historically removed extension* (e.g., Consul)
>  ** Re-integrate via SPI
>  ** Validate backward compatibility
> h3. Supporting Work (Priority P2)
>  * Documentation of startup process and plugin system
>  * Example projects demonstrating:
>  ** Lightweight runtime
>  ** On-demand plugin loading
>  * Migration and adaptation guidelines
> h2. Implementation Plan
> h3. Phase 1: Analysis and Design
>  * Analyze Dubbo-Go startup flow and plugin registration mechanism
>  * Identify implicit plugin loading patterns ({{init()}}, global registry)
>  * Define minimal runtime capability boundary
>  * Design plugin lifecycle:
>  ** discovery
>  ** registration
>  ** enable/disable
>  ** initialization
>  * Draft SPI interface design
> h3. Phase 2: Core Plugin Mechanism Implementation (P0)
>  * Implement plugin management system:
>  ** plugin registry
>  ** enable/disable control
>  * Ensure backward compatibility with existing behavior
>  * Introduce deterministic plugin initialization order
>  * Reduce reliance on Go package initialization order
> h3. Phase 3: SPI Stabilization and Architecture Refactoring (P1)
>  * Define stable SPI layer
>  * Separate core runtime from extensions
>  * Refactor internal dependencies to reduce coupling
>  * Ensure plugins can evolve independently
> h3. Phase 4: Extension Migration and Validation (P1)
>  * Migrate multiple extensions into independent modules
>  * Adapt extensions using new SPI
>  * Restore at least one removed extension (e.g., Consul)
>  * Validate:
>  ** plugin enable/disable
>  ** load order
>  ** runtime compatibility
> h3. Phase 5: Testing, Documentation, and Finalization (P2)
>  * Add unit and integration tests
>  * Validate backward compatibility
>  * Provide usage examples and documentation
>  * Prepare design documentation and final report
> h2. Required Skills
>  * Strong Go programming skills
>  * Understanding of modular system design and plugin architectures
>  * Familiarity with RPC frameworks and distributed systems
>  * Experience with dependency management and system initialization
>  * Ability to analyze and refactor existing codebases
> h2. Benefits to Apache Dubbo-go
>  * Enables lightweight runtime mode for resource-constrained environments
>  * Improves modularity and separation of concerns
>  * Reduces maintenance cost of core repository
>  * Supports independent evolution of extensions
>  * Enhances developer experience with explicit plugin control
>  * Provides a foundation for future runtime optimization and deployment flexibility
> h2. Conclusion
> This project introduces a modular and controllable plugin architecture for Dubbo-Go, enabling a lightweight runtime mode while maintaining backward compatibility. By defining a clear SPI layer and decoupling core and extensions, it significantly improves maintainability, flexibility, and long-term scalability of the Dubbo-Go ecosystem.
> h2. Useful Link
> [https://github.com/apache/dubbo-go/issues/2326] [https://github.com/apache/dubbo-go/issues/1981] [https://github.com/apache/dubbo-go-contrib/issues/2]
> h2. Contact Information
>  * Mentor: [alexstocks@apache.org|mailto:alexstocks@apache.org], Apache Dubbo PMC member



--
This message was sent by Atlassian Jira
(v8.20.10#820010)

---------------------------------------------------------------------
To unsubscribe, e-mail: gsoc-unsubscribe@community.apache.org
For additional commands, e-mail: gsoc-help@community.apache.org