first commit

internal/continuous/ping.go

@@ -0,0 +1,143 @@
+package continuous
+
+import (
+	"context"
+	"os/exec"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"go.uber.org/zap"
+)
+
+type PingTask struct {
+	TaskID      string
+	Target      string
+	Interval    time.Duration
+	MaxDuration time.Duration
+	StartTime   time.Time
+	LastRequest time.Time
+	StopCh      chan struct{}
+	IsRunning   bool
+	mu          sync.RWMutex
+	logger      *zap.Logger
+}
+
+func NewPingTask(taskID, target string, interval, maxDuration time.Duration) *PingTask {
+	logger, _ := zap.NewProduction()
+	return &PingTask{
+		TaskID:      taskID,
+		Target:      target,
+		Interval:    interval,
+		MaxDuration: maxDuration,
+		StartTime:   time.Now(),
+		LastRequest: time.Now(),
+		StopCh:      make(chan struct{}),
+		IsRunning:   true,
+		logger:      logger,
+	}
+}
+
+func (t *PingTask) Start(ctx context.Context, resultCallback func(result map[string]interface{})) {
+	ticker := time.NewTicker(t.Interval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-t.StopCh:
+			return
+		case <-ticker.C:
+			// 检查是否超过最大运行时长
+			t.mu.RLock()
+			if time.Since(t.StartTime) > t.MaxDuration {
+				t.mu.RUnlock()
+				t.Stop()
+				return
+			}
+			t.mu.RUnlock()
+
+			// 执行ping测试
+			result := t.executePing()
+			if resultCallback != nil {
+				resultCallback(result)
+			}
+		}
+	}
+}
+
+func (t *PingTask) Stop() {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	if t.IsRunning {
+		t.IsRunning = false
+		close(t.StopCh)
+	}
+}
+
+func (t *PingTask) UpdateLastRequest() {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	t.LastRequest = time.Now()
+}
+
+func (t *PingTask) executePing() map[string]interface{} {
+	cmd := exec.Command("ping", "-c", "4", t.Target)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return map[string]interface{}{
+			"timestamp":   time.Now().Unix(),
+			"latency":     -1,
+			"success":     false,
+			"packet_loss": true,
+			"error":       err.Error(),
+		}
+	}
+
+	// 解析ping输出
+	result := parsePingOutput(string(output))
+	result["timestamp"] = time.Now().Unix()
+	return result
+}
+
+func parsePingOutput(output string) map[string]interface{} {
+	result := map[string]interface{}{
+		"latency":     0.0,
+		"success":     true,
+		"packet_loss": false,
+	}
+
+	lines := strings.Split(output, "\n")
+	for _, line := range lines {
+		if strings.Contains(line, "packets transmitted") {
+			// 解析丢包率
+			parts := strings.Fields(line)
+			for i, part := range parts {
+				if part == "packet" && i+2 < len(parts) {
+					if loss, err := strconv.ParseFloat(strings.Trim(parts[i+1], "%"), 64); err == nil {
+						result["packet_loss"] = loss > 0
+					}
+				}
+			}
+		}
+		if strings.Contains(line, "min/avg/max") {
+			// 解析平均延迟
+			parts := strings.Fields(line)
+			for _, part := range parts {
+				if strings.Contains(part, "/") {
+					times := strings.Split(part, "/")
+					if len(times) >= 2 {
+						if avg, err := strconv.ParseFloat(times[1], 64); err == nil {
+							result["latency"] = avg
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return result
+}
+

internal/continuous/tcping.go

@@ -0,0 +1,126 @@
+package continuous
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"go.uber.org/zap"
+)
+
+type TCPingTask struct {
+	TaskID      string
+	Target      string
+	Host        string
+	Port        int
+	Interval    time.Duration
+	MaxDuration time.Duration
+	StartTime   time.Time
+	LastRequest time.Time
+	StopCh      chan struct{}
+	IsRunning   bool
+	mu          sync.RWMutex
+	logger      *zap.Logger
+}
+
+func NewTCPingTask(taskID, target string, interval, maxDuration time.Duration) (*TCPingTask, error) {
+	// 解析host:port
+	parts := strings.Split(target, ":")
+	if len(parts) != 2 {
+		return nil, fmt.Errorf("无效的target格式，需要 host:port")
+	}
+
+	host := parts[0]
+	port, err := strconv.Atoi(parts[1])
+	if err != nil {
+		return nil, fmt.Errorf("无效的端口: %v", err)
+	}
+
+	logger, _ := zap.NewProduction()
+	return &TCPingTask{
+		TaskID:      taskID,
+		Target:      target,
+		Host:        host,
+		Port:        port,
+		Interval:    interval,
+		MaxDuration: maxDuration,
+		StartTime:   time.Now(),
+		LastRequest: time.Now(),
+		StopCh:      make(chan struct{}),
+		IsRunning:   true,
+		logger:      logger,
+	}, nil
+}
+
+func (t *TCPingTask) Start(ctx context.Context, resultCallback func(result map[string]interface{})) {
+	ticker := time.NewTicker(t.Interval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-t.StopCh:
+			return
+		case <-ticker.C:
+			// 检查是否超过最大运行时长
+			t.mu.RLock()
+			if time.Since(t.StartTime) > t.MaxDuration {
+				t.mu.RUnlock()
+				t.Stop()
+				return
+			}
+			t.mu.RUnlock()
+
+			// 执行tcping测试
+			result := t.executeTCPing()
+			if resultCallback != nil {
+				resultCallback(result)
+			}
+		}
+	}
+}
+
+func (t *TCPingTask) Stop() {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	if t.IsRunning {
+		t.IsRunning = false
+		close(t.StopCh)
+	}
+}
+
+func (t *TCPingTask) UpdateLastRequest() {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	t.LastRequest = time.Now()
+}
+
+func (t *TCPingTask) executeTCPing() map[string]interface{} {
+	start := time.Now()
+	conn, err := net.DialTimeout("tcp", net.JoinHostPort(t.Host, strconv.Itoa(t.Port)), 5*time.Second)
+	latency := time.Since(start).Milliseconds()
+
+	if err != nil {
+		return map[string]interface{}{
+			"timestamp":   time.Now().Unix(),
+			"latency":     -1,
+			"success":     false,
+			"packet_loss": true,
+			"error":       err.Error(),
+		}
+	}
+	defer conn.Close()
+
+	return map[string]interface{}{
+		"timestamp":   time.Now().Unix(),
+		"latency":     float64(latency),
+		"success":     true,
+		"packet_loss": false,
+	}
+}
+