package main

import (
	"fmt"
	"net/http"
	"sync"
)

func main() {
	urls := []string{
		"https://api.example.com/1",
		"https://api.example.com/2",
		"https://api.example.com/3",
	}
	var wg sync.WaitGroup
	results := make(chan string, len(urls))

	// 并發(fā)發(fā)起 HTTP 請(qǐng)求
	for _, url := range urls {
		wg.Add(1)
		go func(url string) {
			defer wg.Done()
			resp, err := http.Get(url)
			if err != nil {
				results <- fmt.Sprintf("Error fetching %s: %v", url, err)
				return
			}
			defer resp.Body.Close()
			results <- fmt.Sprintf("Fetched %s with status: %s", url, resp.Status)
		}(url)
	}

	// 等待所有請(qǐng)求完成
	wg.Wait()
	close(results)

	// 輸出結(jié)果
	for result := range results {
		fmt.Println(result)
	}
}

package main

import (
	"fmt"
	"net"
	"time"
)

func checkConnection(host, port string, timeout time.Duration) error {
	conn, err := net.DialTimeout("tcp", host+":"+port, timeout)
	if err != nil {
		return fmt.Errorf("failed to connect to %s:%s: %v", host, port, err)
	}
	defer conn.Close()
	fmt.Printf("Successfully connected to %s:%s\n", host, port)
	return nil
}

func main() {
	err := checkConnection("example.com", "80", 5*time.Second)
	if err != nil {
		fmt.Println(err)
	}
}

package main

import (
	"fmt"
	"net/http"
	"net/http/httptrace"
	"time"
)

func main() {
	req, err := http.NewRequest("GET", "https://example.com", nil)
	if err != nil {
		fmt.Println("Error creating request:", err)
		return
	}

	var start, connect, dns, tlsHandshake time.Time
	trace := &httptrace.ClientTrace{
		DNSStart: func(_ httptrace.DNSStartInfo) { dns = time.Now() },
		DNSDone:  func(_ httptrace.DNSDoneInfo) {
			fmt.Printf("DNS Lookup: %v\n", time.Since(dns))
		},
		ConnectStart: func(_, _ string) { connect = time.Now() },
		ConnectDone: func(_, _ string, err error) {
			fmt.Printf("Connect: %v\n", time.Since(connect))
		},
		TLSHandshakeStart: func() { tlsHandshake = time.Now() },
		TLSHandshakeDone: func(_ tls.ConnectionState, _ error) {
			fmt.Printf("TLS Handshake: %v\n", time.Since(tlsHandshake))
		},
		GotFirstResponseByte: func() {
			fmt.Printf("Time to first byte: %v\n", time.Since(start))
		},
	}
	req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace))

	start = time.Now()
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("Error executing request:", err)
		return
	}
	defer resp.Body.Close()
	fmt.Printf("Total time: %v\n", time.Since(start))
}

package main

import (
	"fmt"
	"hash/crc32"
	"io"
	"net"
)

// sendData 發(fā)送數(shù)據(jù)并附帶 CRC32 校驗(yàn)
func sendData(conn net.Conn, data []byte) error {
	conn.SetWriteBuffer(1024 * 8) // 8KB 緩沖區(qū)
	checksum := crc32.ChecksumIEEE(data)
	length := len(data)
	_, err := conn.Write([]byte{byte(length >> 8), byte(length)})
	if err != nil {
		return fmt.Errorf("failed to send length: %v", err)
	}
	_, err = conn.Write(data)
	if err != nil {
		return fmt.Errorf("failed to send data: %v", err)
	}
	_, err = conn.Write([]byte{
		byte(checksum >> 24), byte(checksum >> 16),
		byte(checksum >> 8), byte(checksum),
	})
	if err != nil {
		return fmt.Errorf("failed to send checksum: %v", err)
	}
	return nil
}

// receiveData 接收數(shù)據(jù)并驗(yàn)證 CRC32 校驗(yàn)
func receiveData(conn net.Conn) ([]byte, error) {
	conn.SetReadBuffer(1024 * 8)
	lengthBuf := make([]byte, 2)
	_, err := io.ReadFull(conn, lengthBuf)
	if err != nil {
		return nil, fmt.Errorf("failed to read length: %v", err)
	}
	length := int(lengthBuf[0])<<8 | int(lengthBuf[1])
	data := make([]byte, length)
	_, err = io.ReadFull(conn, data)
	if err != nil {
		return nil, fmt.Errorf("failed to read data: %v", err)
	}
	checksumBuf := make([]byte, 4)
	_, err = io.ReadFull(conn, checksumBuf)
	if err != nil {
		return nil, fmt.Errorf("failed to read checksum: %v", err)
	}
	receivedChecksum := uint32(checksumBuf[0])<<24 |
		uint32(checksumBuf[1])<<16 |
		uint32(checksumBuf[2])<<8 |
		uint32(checksumBuf[3])
	calculatedChecksum := crc32.ChecksumIEEE(data)
	if receivedChecksum != calculatedChecksum {
		return nil, fmt.Errorf("checksum mismatch: expected %d, got %d", calculatedChecksum, receivedChecksum)
	}
	return data, nil
}

func main() {
	listener, err := net.Listen("tcp", ":8080")
	if err != nil {
		fmt.Println("Error starting server:", err)
		return
	}
	defer listener.Close()
	go func() {
		conn, err := listener.Accept()
		if err != nil {
			fmt.Println("Error accepting connection:", err)
			return
		}
		defer conn.Close()
		data, err := receiveData(conn)
		if err != nil {
			fmt.Println("Error receiving data:", err)
			return
		}
		fmt.Printf("Received: %s\n", data)
	}()
	conn, err := net.Dial("tcp", "localhost:8080")
	if err != nil {
		fmt.Println("Error connecting:", err)
		return
	}
	defer conn.Close()
	data := []byte("Hello, TCP!")
	err = sendData(conn, data)
	if err != nil {
		fmt.Println("Error sending data:", err)
	}
}

package main

import (
	"net/http"
	"net/http/pprof"
)

func setupPprof(mux *http.ServeMux) {
	mux.HandleFunc("/debug/pprof/", pprof.Index)
	mux.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
	mux.HandleFunc("/debug/pprof/profile", pprof.Profile)
	mux.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
	mux.HandleFunc("/debug/pprof/trace", pprof.Trace)
}

func main() {
	mux := http.NewServeMux()
	setupPprof(mux)
	mux.HandleFunc("/api", func(w http.ResponseWriter, r *http.Request) {
		for i := 0; i < 1000000; i++ {
			_ = i * i
		}
		w.Write([]byte("Hello, World!"))
	})
	server := &http.Server{Addr: ":8080", Handler: mux}
	if err := server.ListenAndServe(); err != nil {
		fmt.Println("Error starting server:", err)
	}
}

package main

import (
	"fmt"
	"net/http"
	"os"
	"runtime/trace"
	"time"
)

func main() {
	f, err := os.Create("trace.out")
	if err != nil {
		fmt.Println("Error creating trace file:", err)
		return
	}
	defer f.Close()
	if err := trace.Start(f); err != nil {
		fmt.Println("Error starting trace:", err)
		return
	}
	defer trace.Stop()
	client := &http.Client{}
	for i := 0; i < 100; i++ {
		go func(i int) {
			resp, err := client.Get("https://example.com")
			if err != nil {
				fmt.Printf("Request %d failed: %v\n", i, err)
				return
			}
			defer resp.Body.Close()
		}(i)
	}
	time.Sleep(2 * time.Second)
}

package main

import (
	"context"
	"fmt"
	"net/http"
	"time"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()
	req, err := http.NewRequestWithContext(ctx, "GET", "https://example.com", nil)
	if err != nil {
		fmt.Println("Error creating request:", err)
		return
	}
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("Error executing request:", err)
		return
	}
	defer resp.Body.Close()
	fmt.Println("Request succeeded with status:", resp.Status)
}

package main

import (
	"context"
	"flag"
	"fmt"
	"net"
	"net/http"
	"net/http/httptrace"
	"os"
	"time"
	"github.com/prometheus/client_golang/prometheus"
	"github.com/prometheus/client_golang/promhttp"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
)

type NetworkDiagnostic struct {
	logger      *zap.Logger
	tcpSuccess  prometheus.Counter
	tcpFailure  prometheus.Counter
	httpLatency prometheus.Histogram
}

func NewNetworkDiagnostic(logFile string) (*NetworkDiagnostic, error) {
	config := zap.NewProductionEncoderConfig()
	config.EncodeTime = zapcore.ISO8601TimeEncoder
	file, err := os.OpenFile(logFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		return nil, fmt.Errorf("failed to open log file: %v", err)
	}
	writeSyncer := zapcore.AddSync(file)
	consoleSyncer := zapcore.AddSync(os.Stdout)
	core := zapcore.NewTee(
		zapcore.NewCore(zapcore.NewJSONEncoder(config), writeSyncer, zapcore.InfoLevel),
		zapcore.NewCore(zapcore.NewConsoleEncoder(config), consoleSyncer, zapcore.InfoLevel),
	)
	logger := zap.New(core, zap.AddCaller())
	tcpSuccess := prometheus.NewCounter(prometheus.CounterOpts{
		Name: "tcp_connection_success_total",
		Help: "Total number of successful TCP connections",
	})
	tcpFailure := prometheus.NewCounter(prometheus.CounterOpts{
		Name: "tcp_connection_failure_total",
		Help: "Total number of failed TCP connections",
	})
	httpLatency := prometheus.NewHistogram(prometheus.HistogramOpts{
		Name:    "http_request_latency_seconds",
		Help:    "HTTP request latency in seconds",
		Buckets: prometheus.LinearBuckets(0.1, 0.1, 10),
	})
	prometheus.MustRegister(tcpSuccess, tcpFailure, httpLatency)
	return &NetworkDiagnostic{
		logger:      logger,
		tcpSuccess:  tcpSuccess,
		tcpFailure:  tcpFailure,
		httpLatency: httpLatency,
	}, nil
}

func (nd *NetworkDiagnostic) CheckTCPConnection(host, port string, timeout time.Duration, maxRetries int) error {
	for attempt := 1; attempt <= maxRetries; attempt++ {
		conn, err := net.DialTimeout("tcp", host+":"+port, timeout)
		if err == nil {
			defer conn.Close()
			nd.logger.Info("TCP connection succeeded",
				zap.String("host", host),
				zap.String("port", port),
				zap.Int("attempt", attempt))
			nd.tcpSuccess.Inc()
			return nil
		}
		nd.logger.Warn("TCP connection attempt failed",
			zap.String("host", host),
			zap.String("port", port),
			zap.Int("attempt", attempt),
			zap.Error(err))
		time.Sleep(time.Duration(1<<uint(attempt-1)) * 100 * time.Millisecond)
	}
	nd.tcpFailure.Inc()
	return fmt.Errorf("failed to connect to %s:%s after %d attempts", host, port, maxRetries)
}

func (nd *NetworkDiagnostic) TraceHTTPRequest(url string, timeout time.Duration, maxRetries int) error {
	for attempt := 1; attempt <= maxRetries; attempt++ {
		ctx, cancel := context.WithTimeout(context.Background(), timeout)
		defer cancel()
		req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
		if err != nil {
			nd.logger.Error("Failed to create request", zap.Error(err), zap.Int("attempt", attempt))
			continue
		}
		var start, connect, dns, tlsHandshake time.Time
		trace := &httptrace.ClientTrace{
			DNSStart: func(_ httptrace.DNSStartInfo) {
				dns = time.Now()
				nd.logger.Info("DNS lookup started", zap.Int("attempt", attempt))
			},
			DNSDone: func(_ httptrace.DNSDoneInfo) {
				nd.logger.Info("DNS lookup completed",
					zap.Duration("duration", time.Since(dns)),
					zap.Int("attempt", attempt))
			},
			ConnectStart: func(_, _ string) {
				connect = time.Now()
				nd.logger.Info("Connection started", zap.Int("attempt", attempt))
			},
			ConnectDone: func(_, _ string, err error) {
				nd.logger.Info("Connection established",
					zap.Duration("duration", time.Since(connect)),
					zap.Error(err),
					zap.Int("attempt", attempt))
			},
			TLSHandshakeStart: func() {
				tlsHandshake = time.Now()
				nd.logger.Info("TLS handshake started", zap.Int("attempt", attempt))
			},
			TLSHandshakeDone: func(_ tls.ConnectionState, _ error) {
				nd.logger.Info("TLS handshake completed",
					zap.Duration("duration", time.Since(tlsHandshake)),
					zap.Int("attempt", attempt))
			},
			GotFirstResponseByte: func() {
				nd.logger.Info("Received first response byte",
					zap.Duration("duration", time.Since(start)),
					zap.Int("attempt", attempt))
			},
		}
		req = req.WithContext(httptrace.WithClientTrace(ctx, trace))
		start = time.Now()
		client := &http.Client{
			Transport: &http.Transport{
				MaxIdleConns:        100,
				MaxIdleConnsPerHost: 10,
			},
		}
		resp, err := client.Do(req)
		if err == nil {
			defer resp.Body.Close()
			nd.httpLatency.Observe(time.Since(start).Seconds())
			nd.logger.Info("HTTP request succeeded",
				zap.String("status", resp.Status),
				zap.Duration("total", time.Since(start)),
				zap.Int("attempt", attempt))
			return nil
		}
		nd.logger.Warn("HTTP request attempt failed",
			zap.Error(err),
			zap.Int("attempt", attempt))
		time.Sleep(time.Duration(1<<uint(attempt-1)) * 100 * time.Millisecond)
	}
	return fmt.Errorf("HTTP request to %s failed after %d attempts", url, maxRetries)
}

func main() {
	host := flag.String("host", "example.com", "目標(biāo)主機(jī)，用于 TCP 檢查")
	port := flag.String("port", "80", "目標(biāo)端口，用于 TCP 檢查")
	url := flag.String("url", "https://example.com", "目標(biāo) URL，用于 HTTP 跟蹤")
	logFile := flag.String("log", "network_diagnostic.log", "日志文件路徑")
	timeout := flag.Duration("timeout", 5*time.Second, "操作超時(shí)時(shí)間")
	retries := flag.Int("retries", 3, "最大重試次數(shù)")
	flag.Parse()
	diag, err := NewNetworkDiagnostic(*logFile)
	if err != nil {
		fmt.Fprintf(os.Stderr, "初始化診斷工具失敗：%v\n", err)
		os.Exit(1)
	}
	defer diag.logger.Sync()
	go func() {
		http.Handle("/metrics", promhttp.Handler())
		http.ListenAndServe(":9090", nil)
	}()
	fmt.Printf("檢查 TCP 連接 %s:%s...\n", *host, *port)
	if err := diag.CheckTCPConnection(*host, *port, *timeout, *retries); err != nil {
		fmt.Println("TCP 檢查失?。?, err)
	} else {
		fmt.Println("TCP 檢查成功")
	}
	fmt.Printf("\n跟蹤 HTTP 請(qǐng)求 %s...\n", *url)
	if err := diag.TraceHTTPRequest(*url, *timeout, *retries); err != nil {
		fmt.Println("HTTP 跟蹤失?。?, err)
	} else {
		fmt.Println("HTTP 跟蹤成功")
	}
}

go run diagnostic.go -host example.com -port 80 -url https://example.com -log diag.log -timeout 5s -retries 3