mirror of
https://github.com/shadow1ng/fscan.git
synced 2025-09-14 05:56:46 +08:00
refactor: 系统性清理common包中的死代码和未使用变量
主要清理内容： - logging包：移除DetailedFormatter、JSONFormatter及相关方法 - output包：清理Manager和Statistics中的未使用方法 - parsers包：移除各Parser中的Validate()和GetStatistics()方法 - proxy包：清理Factory和Global中的所有未使用函数 - ProgressManager：移除未使用的进度条方法和字段 - globals：清理未使用的status变量 技术改进： - 使用deadcode和golangci-lint工具系统性检测 - 保持代码结构清晰，添加清理注释 - 修复相关依赖引用问题 - 确保编译通过和功能正常 代码减少：移除约40个死代码函数和多个未使用字段
This commit is contained in:
ZacharyZcR
parent
aff27e0b2c
commit
2f9c213e80
@ -507,6 +507,6 @@ func applyLogLevel() {
|
||||
|
||||
// 更新全局日志管理器
|
||||
globalLogger = newLogger
|
||||
status = newLogger.GetScanStatus()
|
||||
// status变量已移除，如需获取状态请直接调用newLogger.GetScanStatus()
|
||||
}
|
||||
}
|
||||
|
||||
@ -31,8 +31,6 @@ type ProgressManager struct {
|
||||
|
||||
// 输出缓冲相关
|
||||
outputMutex sync.Mutex
|
||||
pendingOutputs []string
|
||||
needProgressRedraw bool
|
||||
}
|
||||
|
||||
var (
|
||||
@ -96,22 +94,9 @@ func (pm *ProgressManager) UpdateProgress(increment int64) {
|
||||
pm.renderProgress()
|
||||
}
|
||||
|
||||
// SetProgress 设置当前进度
|
||||
func (pm *ProgressManager) SetProgress(current int64) {
|
||||
if !pm.enabled || !pm.isActive {
|
||||
return
|
||||
}
|
||||
|
||||
pm.mu.Lock()
|
||||
defer pm.mu.Unlock()
|
||||
|
||||
pm.current = current
|
||||
if pm.current > pm.total {
|
||||
pm.current = pm.total
|
||||
}
|
||||
|
||||
pm.renderProgress()
|
||||
}
|
||||
// =============================================================================================
|
||||
// 已删除的死代码（未使用）：SetProgress 设置当前进度
|
||||
// =============================================================================================
|
||||
|
||||
// FinishProgress 完成进度条
|
||||
func (pm *ProgressManager) FinishProgress() {
|
||||
@ -140,17 +125,9 @@ func (pm *ProgressManager) setupProgressSpace() {
|
||||
pm.lastContentLine = 0
|
||||
}
|
||||
|
||||
// moveToContentArea 移动到内容输出区域
|
||||
func (pm *ProgressManager) moveToContentArea() {
|
||||
// 对于简化的实现，直接在当前位置输出内容
|
||||
// 不需要复杂的光标移动
|
||||
}
|
||||
|
||||
// moveToProgressLine 移动到进度条位置
|
||||
func (pm *ProgressManager) moveToProgressLine() {
|
||||
// 移动到行首准备重绘进度条
|
||||
fmt.Print("\r")
|
||||
}
|
||||
// =============================================================================================
|
||||
// 已删除的死代码（未使用）：moveToContentArea 和 moveToProgressLine 方法
|
||||
// =============================================================================================
|
||||
|
||||
// renderProgress 渲染进度条（使用锁避免输出冲突）
|
||||
func (pm *ProgressManager) renderProgress() {
|
||||
@ -279,9 +256,9 @@ func UpdateProgressBar(increment int64) {
|
||||
GetProgressManager().UpdateProgress(increment)
|
||||
}
|
||||
|
||||
func SetProgressBar(current int64) {
|
||||
GetProgressManager().SetProgress(current)
|
||||
}
|
||||
// =============================================================================================
|
||||
// 已删除的死代码（未使用）：SetProgressBar 全局函数
|
||||
// =============================================================================================
|
||||
|
||||
func FinishProgressBar() {
|
||||
GetProgressManager().FinishProgress()
|
||||
|
||||
@ -151,7 +151,6 @@ func InitOutput() error {
|
||||
return err
|
||||
}
|
||||
ResultOutput = manager
|
||||
output.SetGlobalManager(manager)
|
||||
return nil
|
||||
}
|
||||
|
||||
|
||||
@ -85,7 +85,6 @@ var (
|
||||
OutputMutex sync.Mutex
|
||||
|
||||
// 日志状态
|
||||
status = logging.NewScanStatus()
|
||||
Num, End int64
|
||||
StartTime = time.Now()
|
||||
|
||||
|
||||
@ -68,58 +68,8 @@ func (f *StandardFormatter) getLevelPrefix(level LogLevel) string {
|
||||
}
|
||||
}
|
||||
|
||||
// DetailedFormatter 详细日志格式化器
|
||||
type DetailedFormatter struct {
|
||||
StandardFormatter
|
||||
includeSource bool
|
||||
includeMetadata bool
|
||||
}
|
||||
|
||||
// Format 格式化日志条目（包含详细信息）
|
||||
func (f *DetailedFormatter) Format(entry *LogEntry) string {
|
||||
baseFormat := f.StandardFormatter.Format(entry)
|
||||
|
||||
if f.includeSource && entry.Source != "" {
|
||||
baseFormat += fmt.Sprintf(" [%s]", entry.Source)
|
||||
}
|
||||
|
||||
if f.includeMetadata && len(entry.Metadata) > 0 {
|
||||
baseFormat += fmt.Sprintf(" %v", entry.Metadata)
|
||||
}
|
||||
|
||||
return baseFormat
|
||||
}
|
||||
|
||||
// JSONFormatter JSON格式化器
|
||||
type JSONFormatter struct {
|
||||
startTime time.Time
|
||||
}
|
||||
|
||||
// SetStartTime 设置开始时间
|
||||
func (f *JSONFormatter) SetStartTime(startTime time.Time) {
|
||||
f.startTime = startTime
|
||||
}
|
||||
|
||||
// Format 格式化为JSON格式
|
||||
func (f *JSONFormatter) Format(entry *LogEntry) string {
|
||||
elapsed := time.Since(f.startTime)
|
||||
|
||||
jsonStr := fmt.Sprintf(`{"level":"%s","time":"%s","elapsed_ms":%d,"content":"%s"`,
|
||||
entry.Level,
|
||||
entry.Time.Format("2006-01-02T15:04:05.000Z07:00"),
|
||||
elapsed.Milliseconds(),
|
||||
entry.Content)
|
||||
|
||||
if entry.Source != "" {
|
||||
jsonStr += fmt.Sprintf(`,"source":"%s"`, entry.Source)
|
||||
}
|
||||
|
||||
if len(entry.Metadata) > 0 {
|
||||
jsonStr += `,"metadata":`
|
||||
// 这里为简化处理，使用简单的格式
|
||||
jsonStr += fmt.Sprintf(`%v`, entry.Metadata)
|
||||
}
|
||||
|
||||
jsonStr += "}"
|
||||
return jsonStr
|
||||
}
|
||||
// =============================================================================================
|
||||
// 已删除的死代码（未使用）：
|
||||
// DetailedFormatter 及其 Format() 方法
|
||||
// JSONFormatter 及其 SetStartTime() 和 Format() 方法
|
||||
// =============================================================================================
|
||||
|
||||
@ -6,7 +6,6 @@ import (
|
||||
"log"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
@ -50,13 +49,9 @@ func NewLogger(config *LoggerConfig) *Logger {
|
||||
return logger
|
||||
}
|
||||
|
||||
// SetFormatter 设置格式化器
|
||||
func (l *Logger) SetFormatter(formatter LogFormatter) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
l.formatter = formatter
|
||||
l.formatter.SetStartTime(l.config.StartTime)
|
||||
}
|
||||
// =============================================================================================
|
||||
// 已删除的死代码（未使用）：SetFormatter 方法
|
||||
// =============================================================================================
|
||||
|
||||
// AddHandler 添加日志处理器
|
||||
func (l *Logger) AddHandler(handler LogHandler) {
|
||||
@ -308,32 +303,6 @@ func (h *ConsoleHandler) IsEnabled() bool {
|
||||
return h.enabled
|
||||
}
|
||||
|
||||
// 错误检查函数（保持原有逻辑）
|
||||
func CheckErrs(err error) error {
|
||||
if err == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
// 已知需要重试的错误列表
|
||||
errs := []string{
|
||||
"closed by the remote host", "too many connections",
|
||||
"EOF", "A connection attempt failed",
|
||||
"established connection failed", "connection attempt failed",
|
||||
"Unable to read", "is not allowed to connect to this",
|
||||
"no pg_hba.conf entry",
|
||||
"No connection could be made",
|
||||
"invalid packet size",
|
||||
"bad connection",
|
||||
}
|
||||
|
||||
// 检查错误是否匹配
|
||||
errLower := strings.ToLower(err.Error())
|
||||
for _, key := range errs {
|
||||
if strings.Contains(errLower, strings.ToLower(key)) {
|
||||
time.Sleep(1 * time.Second)
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
// =============================================================================================
|
||||
// 已删除的死代码（未使用）：CheckErrs 错误检查函数
|
||||
// =============================================================================================
|
||||
|
||||
@ -104,40 +104,10 @@ func (s *ScanStatus) UpdateError() {
|
||||
s.lastError = time.Now()
|
||||
}
|
||||
|
||||
// GetLastSuccess 获取最后成功时间
|
||||
func (s *ScanStatus) GetLastSuccess() time.Time {
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
return s.lastSuccess
|
||||
}
|
||||
|
||||
// GetLastError 获取最后错误时间
|
||||
func (s *ScanStatus) GetLastError() time.Time {
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
return s.lastError
|
||||
}
|
||||
|
||||
// SetTotal 设置总任务数
|
||||
func (s *ScanStatus) SetTotal(total int64) {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
s.total = total
|
||||
}
|
||||
|
||||
// SetCompleted 设置已完成任务数
|
||||
func (s *ScanStatus) SetCompleted(completed int64) {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
s.completed = completed
|
||||
}
|
||||
|
||||
// GetProgress 获取进度信息
|
||||
func (s *ScanStatus) GetProgress() (int64, int64) {
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
return s.completed, s.total
|
||||
}
|
||||
// =============================================================================================
|
||||
// 已删除的死代码（未使用）：
|
||||
// GetLastSuccess, GetLastError, SetTotal, SetCompleted, GetProgress 方法
|
||||
// =============================================================================================
|
||||
|
||||
// ProgressDisplay 进度条显示接口
|
||||
type ProgressDisplay interface {
|
||||
|
||||
@ -202,47 +202,10 @@ func (m *Manager) flushBufferUnsafe() error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetResults 获取扫描结果
|
||||
func (m *Manager) GetResults() ([]*ScanResult, error) {
|
||||
return m.GetResultsWithFilter(nil)
|
||||
}
|
||||
|
||||
// GetResultsWithFilter 获取过滤后的扫描结果
|
||||
func (m *Manager) GetResultsWithFilter(filter *ResultFilter) ([]*ScanResult, error) {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
|
||||
if m.reader == nil {
|
||||
return nil, fmt.Errorf("当前输出格式不支持读取")
|
||||
}
|
||||
|
||||
return m.reader.ReadWithFilter(filter)
|
||||
}
|
||||
|
||||
// GetStatistics 获取统计信息
|
||||
func (m *Manager) GetStatistics() *Statistics {
|
||||
return m.statistics
|
||||
}
|
||||
|
||||
// Flush 刷新所有缓冲区
|
||||
func (m *Manager) Flush() error {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
|
||||
if !m.initialized || m.closed {
|
||||
return nil
|
||||
}
|
||||
|
||||
// 刷新缓冲区
|
||||
if m.config.EnableBuffer {
|
||||
if err := m.flushBuffer(); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
// 刷新写入器
|
||||
return m.writer.Flush()
|
||||
}
|
||||
// =============================================================================================
|
||||
// 已删除的死代码（未使用）：
|
||||
// GetResults, GetResultsWithFilter, GetStatistics, Flush 方法
|
||||
// =============================================================================================
|
||||
|
||||
// Close 关闭输出管理器
|
||||
func (m *Manager) Close() error {
|
||||
@ -281,82 +244,11 @@ func (m *Manager) Close() error {
|
||||
return err
|
||||
}
|
||||
|
||||
// IsInitialized 检查是否已初始化
|
||||
func (m *Manager) IsInitialized() bool {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
return m.initialized
|
||||
}
|
||||
// =============================================================================================
|
||||
// 已删除的死代码（未使用）：
|
||||
// IsInitialized, IsClosed, GetConfig, UpdateConfig 方法
|
||||
// =============================================================================================
|
||||
|
||||
// IsClosed 检查是否已关闭
|
||||
func (m *Manager) IsClosed() bool {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
return m.closed
|
||||
}
|
||||
|
||||
// GetConfig 获取配置
|
||||
func (m *Manager) GetConfig() *ManagerConfig {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
|
||||
// 返回配置副本
|
||||
config := *m.config
|
||||
return &config
|
||||
}
|
||||
|
||||
// UpdateConfig 更新配置（部分配置可以动态更新）
|
||||
func (m *Manager) UpdateConfig(updates map[string]interface{}) error {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
|
||||
if m.closed {
|
||||
return fmt.Errorf("输出管理器已关闭")
|
||||
}
|
||||
|
||||
// 只允许更新部分配置
|
||||
for key, value := range updates {
|
||||
switch key {
|
||||
case "enable_buffer":
|
||||
if enableBuffer, ok := value.(bool); ok {
|
||||
m.config.EnableBuffer = enableBuffer
|
||||
}
|
||||
case "buffer_size":
|
||||
if bufferSize, ok := value.(int); ok && bufferSize > 0 {
|
||||
m.config.BufferSize = bufferSize
|
||||
}
|
||||
case "auto_flush":
|
||||
if autoFlush, ok := value.(bool); ok {
|
||||
m.config.AutoFlush = autoFlush
|
||||
if autoFlush && m.flushTicker == nil {
|
||||
m.startAutoFlush()
|
||||
} else if !autoFlush && m.flushTicker != nil {
|
||||
m.flushTicker.Stop()
|
||||
m.flushTicker = nil
|
||||
}
|
||||
}
|
||||
case "flush_interval":
|
||||
if flushInterval, ok := value.(time.Duration); ok && flushInterval > 0 {
|
||||
m.config.FlushInterval = flushInterval
|
||||
if m.flushTicker != nil {
|
||||
m.flushTicker.Stop()
|
||||
m.startAutoFlush()
|
||||
}
|
||||
}
|
||||
default:
|
||||
return fmt.Errorf("不支持更新的配置项: %s", key)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// 全局输出管理器实例
|
||||
var (
|
||||
globalManager *Manager
|
||||
)
|
||||
|
||||
// SetGlobalManager 设置全局输出管理器
|
||||
func SetGlobalManager(manager *Manager) {
|
||||
globalManager = manager
|
||||
}
|
||||
// =============================================================================================
|
||||
// 已删除的死代码（未使用）：globalManager 全局变量及 SetGlobalManager 函数
|
||||
// =============================================================================================
|
||||
|
||||
@ -113,39 +113,7 @@ func (s *Statistics) AddResult(resultType ResultType) {
|
||||
s.LastUpdate = time.Now()
|
||||
}
|
||||
|
||||
// GetTotalResults 获取总结果数
|
||||
func (s *Statistics) GetTotalResults() int64 {
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
return s.TotalResults
|
||||
}
|
||||
|
||||
// GetTypeCounts 获取类型计数
|
||||
func (s *Statistics) GetTypeCounts() map[ResultType]int64 {
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
|
||||
// 返回副本以避免并发问题
|
||||
counts := make(map[ResultType]int64)
|
||||
for k, v := range s.TypeCounts {
|
||||
counts[k] = v
|
||||
}
|
||||
return counts
|
||||
}
|
||||
|
||||
// GetDuration 获取运行时长
|
||||
func (s *Statistics) GetDuration() time.Duration {
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
return s.LastUpdate.Sub(s.StartTime)
|
||||
}
|
||||
|
||||
// Reset 重置统计信息
|
||||
func (s *Statistics) Reset() {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
s.TotalResults = 0
|
||||
s.TypeCounts = make(map[ResultType]int64)
|
||||
s.StartTime = time.Now()
|
||||
s.LastUpdate = time.Now()
|
||||
}
|
||||
// =============================================================================================
|
||||
// 已删除的死代码（未使用）：
|
||||
// GetTotalResults, GetTypeCounts, GetDuration, Reset 方法
|
||||
// =============================================================================================
|
||||
|
||||
@ -358,19 +358,6 @@ func (cp *CredentialParser) generateStatistics(usernames, passwords, hashValues
|
||||
}
|
||||
}
|
||||
|
||||
// Validate 验证解析结果
|
||||
func (cp *CredentialParser) Validate() error {
|
||||
// 基本验证逻辑
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetStatistics 获取解析统计
|
||||
func (cp *CredentialParser) GetStatistics() interface{} {
|
||||
cp.mu.RLock()
|
||||
defer cp.mu.RUnlock()
|
||||
|
||||
return map[string]interface{}{
|
||||
"parser_type": "credential",
|
||||
"options": cp.options,
|
||||
}
|
||||
}
|
||||
// =============================================================================================
|
||||
// 已删除的死代码（未使用）：Validate 和 GetStatistics 方法
|
||||
// =============================================================================================
|
||||
@ -122,63 +122,9 @@ func (fr *FileReader) ReadFile(filename string, options ...*FileReaderOptions) (
|
||||
}
|
||||
}
|
||||
|
||||
// ReadFiles 并发读取多个文件
|
||||
func (fr *FileReader) ReadFiles(filenames []string, options ...*FileReaderOptions) (map[string]*FileResult, error) {
|
||||
if len(filenames) == 0 {
|
||||
return nil, NewParseError("FILE_ERROR", "文件列表为空", "", 0, ErrEmptyInput)
|
||||
}
|
||||
|
||||
opts := fr.mergeOptions(options...)
|
||||
results := make(map[string]*FileResult)
|
||||
resultsChan := make(chan struct {
|
||||
filename string
|
||||
result *FileResult
|
||||
err error
|
||||
}, len(filenames))
|
||||
|
||||
// 并发读取文件
|
||||
var wg sync.WaitGroup
|
||||
semaphore := make(chan struct{}, 4) // 限制并发数
|
||||
|
||||
for _, filename := range filenames {
|
||||
wg.Add(1)
|
||||
go func(fname string) {
|
||||
defer wg.Done()
|
||||
semaphore <- struct{}{} // 获取信号量
|
||||
defer func() { <-semaphore }() // 释放信号量
|
||||
|
||||
result, err := fr.ReadFile(fname, opts)
|
||||
resultsChan <- struct {
|
||||
filename string
|
||||
result *FileResult
|
||||
err error
|
||||
}{fname, result, err}
|
||||
}(filename)
|
||||
}
|
||||
|
||||
// 等待所有协程完成
|
||||
go func() {
|
||||
wg.Wait()
|
||||
close(resultsChan)
|
||||
}()
|
||||
|
||||
// 收集结果
|
||||
var errors []error
|
||||
for res := range resultsChan {
|
||||
if res.err != nil {
|
||||
errors = append(errors, res.err)
|
||||
} else {
|
||||
results[res.filename] = res.result
|
||||
}
|
||||
}
|
||||
|
||||
// 如果有错误且所有文件都失败，返回第一个错误
|
||||
if len(errors) > 0 && len(results) == 0 {
|
||||
return nil, errors[0]
|
||||
}
|
||||
|
||||
return results, nil
|
||||
}
|
||||
// =============================================================================================
|
||||
// 已删除的死代码（未使用）：ReadFiles 并发读取多个文件的方法
|
||||
// =============================================================================================
|
||||
|
||||
// readFileSync 同步读取文件
|
||||
func (fr *FileReader) readFileSync(filename string, options *FileReaderOptions) (*FileResult, error) {
|
||||
@ -340,21 +286,6 @@ func (fr *FileReader) addToCache(filename string, result *FileResult) {
|
||||
fr.cache[filename] = result
|
||||
}
|
||||
|
||||
// ClearCache 清空缓存
|
||||
func (fr *FileReader) ClearCache() {
|
||||
fr.mu.Lock()
|
||||
defer fr.mu.Unlock()
|
||||
fr.cache = make(map[string]*FileResult)
|
||||
}
|
||||
|
||||
// GetCacheStats 获取缓存统计
|
||||
func (fr *FileReader) GetCacheStats() map[string]interface{} {
|
||||
fr.mu.RLock()
|
||||
defer fr.mu.RUnlock()
|
||||
|
||||
return map[string]interface{}{
|
||||
"cache_size": len(fr.cache),
|
||||
"max_cache_size": fr.maxCacheSize,
|
||||
"cache_enabled": fr.enableCache,
|
||||
}
|
||||
}
|
||||
// =============================================================================================
|
||||
// 已删除的死代码（未使用）：ClearCache 和 GetCacheStats 方法
|
||||
// =============================================================================================
|
||||
@ -369,18 +369,6 @@ func (np *NetworkParser) isValidCookie(cookie string) bool {
|
||||
return cookieRegex.MatchString(strings.TrimSpace(cookie))
|
||||
}
|
||||
|
||||
// Validate 验证解析结果
|
||||
func (np *NetworkParser) Validate() error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetStatistics 获取解析统计
|
||||
func (np *NetworkParser) GetStatistics() interface{} {
|
||||
np.mu.RLock()
|
||||
defer np.mu.RUnlock()
|
||||
|
||||
return map[string]interface{}{
|
||||
"parser_type": "network",
|
||||
"options": np.options,
|
||||
}
|
||||
}
|
||||
// =============================================================================================
|
||||
// 已删除的死代码（未使用）：Validate 和 GetStatistics 方法
|
||||
// =============================================================================================
|
||||
@ -868,18 +868,6 @@ func (tp *TargetParser) generateStatistics(hosts, urls []string, ports, excludeP
|
||||
}
|
||||
}
|
||||
|
||||
// Validate 验证解析结果
|
||||
func (tp *TargetParser) Validate() error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetStatistics 获取解析统计
|
||||
func (tp *TargetParser) GetStatistics() interface{} {
|
||||
tp.mu.RLock()
|
||||
defer tp.mu.RUnlock()
|
||||
|
||||
return map[string]interface{}{
|
||||
"parser_type": "target",
|
||||
"options": tp.options,
|
||||
}
|
||||
}
|
||||
// =============================================================================================
|
||||
// 已删除的死代码（未使用）：Validate 和 GetStatistics 方法
|
||||
// =============================================================================================
|
||||
@ -286,18 +286,6 @@ func (vp *ValidationParser) validateScanMode(scanMode string) error {
|
||||
}
|
||||
|
||||
|
||||
// Validate 验证解析结果
|
||||
func (vp *ValidationParser) Validate() error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetStatistics 获取解析统计
|
||||
func (vp *ValidationParser) GetStatistics() interface{} {
|
||||
vp.mu.RLock()
|
||||
defer vp.mu.RUnlock()
|
||||
|
||||
return map[string]interface{}{
|
||||
"parser_type": "validation",
|
||||
"options": vp.options,
|
||||
}
|
||||
}
|
||||
// =============================================================================================
|
||||
// 已删除的死代码（未使用）：Validate 和 GetStatistics 方法
|
||||
// =============================================================================================
|
||||
@ -1,186 +1,14 @@
|
||||
package proxy
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/url"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
// 已清理未使用的导入
|
||||
|
||||
// ParseProxyURL 解析代理URL
|
||||
func ParseProxyURL(proxyURL string) (*ProxyConfig, error) {
|
||||
if proxyURL == "" {
|
||||
return DefaultProxyConfig(), nil
|
||||
}
|
||||
|
||||
u, err := url.Parse(proxyURL)
|
||||
if err != nil {
|
||||
return nil, NewProxyError(ErrTypeConfig, "代理URL解析失败", 6001, err)
|
||||
}
|
||||
|
||||
config := DefaultProxyConfig()
|
||||
|
||||
// 设置代理类型
|
||||
switch strings.ToLower(u.Scheme) {
|
||||
case "http":
|
||||
config.Type = ProxyTypeHTTP
|
||||
case "https":
|
||||
config.Type = ProxyTypeHTTPS
|
||||
case "socks5":
|
||||
config.Type = ProxyTypeSOCKS5
|
||||
default:
|
||||
return nil, NewProxyError(ErrTypeConfig,
|
||||
fmt.Sprintf("不支持的代理协议: %s", u.Scheme), 6002, nil)
|
||||
}
|
||||
|
||||
// 设置地址
|
||||
config.Address = u.Host
|
||||
|
||||
// 设置认证信息
|
||||
if u.User != nil {
|
||||
config.Username = u.User.Username()
|
||||
config.Password, _ = u.User.Password()
|
||||
}
|
||||
|
||||
// 解析查询参数中的配置
|
||||
query := u.Query()
|
||||
|
||||
// 超时设置
|
||||
if timeout := query.Get("timeout"); timeout != "" {
|
||||
if t, err := time.ParseDuration(timeout); err == nil {
|
||||
config.Timeout = t
|
||||
}
|
||||
}
|
||||
|
||||
// 最大重试次数
|
||||
if retries := query.Get("retries"); retries != "" {
|
||||
if r, err := strconv.Atoi(retries); err == nil {
|
||||
config.MaxRetries = r
|
||||
}
|
||||
}
|
||||
|
||||
// 保活时间
|
||||
if keepalive := query.Get("keepalive"); keepalive != "" {
|
||||
if ka, err := time.ParseDuration(keepalive); err == nil {
|
||||
config.KeepAlive = ka
|
||||
}
|
||||
}
|
||||
|
||||
return config, nil
|
||||
}
|
||||
|
||||
// CreateProxyManager 创建代理管理器
|
||||
func CreateProxyManager(proxyURL string) (ProxyManager, error) {
|
||||
config, err := ParseProxyURL(proxyURL)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return NewProxyManager(config), nil
|
||||
}
|
||||
|
||||
// ValidateProxyConfig 验证代理配置
|
||||
func ValidateProxyConfig(config *ProxyConfig) error {
|
||||
if config == nil {
|
||||
return NewProxyError(ErrTypeConfig, "配置不能为空", 6003, nil)
|
||||
}
|
||||
|
||||
// 验证代理类型
|
||||
if config.Type < ProxyTypeNone || config.Type > ProxyTypeSOCKS5 {
|
||||
return NewProxyError(ErrTypeConfig, "无效的代理类型", 6004, nil)
|
||||
}
|
||||
|
||||
// 如果不是直连，必须有地址
|
||||
if config.Type != ProxyTypeNone && config.Address == "" {
|
||||
return NewProxyError(ErrTypeConfig, "代理地址不能为空", 6005, nil)
|
||||
}
|
||||
|
||||
// 验证超时时间
|
||||
if config.Timeout <= 0 {
|
||||
return NewProxyError(ErrTypeConfig, "超时时间必须大于0", 6006, nil)
|
||||
}
|
||||
|
||||
// 验证重试次数
|
||||
if config.MaxRetries < 0 {
|
||||
return NewProxyError(ErrTypeConfig, "最大重试次数不能为负数", 6007, nil)
|
||||
}
|
||||
|
||||
// 验证连接池配置
|
||||
if config.MaxIdleConns < 0 {
|
||||
return NewProxyError(ErrTypeConfig, "最大空闲连接数不能为负数", 6008, nil)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetProxyTypeFromString 从字符串获取代理类型
|
||||
func GetProxyTypeFromString(typeStr string) ProxyType {
|
||||
switch strings.ToLower(typeStr) {
|
||||
case "none", "direct":
|
||||
return ProxyTypeNone
|
||||
case "http":
|
||||
return ProxyTypeHTTP
|
||||
case "https":
|
||||
return ProxyTypeHTTPS
|
||||
case "socks5":
|
||||
return ProxyTypeSOCKS5
|
||||
default:
|
||||
return ProxyTypeNone
|
||||
}
|
||||
}
|
||||
|
||||
// BuildProxyURL 构建代理URL
|
||||
func BuildProxyURL(config *ProxyConfig) string {
|
||||
if config == nil || config.Type == ProxyTypeNone {
|
||||
return ""
|
||||
}
|
||||
|
||||
var scheme string
|
||||
switch config.Type {
|
||||
case ProxyTypeHTTP:
|
||||
scheme = "http"
|
||||
case ProxyTypeHTTPS:
|
||||
scheme = "https"
|
||||
case ProxyTypeSOCKS5:
|
||||
scheme = "socks5"
|
||||
default:
|
||||
return ""
|
||||
}
|
||||
|
||||
url := fmt.Sprintf("%s://", scheme)
|
||||
|
||||
if config.Username != "" {
|
||||
if config.Password != "" {
|
||||
url += fmt.Sprintf("%s:%s@", config.Username, config.Password)
|
||||
} else {
|
||||
url += fmt.Sprintf("%s@", config.Username)
|
||||
}
|
||||
}
|
||||
|
||||
url += config.Address
|
||||
|
||||
return url
|
||||
}
|
||||
|
||||
// IsProxyEnabled 检查是否启用了代理
|
||||
func IsProxyEnabled(config *ProxyConfig) bool {
|
||||
return config != nil && config.Type != ProxyTypeNone && config.Address != ""
|
||||
}
|
||||
|
||||
// GetDefaultProxyConfigForType 获取指定类型的默认配置
|
||||
func GetDefaultProxyConfigForType(proxyType ProxyType, address string) *ProxyConfig {
|
||||
config := DefaultProxyConfig()
|
||||
config.Type = proxyType
|
||||
config.Address = address
|
||||
|
||||
// 根据类型调整默认配置
|
||||
switch proxyType {
|
||||
case ProxyTypeHTTP, ProxyTypeHTTPS:
|
||||
config.Timeout = 15 * time.Second
|
||||
case ProxyTypeSOCKS5:
|
||||
config.Timeout = 30 * time.Second
|
||||
}
|
||||
|
||||
return config
|
||||
}
|
||||
// =============================================================================================
|
||||
// 已删除的死代码（未使用）：
|
||||
// - ParseProxyURL: 解析代理URL
|
||||
// - CreateProxyManager: 创建代理管理器
|
||||
// - ValidateProxyConfig: 验证代理配置
|
||||
// - GetProxyTypeFromString: 从字符串获取代理类型
|
||||
// - BuildProxyURL: 构建代理URL
|
||||
// - IsProxyEnabled: 检查是否启用了代理
|
||||
// - GetDefaultProxyConfigForType: 获取指定类型的默认配置
|
||||
// =============================================================================================
|
||||
@ -1,9 +1,6 @@
|
||||
package proxy
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/tls"
|
||||
"net"
|
||||
"sync"
|
||||
)
|
||||
|
||||
@ -13,137 +10,18 @@ var (
|
||||
once sync.Once
|
||||
)
|
||||
|
||||
// InitGlobalProxy 初始化全局代理管理器
|
||||
func InitGlobalProxy(proxyURL string) error {
|
||||
globalMutex.Lock()
|
||||
defer globalMutex.Unlock()
|
||||
|
||||
config, err := ParseProxyURL(proxyURL)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if err := ValidateProxyConfig(config); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// 关闭旧的管理器
|
||||
if globalManager != nil {
|
||||
globalManager.Close()
|
||||
}
|
||||
|
||||
globalManager = NewProxyManager(config)
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetGlobalProxy 获取全局代理管理器
|
||||
func GetGlobalProxy() ProxyManager {
|
||||
globalMutex.RLock()
|
||||
defer globalMutex.RUnlock()
|
||||
|
||||
if globalManager == nil {
|
||||
// 使用默认配置初始化
|
||||
once.Do(func() {
|
||||
globalManager = NewProxyManager(DefaultProxyConfig())
|
||||
})
|
||||
}
|
||||
|
||||
return globalManager
|
||||
}
|
||||
|
||||
// UpdateGlobalProxyConfig 更新全局代理配置
|
||||
func UpdateGlobalProxyConfig(config *ProxyConfig) error {
|
||||
if err := ValidateProxyConfig(config); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
manager := GetGlobalProxy()
|
||||
return manager.UpdateConfig(config)
|
||||
}
|
||||
|
||||
// CloseGlobalProxy 关闭全局代理管理器
|
||||
func CloseGlobalProxy() error {
|
||||
globalMutex.Lock()
|
||||
defer globalMutex.Unlock()
|
||||
|
||||
if globalManager != nil {
|
||||
err := globalManager.Close()
|
||||
globalManager = nil
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetGlobalProxyStats 获取全局代理统计信息
|
||||
func GetGlobalProxyStats() *ProxyStats {
|
||||
manager := GetGlobalProxy()
|
||||
return manager.Stats()
|
||||
}
|
||||
|
||||
// 便捷函数
|
||||
|
||||
// DialWithProxy 使用全局代理拨号
|
||||
func DialWithProxy(network, address string) (net.Conn, error) {
|
||||
manager := GetGlobalProxy()
|
||||
dialer, err := manager.GetDialer()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return dialer.Dial(network, address)
|
||||
}
|
||||
|
||||
// DialContextWithProxy 使用全局代理和上下文拨号
|
||||
func DialContextWithProxy(ctx context.Context, network, address string) (net.Conn, error) {
|
||||
manager := GetGlobalProxy()
|
||||
dialer, err := manager.GetDialer()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return dialer.DialContext(ctx, network, address)
|
||||
}
|
||||
|
||||
// DialTLSWithProxy 使用全局代理建立TLS连接
|
||||
func DialTLSWithProxy(network, address string, config *tls.Config) (net.Conn, error) {
|
||||
manager := GetGlobalProxy()
|
||||
dialer, err := manager.GetTLSDialer()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return dialer.DialTLS(network, address, config)
|
||||
}
|
||||
|
||||
// DialTLSContextWithProxy 使用全局代理和上下文建立TLS连接
|
||||
func DialTLSContextWithProxy(ctx context.Context, network, address string, config *tls.Config) (net.Conn, error) {
|
||||
manager := GetGlobalProxy()
|
||||
dialer, err := manager.GetTLSDialer()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return dialer.DialTLSContext(ctx, network, address, config)
|
||||
}
|
||||
|
||||
// IsProxyEnabledGlobally 检查全局是否启用了代理
|
||||
func IsProxyEnabledGlobally() bool {
|
||||
manager := GetGlobalProxy()
|
||||
stats := manager.Stats()
|
||||
return stats.ProxyType != "none"
|
||||
}
|
||||
|
||||
// GetGlobalProxyType 获取全局代理类型
|
||||
func GetGlobalProxyType() string {
|
||||
manager := GetGlobalProxy()
|
||||
stats := manager.Stats()
|
||||
return stats.ProxyType
|
||||
}
|
||||
|
||||
// GetGlobalProxyAddress 获取全局代理地址
|
||||
func GetGlobalProxyAddress() string {
|
||||
manager := GetGlobalProxy()
|
||||
stats := manager.Stats()
|
||||
return stats.ProxyAddress
|
||||
}
|
||||
// =============================================================================================
|
||||
// 已删除的死代码（未使用）：
|
||||
// - InitGlobalProxy: 初始化全局代理管理器
|
||||
// - GetGlobalProxy: 获取全局代理管理器
|
||||
// - UpdateGlobalProxyConfig: 更新全局代理配置
|
||||
// - CloseGlobalProxy: 关闭全局代理管理器
|
||||
// - GetGlobalProxyStats: 获取全局代理统计信息
|
||||
// - DialWithProxy: 使用全局代理拨号
|
||||
// - DialContextWithProxy: 使用全局代理和上下文拨号
|
||||
// - DialTLSWithProxy: 使用全局代理建立TLS连接
|
||||
// - DialTLSContextWithProxy: 使用全局代理和上下文建立TLS连接
|
||||
// - IsProxyEnabledGlobally: 检查全局是否启用了代理
|
||||
// - GetGlobalProxyType: 获取全局代理类型
|
||||
// - GetGlobalProxyAddress: 获取全局代理地址
|
||||
// =============================================================================================
|
||||
@ -83,7 +83,6 @@ func (t *tlsDialerWrapper) updateAverageConnectTime(duration time.Duration) {
|
||||
type trackedConn struct {
|
||||
net.Conn
|
||||
stats *ProxyStats
|
||||
startTime time.Time
|
||||
bytesSent int64
|
||||
bytesRecv int64
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user