File size: 5,532 Bytes
22728c9 5f82b66 22728c9 5f82b66 22728c9 5f82b66 22728c9 5f82b66 845f74c 22728c9 5f82b66 845f74c 5f82b66 845f74c 22728c9 5f82b66 845f74c 22728c9 5f82b66 845f74c 5f82b66 22728c9 5f82b66 22728c9 5f82b66 845f74c 5f82b66 22728c9 5f82b66 22728c9 5f82b66 845f74c 5f82b66 22728c9 5f82b66 845f74c 5f82b66 845f74c 5f82b66 22728c9 5f82b66 22728c9 5f82b66 22728c9 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 | package executor
import (
"context"
"net"
"net/http"
"net/url"
"strconv"
"strings"
"sync"
"time"
"github.com/router-for-me/CLIProxyAPI/v6/internal/config"
cliproxyauth "github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/auth"
log "github.com/sirupsen/logrus"
"golang.org/x/net/proxy"
)
var transportPool sync.Map
// newProxyAwareHTTPClient creates an HTTP client with proper proxy configuration priority:
// 1. Use auth.ProxyURL if configured (highest priority)
// 2. Use cfg.ProxyURL if auth proxy is not configured
// 3. Use RoundTripper from context if neither are configured
func newProxyAwareHTTPClient(ctx context.Context, cfg *config.Config, auth *cliproxyauth.Auth, timeout time.Duration) *http.Client {
httpClient := &http.Client{}
if timeout > 0 {
httpClient.Timeout = timeout
}
// Priority 1: Use auth.ProxyURL if configured
var proxyURL string
if auth != nil {
proxyURL = strings.TrimSpace(auth.ProxyURL)
}
// Priority 2: Use cfg.ProxyURL if auth proxy is not configured
if proxyURL == "" && cfg != nil {
proxyURL = strings.TrimSpace(cfg.ProxyURL)
}
keepAliveEnabled := true
if cfg != nil {
keepAliveEnabled = cfg.HTTPKeepAlive.Enabled
}
// If we have a proxy URL configured, set up the transport.
if proxyURL != "" {
if keepAliveEnabled {
if pooled := getOrCreatePooledTransport(proxyURL, cfg); pooled != nil {
httpClient.Transport = pooled
return httpClient
}
} else {
transport := buildProxyTransport(proxyURL, cfg, false)
if transport != nil {
httpClient.Transport = transport
return httpClient
}
}
// If proxy setup failed, log and fall through to context RoundTripper.
log.Debugf("failed to setup proxy from URL: %s, falling back to context/default transport", proxyURL)
}
// Priority 3: Use RoundTripper from context (typically from RoundTripperFor)
if rt, ok := ctx.Value("cliproxy.roundtripper").(http.RoundTripper); ok && rt != nil {
httpClient.Transport = rt
return httpClient
}
if keepAliveEnabled {
httpClient.Transport = getOrCreatePooledTransport("", cfg)
} else {
httpClient.Transport = buildProxyTransport("", cfg, false)
}
return httpClient
}
func pooledTransportKey(proxyURL string, cfg *config.Config) string {
idle := 120
maxIdle := 512
maxPerHost := 128
if cfg != nil {
if cfg.HTTPKeepAlive.IdleConnTimeoutSeconds > 0 {
idle = cfg.HTTPKeepAlive.IdleConnTimeoutSeconds
}
if cfg.HTTPKeepAlive.MaxIdleConns > 0 {
maxIdle = cfg.HTTPKeepAlive.MaxIdleConns
}
if cfg.HTTPKeepAlive.MaxIdleConnsPerHost > 0 {
maxPerHost = cfg.HTTPKeepAlive.MaxIdleConnsPerHost
}
}
return strings.Join([]string{proxyURL, strconv.Itoa(idle), strconv.Itoa(maxIdle), strconv.Itoa(maxPerHost)}, "|")
}
func getOrCreatePooledTransport(proxyURL string, cfg *config.Config) *http.Transport {
key := pooledTransportKey(proxyURL, cfg)
if existing, ok := transportPool.Load(key); ok {
if tr, ok := existing.(*http.Transport); ok {
return tr
}
}
created := buildProxyTransport(proxyURL, cfg, true)
if created == nil {
return nil
}
actual, _ := transportPool.LoadOrStore(key, created)
if tr, ok := actual.(*http.Transport); ok {
return tr
}
return created
}
// buildProxyTransport creates an HTTP transport configured for the given proxy URL.
// It supports SOCKS5, HTTP, and HTTPS proxy protocols.
func buildProxyTransport(proxyURL string, cfg *config.Config, keepAliveEnabled bool) *http.Transport {
parsedURL := &url.URL{}
if proxyURL != "" {
var errParse error
parsedURL, errParse = url.Parse(proxyURL)
if errParse != nil {
log.Errorf("parse proxy URL failed: %v", errParse)
return nil
}
}
var transport *http.Transport
maxIdle := 512
maxPerHost := 128
idleTimeout := 120 * time.Second
if cfg != nil {
if cfg.HTTPKeepAlive.MaxIdleConns > 0 {
maxIdle = cfg.HTTPKeepAlive.MaxIdleConns
}
if cfg.HTTPKeepAlive.MaxIdleConnsPerHost > 0 {
maxPerHost = cfg.HTTPKeepAlive.MaxIdleConnsPerHost
}
if cfg.HTTPKeepAlive.IdleConnTimeoutSeconds > 0 {
idleTimeout = time.Duration(cfg.HTTPKeepAlive.IdleConnTimeoutSeconds) * time.Second
}
}
baseTransport := &http.Transport{
MaxIdleConns: maxIdle,
MaxIdleConnsPerHost: maxPerHost,
IdleConnTimeout: idleTimeout,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
ForceAttemptHTTP2: true,
DisableKeepAlives: !keepAliveEnabled,
}
if parsedURL.Scheme == "" {
return baseTransport
}
// Handle different proxy schemes
if parsedURL.Scheme == "socks5" {
// Configure SOCKS5 proxy with optional authentication
var proxyAuth *proxy.Auth
if parsedURL.User != nil {
username := parsedURL.User.Username()
password, _ := parsedURL.User.Password()
proxyAuth = &proxy.Auth{User: username, Password: password}
}
dialer, errSOCKS5 := proxy.SOCKS5("tcp", parsedURL.Host, proxyAuth, proxy.Direct)
if errSOCKS5 != nil {
log.Errorf("create SOCKS5 dialer failed: %v", errSOCKS5)
return nil
}
// Set up a custom transport using the SOCKS5 dialer
transport = baseTransport.Clone()
transport.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
return dialer.Dial(network, addr)
}
} else if parsedURL.Scheme == "http" || parsedURL.Scheme == "https" {
// Configure HTTP or HTTPS proxy
transport = baseTransport.Clone()
transport.Proxy = http.ProxyURL(parsedURL)
} else {
log.Errorf("unsupported proxy scheme: %s", parsedURL.Scheme)
return nil
}
return transport
}
|