// #include <stdio.h>
// #include <string.h>
//
// void process_data(void* data, size_t len) {
//     char buf[100];
//     // 注意：這里只是讀取數(shù)據(jù)，并且假設(shè) len 不會(huì)超長(zhǎng)
//     memcpy(buf, data, len < 99 ? len : 99);
//     buf[len < 99 ? len : 99] = '\0';
//     printf("C received: %s (length: %zu)\n", buf, len);
// }
import "C"
import (
    "fmt"
    "unsafe"
)

func main() {
    goBytes := []byte("Hello from Go Slice!")

    // 將 Go []byte 傳遞給 C 函數(shù)
    // C.CBytes 返回 unsafe.Pointer，對(duì)應(yīng) C 的 void*
    // C 函數(shù)接收數(shù)據(jù)指針和長(zhǎng)度
    C.process_data(C.CBytes(goBytes), C.size_t(len(goBytes)))

    fmt.Println("Go function finished.")

    // 注意：goBytes 的內(nèi)存在 Go 中管理，不需要手動(dòng) free
    // C.CBytes 返回的指針僅在 C.process_data 調(diào)用期間保證有效
}

package context

import "time"

type Context interface {
    // Deadline 返回此 Context 被取消的時(shí)間，如果沒(méi)有設(shè)置 Deadline，ok 返回 false。
    Deadline() (deadline time.Time, ok bool)

    // Done 返回一個(gè) channel，當(dāng) Context 被取消或超時(shí)時(shí)，該 channel 會(huì)被關(guān)閉。
    // 多次調(diào)用 Done 會(huì)返回同一個(gè) channel。
    // 如果 Context 永不取消，Done 可能返回 nil。
    Done() <-chan struct{}

    // Err 在 Done channel 關(guān)閉后，返回 Context 被取消的原因。
    // 如果 Context 未被取消，返回 nil。
    Err() error

    // Value 返回與此 Context 關(guān)聯(lián)的鍵 key 對(duì)應(yīng)的值，如果沒(méi)有則返回 nil。
    // key 必須是可比較的類型，通常不應(yīng)是內(nèi)置的 string 類型或任何其他內(nèi)置類型，
    // 以避免不同包之間定義的鍵發(fā)生沖突。
    Value(key interface{}) interface{}
}

package main

import (
    "context"
    "fmt"
    "time"
)

// worker 模擬一個(gè)耗時(shí)任務(wù)，它會(huì)監(jiān)聽(tīng) Context 的取消信號(hào)
func worker(ctx context.Context, id int) {
    fmt.Printf("Worker %d started\n", id)
    select {
    case <-time.After(5 * time.Second): // 模擬工作耗時(shí)
        fmt.Printf("Worker %d finished normally\n", id)
    case <-ctx.Done(): // 監(jiān)聽(tīng)取消信號(hào)
        // Context 被取消，清理并退出
        fmt.Printf("Worker %d canceled: %v\n", id, ctx.Err())
    }
}

func main() {
    // 創(chuàng)建一個(gè)可以被取消的 Context
    ctx, cancel := context.WithCancel(context.Background())

    // 啟動(dòng)一個(gè) worker goroutine
    go worker(ctx, 1)

    // 等待一段時(shí)間
    time.Sleep(2 * time.Second)

    // 發(fā)出取消信號(hào)
    fmt.Println("Main: Sending cancellation signal...")
    cancel() // 調(diào)用 cancel 函數(shù)

    // 等待一小段時(shí)間，確保 worker 有時(shí)間響應(yīng)取消并打印信息
    time.Sleep(1 * time.Second)
    fmt.Println("Main: Finished")
}

$ go run main.go 
Worker 1 started
Main: Sending cancellation signal...
Worker 1 canceled: context canceled
Main: Finished

package main

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

func fetchURL(ctx context.Context, url string) (string, error) {
    // 使用 http.NewRequestWithContext 將 Context 與請(qǐng)求關(guān)聯(lián)
    // 這個(gè)例子實(shí)際上有些超前， NewRequestWithContext 在 go 1.13 中才被添加
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return "", fmt.Errorf("failed to create request: %w", err)
    }

    // 發(fā)送請(qǐng)求
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        // 如果是因?yàn)?Context 超時(shí)或取消導(dǎo)致的錯(cuò)誤，err 會(huì)是 context.DeadlineExceeded 或 context.Canceled
        return "", fmt.Errorf("failed to fetch URL: %w", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return "", fmt.Errorf("unexpected status code: %d", resp.StatusCode)
    }

    // 這里簡(jiǎn)化處理，實(shí)際應(yīng)用中會(huì)讀取 Body 內(nèi)容
    return fmt.Sprintf("Success: Status %d", resp.StatusCode), nil
}

func main() {
    // 創(chuàng)建一個(gè)帶有 1 秒超時(shí)的 Context
    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
    defer cancel() // 良好的實(shí)踐：即使超時(shí)，也調(diào)用 cancel 釋放資源

    // 嘗試訪問(wèn)一個(gè)響應(yīng)較慢的 URL (httpbin.org/delay/3 會(huì)延遲 3 秒響應(yīng))
    result, err := fetchURL(ctx, "https://httpbin.org/delay/3")

    if err != nil {
        fmt.Printf("Error fetching URL: %v\n", err)
        // 檢查錯(cuò)誤是否由 Context 引起
        if ctx.Err() == context.DeadlineExceeded {
            fmt.Println("Reason: Context deadline exceeded")
        } else if ctx.Err() == context.Canceled {
            fmt.Println("Reason: Context canceled")
        }
    } else {
        fmt.Printf("Result: %s\n", result)
    }
}

$ go run main.go
# 實(shí)際上在 go 1.13 以上才能運(yùn)行
Error fetching URL: failed to fetch URL: Get "https://httpbin.org/delay/3": context deadline exceeded
Reason: Context deadline exceeded

package main

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

// 使用未導(dǎo)出的類型作為 key，防止命名沖突
type contextKey string

const userIPKey contextKey = "userIP"

// 將 IP 存入 Context
func NewContextWithUserIP(ctx context.Context, userIP net.IP) context.Context {
    return context.WithValue(ctx, userIPKey, userIP)
}

// 從 Context 取出 IP
func UserIPFromContext(ctx context.Context) (net.IP, bool) {
    ip, ok := ctx.Value(userIPKey).(net.IP)
    return ip, ok
}

// 模擬一個(gè)需要用戶 IP 的下游處理函數(shù)
func processRequest(ctx context.Context) {
    fmt.Println("Processing request...")
    if ip, ok := UserIPFromContext(ctx); ok {
        fmt.Printf("  User IP found in context: %s\n", ip.String())
    } else {
        fmt.Println("  User IP not found in context.")
    }
    // 模擬工作
    time.Sleep(50 * time.Millisecond)
    fmt.Println("Processing finished.")
}

// HTTP handler
func handleRequest(w http.ResponseWriter, r *http.Request) {
    // 嘗試從請(qǐng)求中解析 IP (簡(jiǎn)化處理)
    ipStr, _, err := net.SplitHostPort(r.RemoteAddr)
    var userIP net.IP
    if err == nil {
        userIP = net.ParseIP(ipStr)
    }

    // 獲取請(qǐng)求的 Context (http.Request 自帶 Context)
    ctx := r.Context() // 通常這個(gè) Context 已經(jīng)與請(qǐng)求的生命周期綁定

    // 如果獲取到 IP，將其添加到 Context 中
    if userIP != nil {
        ctx = NewContextWithUserIP(ctx, userIP)
    }

    // 調(diào)用下游處理函數(shù)，傳遞帶有用戶 IP 的 Context
    processRequest(ctx)

    fmt.Fprintln(w, "Request processed.")
}

func main() {
    http.HandleFunc("/", handleRequest)
    fmt.Println("Starting server on :8080")
    // 注意：在實(shí)際生產(chǎn)中，需要配置 http.Server 并優(yōu)雅地關(guān)閉
    if err := http.ListenAndServe(":8080", nil); err != nil {
        fmt.Printf("Server failed: %v\n", err)
    }
}

$ go run main.go
Starting server on :8080
# 另一個(gè)終端 curl 127.0.0.1:8080
Processing request...
  User IP found in context: 127.0.0.1
Processing finished.

package httptrace

import (
 "context"
 "crypto/tls"
 "net"
 "time"
)

// ClientTrace 是一組可以注冊(cè)的回調(diào)函數(shù)，用于追蹤 HTTP 客戶端請(qǐng)求期間發(fā)生的事件。
type ClientTrace struct {
 // GetConn 在獲取連接之前被調(diào)用。hostPort 是目標(biāo)地址。
 GetConn func(hostPort string)
 // GotConn 在成功獲取連接后被調(diào)用。
 GotConn func(GotConnInfo)
 // PutIdleConn 在連接返回到空閑池時(shí)被調(diào)用。
 PutIdleConn func(err error)
 // GotFirstResponseByte 在收到響應(yīng)的第一個(gè)字節(jié)時(shí)被調(diào)用。
 GotFirstResponseByte func()
 // Got100Continue 在收到 "HTTP/1.1 100 Continue" 響應(yīng)時(shí)被調(diào)用。
 Got100Continue func()
 // Got1xxResponse 在收到以 1 開(kāi)頭的非 100 狀態(tài)碼的響應(yīng)時(shí)被調(diào)用。
 Got1xxResponse func(code int, header string) error
 // DNSStart 在開(kāi)始 DNS 查詢時(shí)被調(diào)用。
 DNSStart func(DNSStartInfo)
 // DNSDone 在 DNS 查詢結(jié)束后被調(diào)用。
 DNSDone func(DNSDoneInfo)
 // ConnectStart 在開(kāi)始新的 TCP 連接時(shí)被調(diào)用。
 ConnectStart func(network, addr string)
 // ConnectDone 在新的 TCP 連接成功建立或失敗后被調(diào)用。
 ConnectDone func(network, addr string, err error)
 // WroteHeaderField 在 Transport 寫(xiě)入 HTTP 請(qǐng)求頭中的每個(gè)鍵值對(duì)后被調(diào)用。
 WroteHeaderField func(key string, value []string)
 // WroteHeaders 在 Transport 成功寫(xiě)入所有請(qǐng)求頭字段后被調(diào)用。
 WroteHeaders func()
 // Wait100Continue 在發(fā)送完請(qǐng)求頭后，如果請(qǐng)求包含 "Expect: 100-continue"，
 // 在等待服務(wù)器的 "100 Continue" 響應(yīng)之前被調(diào)用。
 Wait100Continue func()
 // WroteRequest 在 Transport 成功寫(xiě)入整個(gè)請(qǐng)求（包括主體）后被調(diào)用。
 WroteRequest func(WroteRequestInfo)
}

// GotConnInfo 包含關(guān)于已獲取連接的信息。
type GotConnInfo struct {
 Conn net.Conn // 獲取到的連接
 Reused bool    // 連接是否是從空閑池中復(fù)用的
 WasIdle bool   // 如果是復(fù)用連接，它在空閑池中時(shí)是否是空閑狀態(tài)
 IdleTime time.Duration // 如果是復(fù)用連接且是空閑狀態(tài)，它空閑了多久
}

// ... 其他 Info 結(jié)構(gòu)體定義 ...

package main

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

func main() {
 url := "https://go.dev"
 req, _ := http.NewRequest("GET", url, nil)

 var start, connect, dns time.Time

 trace := &httptrace.ClientTrace{
  // DNS 查詢開(kāi)始
  DNSStart: func(info httptrace.DNSStartInfo) {
   dns = time.Now()
   fmt.Println("DNS Start:", info.Host)
  },
  // DNS 查詢結(jié)束
  DNSDone: func(info httptrace.DNSDoneInfo) {
   fmt.Printf("DNS Done: %v, Err: %v, Duration: %v\n", info.Addrs, info.Err, time.Since(dns))
  },
  // TCP 連接開(kāi)始 (包括 DNS 解析后的地址)
  ConnectStart: func(network, addr string) {
   connect = time.Now()
   fmt.Printf("Connect Start: Network=%s, Addr=%s\n", network, addr)
  },
  // TCP 連接結(jié)束
  ConnectDone: func(network, addr string, err error) {
   fmt.Printf("Connect Done: Network=%s, Addr=%s, Err: %v, Duration: %v\n", network, addr, err, time.Since(connect))
  },
  // 獲取到連接 (可能是新建的或復(fù)用的)
  GotConn: func(info httptrace.GotConnInfo) {
   start = time.Now() // 將獲取連接作為請(qǐng)求開(kāi)始計(jì)時(shí)點(diǎn)
   fmt.Printf("Got Conn: Reused: %t, WasIdle: %t, IdleTime: %v\n", info.Reused, info.WasIdle, info.IdleTime)
  },
  // 收到響應(yīng)的第一個(gè)字節(jié)
  GotFirstResponseByte: func() {
   fmt.Printf("Time to First Byte: %v\n", time.Since(start))
  },
 }

 // 將 trace 關(guān)聯(lián)到 Context
 ctx := httptrace.WithClientTrace(context.Background(), trace)
 // 將帶有 trace 的 Context 附加到 Request
 req = req.WithContext(ctx)

 fmt.Println("Starting request to", url)
 // 執(zhí)行請(qǐng)求
 client := &http.Client{
  // 禁用 KeepAlives 可以確保每次都建立新連接，方便觀察 ConnectStart/Done
  // Transport: &http.Transport{DisableKeepAlives: true},
 }
 resp, err := client.Do(req)
 if err != nil {
  log.Fatalf("Request failed: %v", err)
 }
 defer resp.Body.Close()

 fmt.Printf("Request finished. Status: %s\n", resp.Status)
 // 注意：這里無(wú)法直接得到總耗時(shí)，總耗時(shí)需要自己記錄請(qǐng)求前后的時(shí)間戳來(lái)計(jì)算。
 // trace 主要用于分解內(nèi)部各階段的耗時(shí)。
}

$ go run main.go
Starting request to https://go.dev
DNS Start: go.dev
DNS Done: [{216.239.36.21 } {216.239.34.21 } {216.239.32.21 } {216.239.38.21 } {2001:4860:4802:36::15 } {2001:4860:4802:34::15 } {2001:4860:4802:32::15 } {2001:4860:4802:38::15 }], Err: <nil>, Duration: 311.409ms
Connect Start: Network=tcp, Addr=216.239.36.21:443
Connect Done: Network=tcp, Addr=216.239.36.21:443, Err: <nil>, Duration: 5.076ms
Got Conn: Reused: false, WasIdle: false, IdleTime: 0s
Time to First Byte: 373.383ms
Request finished. Status: 200 OK