// #include <stdio.h>
// #include <string.h>
//
// void process_data(void* data, size_t len) {
//     char buf[100];
//     // 注意：這里只是讀取數(shù)據(jù)，并且假設(shè) len 不會超長
//     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，對應(yīng) C 的 void*
    // C 函數(shù)接收數(shù)據(jù)指針和長度
    C.process_data(C.CBytes(goBytes), C.size_t(len(goBytes)))

    fmt.Println("Go function finished.")

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

package context

import "time"

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

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

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

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

package main

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

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

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

    // 啟動一個 worker goroutine
    go worker(ctx, 1)

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

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

    // 等待一小段時間，確保 worker 有時間響應(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 與請求關(guān)聯(lián)
    // 這個例子實際上有些超前， 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ā)送請求
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        // 如果是因為 Context 超時或取消導(dǎo)致的錯誤，err 會是 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)
    }

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

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

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

    if err != nil {
        fmt.Printf("Error fetching URL: %v\n", err)
        // 檢查錯誤是否由 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
# 實際上在 go 1.13 以上才能運行
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
}

// 模擬一個需要用戶 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) {
    // 嘗試從請求中解析 IP (簡化處理)
    ipStr, _, err := net.SplitHostPort(r.RemoteAddr)
    var userIP net.IP
    if err == nil {
        userIP = net.ParseIP(ipStr)
    }

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

// GotConnInfo 包含關(guān)于已獲取連接的信息。
type GotConnInfo struct {
 Conn net.Conn // 獲取到的連接
 Reused bool    // 連接是否是從空閑池中復(fù)用的
 WasIdle bool   // 如果是復(fù)用連接，它在空閑池中時是否是空閑狀態(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 查詢開始
  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 連接開始 (包括 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() // 將獲取連接作為請求開始計時點
   fmt.Printf("Got Conn: Reused: %t, WasIdle: %t, IdleTime: %v\n", info.Reused, info.WasIdle, info.IdleTime)
  },
  // 收到響應(yīng)的第一個字節(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í)行請求
 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)
 // 注意：這里無法直接得到總耗時，總耗時需要自己記錄請求前后的時間戳來計算。
 // trace 主要用于分解內(nèi)部各階段的耗時。
}

$ 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