- Introduce pooled tunnel sessions (TunnelID/DataConnect) on client/server
- Proxy HTTP/HTTPS via raw HTTP over yamux streams; pipe TCP streams directly
- Move UI/stats into internal/shared; refactor CLI tunnel helpers; drop msgpack/hpack legacy
Move the initialization of the mutex lock after the structure is created to ensure that the condition variable can correctly reference the mutex lock instance.
This can avoid potential race conditions and improve code readability.
A new FlowControl frame type has been added for backpressure control between the client and server, and SafeFrame has been introduced.
Frame resource management has been encapsulated to ensure that frame data is correctly returned to the memory pool after use. The frame processing logic has also been optimized.
The way frame.Release() is called improves code security and maintainability.
feat(client): Implements queue pressure monitoring and flow control signal sending functions.
Add the `monitorQueuePressure` method to periodically check the length of the `dataFrameQueue`, and trigger an alarm when the queue usage exceeds a threshold.
Automatically send flow control commands to the server to pause or resume writing, preventing data backlog and connection interruptions caused by slow consumption speed.
feat(server): Supports receiving and responding to flow control requests from clients.
The `handleFlowControl` and `sendWithBackpressure` methods have been added to enable backpressure control of received data frames on the server side.
By blocking the sending process using a condition variable until the client releases the pause state, connection stability is ensured under high load.
refactor(client): Reduces redundant resource release operations during frame processing.
Use SafeFrame to manage frame lifecycles uniformly, replacing manual frame.Release() with defer sf.Close() in multiple frame handlers.
This avoids the risk of memory leaks caused by unreleased abnormal paths.
perf(client): Shorten the shutdown timeout to speed up resource reclamation.
The forced shutdown wait time in the tunnel runner and connector has been adjusted from 5 seconds and 3 seconds to 2 seconds to improve the program exit response speed.
- Adjust the delayed formatting function to prioritize checking if the delay is 0 to avoid displaying errors.
- When the delay is less than 1 millisecond, it is displayed in microseconds to improve the precision of the expression.
feat (constants): Shorten heart rate intervals and timeouts to improve response speed.
- Adjust HeartbeatInterval from 5 seconds to 2 seconds
- Adjust HeartbeatTimeout from 15 seconds to 6 seconds
- Improve the sensitivity of heartbeat detection between the client and the server
A new recovery package has been added, containing Recoverer and PanicMetrics, for capturing panics in goroutines.
It records stack trace information and provides statistical metrics. This mechanism is also integrated into the TCP connector and listener.
Enhance service stability and observability.
- Added support for HTTPS tunnel types to the `drip stop` command and updated the example documentation.
- Optimized token display logic to adapt to token formats of different lengths.
- Adjust the alignment of FrameHandler buffer read/write and timeout configuration formats.
- Move the error handling logic location to ensure data read integrity.
- Introducing context to control request lifecycle and supporting cancel transfer in proxy handlers
- The hop-by-hop header judgment format in the unified response header filtering rules
- Add a context-aware streaming request cancellation mechanism and extend the channel cleanup timeout.
- Add a context control field to the TCP connection structure to support connection lifecycle management.
- Format the httpResponseWriter field comments
Replace json.NewEncoder.Encode with json.Marshal and w.Write.
Add a Content-Length header to ensure the integrity and correctness of the response data.
At the same time, error handling is enhanced to avoid potential coding failures.
- Set a read timeout before the TLS handshake to prevent slow handshake attacks
- Clear the read timeout setting after a successful handshake
- Enable session resumption for server and client TLS configurations
- Explicitly prioritize the use of server-side cipher suites (ignored in TLS 1.3 but retained to ensure consistency)
Replaces the fixed-size buffers in `FrameHandler` and `Handler` with dynamic buffers obtained from the buffer pool,
to reduce memory allocation and improve performance. Also updates the logo path in the README to match the new resource directory structure.
- Add runtime performance optimization configurations to main.go, including setting GOMAXPROCS, adjusting GC frequency, and memory limits.
- Implement a worker pool-based data frame processing mechanism in connector.go to improve processing capabilities under high concurrency.
- Adjust frame writer configuration to improve batch write efficiency and enable adaptive refresh strategy.
- Add callback handling support for write errors to enhance connection stability.
refactor(server): Introduce an adaptive buffer pool to optimize memory usage
- Add adaptive_buffer_pool.go to implement large and small buffer reuse, reducing memory allocation overhead.
- Apply buffer pool management for large/medium temporary buffers in proxy handlers and TCP connections.
- Change the HTTP response writer to a cached bufio.Writer to improve I/O performance.
- Optimize HTTP request reading logic and response sending process.
build(docker): Update mount paths and remove unused named volumes
- Modify the data directory mount method in docker-compose.release.yml. ./data:/app/data
- Remove the unnecessary drip-data named volume definition
test(script): Add performance testing and profiling scripts
- Add profile-test.sh script for automating stress testing and performance data collection
- Supports collecting pprof data such as CPU, stack traces, and coroutines and generating analysis reports
The Docker Hub login step and image push configuration have been removed from the GitHub Actions workflow,
retaining only the push logic for the GitHub Container Registry. This simplifies the CI process and avoids
unnecessary Docker Hub-related operations.
Replaced the original `<p>` tags with `<div>` tags for better alignment and layout control,
while maintaining content centering. This change applies to the README.md and README_CN.md files.
Added support for HTTP response context cancellation, including logic for registering, triggering, and cleaning up cancellation functions.
Introduced a responseCancels mapping and corresponding synchronization lock in FrameHandler to track and control the request lifecycle.
When the data frame type is closed, actively called cancelResponse to release related resources.
Simultaneously, during the response body reading process, identified context cancellation or timeout errors and prematurely terminated the processing flow to avoid invalid operations.
- Changed the previous separate client and server installation method to a unified entry point, distinguished by the `--client` or `--server` parameters.
- Provided examples of non-interactive installation commands.
- Synchronized the installation guidance in the English and Chinese README documents.
- Removed the separate `install-server.sh` script content display, as it has been integrated into the new `install.sh` script.
- Added panel printing functions (print_panel, print_subheader) to install-server.sh and install.sh,
for improved interface display.
- Introduced the ensure_command_access function to automatically link the drip command to system paths (e.g., /usr/local/bin),
improving command availability.
- Added complete uninstallation logic: Added uninstall.sh script, supporting client-side, server-side, or both uninstallation.
- install.sh supports triggering the uninstallation process with the --uninstall parameter and enhanced PATH cleanup mechanism.
- Unified multilingual prompts and optimized user experience.
The original method of storing multilingual messages using associative arrays was replaced with the functions `msg_en` and `msg_zh`,
to provide better shell compatibility. The `prompt_input` function was also introduced to unify user input logic,
improving stability and maintainability across different shell environments.
- Explicitly included golang.org/x/sys v0.38.0 in go.mod and removed indirect references
- Optimized process liveness detection logic on Windows platforms using the golang.org/x/sys/windows package
- Used OpenProcess and GetExitCodeProcess instead of Signal detection methods to improve accuracy
- Updated command-line output and added an ASCII banner to improve user experience
- Added blank lines to the github.com/spf13/cobra package to standardize import format
Adds a `lastActivityAt` field to the `streamingResponseEntry` structure to record the last active time of the streaming response.
Updates this timestamp when creating the streaming response, sending headers, and sending data blocks.
Modifies the logic for cleaning up timeout channels, using the last activity time instead of the creation time to determine if a timeout has occurred, improving accuracy in long-connection scenarios.
Redundant comments have been removed from the `WriteFrame` and heartbeat control methods, and logic for releasing unprocessed frames in the queue has been added to the `Close` method to ensure proper resource reclamation. Some unnecessary channel signal comments have also been removed, making the code more concise and clear.
Added the `--short` flag to the `version` command for printing version information without styles.
In this mode, only the version, Git commit hash, and build time in plain text format will be output, facilitating script parsing.
Optimized Windows process detection logic to improve runtime accuracy.
Removed redundant comments and simplified signal checking methods, making the code clearer and easier to maintain.
refactor(protocol): Replaced string matching of data frame types with enumeration types.
Unified the representation of data frame types in the protocol, using the `DataType` enumeration to improve performance and readability.
Introduced a pooled buffer mechanism to improve memory efficiency in high-load scenarios.
refactor(ui): Adjusted style definitions, removing hard-coded color values.
Removed fixed color settings from some lipgloss styles, providing flexibility for future theme customization.
``` docs(install): Improved the version extraction function in the installation script.
Added the `get_version_from_binary` function to enhance version identification capabilities, prioritizing plain mode output, ensuring accurate version number acquisition for the drip client or server across different terminal environments.
perf(tcp): Improved TCP processing performance and connection management capabilities.
Adjusted HTTP client transmission parameter configuration, increasing the maximum number of idle connections to accommodate higher concurrent requests.
Improved error handling logic, adding special checks for common cases such as closing network connections to avoid log pollution.
chore(writer): Expanded the FrameWriter queue length to improve batch write stability.
Increased the FrameWriter queue size from 1024 to 2048, and released pooled resources after flushing, better handling sudden traffic spikes and reducing memory usage fluctuations.
- Unified logo size and optimized layout using HTML tags
- Replaced headings with semantic tags `<h1>` and `<h3>`
- Reorganized the document structure to enhance readability and visual appeal
- Optimized Chinese descriptions for a more natural and fluent style
- Adjusted the installation, usage instructions, and architecture diagram descriptions
- Standardized the display of command-line options and parameters
Added a heartbeatControl channel to support dynamic start/stop of the heartbeat function and optimized related resource management logic,
ensuring that the heartbeat ticker can be correctly stopped and rebuilt. Also adjusted the field initialization order to ensure concurrency safety.
fix(ui): Improved the tunnel connection status display style
Updated the URL line display content, added the "(forwarded link)" prompt text; adjusted the style layout of the local forwarding address and prompt information,
making the interface clearer and easier to read.
- Optimized terminal output style and configuration management using libraries such as `lipgloss` and `go-json`
- Introduced the `ui` package to unify the display logic of colors, tables, and prompts
- Updated the README document structure and installation script links to improve readability and internationalization support
- Improved the interaction flow and log display effects of the daemon startup and attach commands
- Fixed some command parameter parsing issues, improving program robustness and user onboarding experience
The previous method of obtaining commit hashes via `git rev-parse` has been changed to directly using the `github.sha` variable provided by GitHub Actions,
and the first 10 characters are truncated as the short version commit hash.
Unnecessary `fetch-depth` configuration has also been removed.
In GitHub Actions' release workflow, the `ldflags` parameter has been added to the build command for each platform,
to inject the application version number, Git commit hash, and build time. This facilitates subsequent debugging and release tracking.
Updated client and server installation scripts to automatically fetch the latest release via the GitHub API and corrected binary download addresses. Removed the old "latest" version logic to ensure explicit version tags are always used for downloads.
fix(readme): Fixed installation commands and license information in the README.
Corrected the installation script link pointing to an incorrect URL in the README to the correct path raw.githubusercontent.com, and updated the open-source license information used by the project from MIT to BSD 3-Clause.
ci(release): Added an automated GitHub Actions release workflow.
Added a new CI workflow configuration file to trigger the build process when a tag is pushed. This workflow compiles binaries for multiple platforms, generates checksums, and creates a GitHub Release with attachments. Supports different architectures including Linux, macOS, and Windows.
