Go语言中HTTP客户端操作的nil指针解引用恐慌及defer的正确使用

func getBody(method string, url string, headers map[string]string, body []byte) ([]byte, error) {
    client := &http.Client{}
    req, err := http.NewRequest(method, url, bytes.NewReader(body))
    if err != nil {
        return nil, err
    }

    for key, value := range headers {
        req.Header.Add(key, value)
    }

    res, err := client.Do(req) // 执行HTTP请求
    defer res.Body.Close()     // 尝试在请求结束后关闭响应体

    if err != nil {            // 在这里才检查错误
        return nil, err
    }

    // ... 后续处理响应体 ...
    return nil, nil // 示例简化
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "os"
    "os/exec"
)

// ... (其他函数，如 prefetchImages, queueImages, getImages, getToken, main 保持不变) ...

func getBody(method string, url string, headers map[string]string, body []byte) ([]byte, error) {
    client := &http.Client{}
    req, err := http.NewRequest(method, url, bytes.NewReader(body))

    if err != nil {
        return nil, err
    }

    for key, value := range headers {
        req.Header.Add(key, value)
    }

    res, err := client.Do(req) // 执行HTTP请求

    // 立即检查错误。如果发生错误，res可能为nil。
    if err != nil {
        return nil, err // 如果有错误，直接返回，避免访问nil的res
    }

    // 只有在确定res不为nil时，才defer关闭res.Body
    defer res.Body.Close() 

    var bodyBytes []byte

    if res.StatusCode == http.StatusOK { // 使用http.StatusOK常量更具可读性
        bodyBytes, err = ioutil.ReadAll(res.Body)
        if err != nil {
            return nil, fmt.Errorf("failed to read response body: %v", err)
        }
    } else {
        // 对于非200状态码，也视为一种错误，并返回详细信息
        return nil, fmt.Errorf("remote end returned HTTP %d status: %s", res.StatusCode, res.Status)
    }

    return bodyBytes, nil
}

// ... (main函数和其他依赖函数) ...

func prefetchImages() error {
    cmd := exec.Command("glance-cache-prefetcher")
    err := cmd.Run()
    if err != nil {
        return fmt.Errorf("glance-cache-prefetcher failed to execute properly: %v", err)
    }
    return nil
}

func queueImages(hostname string, imageList []string) error {
    for _, image := range imageList {
        cmd := exec.Command("glance-cache-manage", "--host="+hostname, "queue-image", image) // 注意这里参数的拼接方式
        err := cmd.Run()
        if err != nil {
            return fmt.Errorf("glance-cache-manage failed to execute properly for image %s: %v", image, err)
        } else {
            fmt.Printf("Image %s queued\n", image)
        }
    }
    return nil
}

func getImages(authToken string) ([]string, error) {
    type GlanceDetailResponse struct {
        Images []struct {
            Name   string `json:"name"`
            Status string `json:"status"`
            ID     string `json:"id"`
        }
    }

    method := "GET"
    url := "http://192.168.1.2:9292/v1.1/images/detail"
    headers := map[string]string{"X-Auth-Token": authToken}

    bodyBytes, err := getBody(method, url, headers, nil)
    if err != nil {
        return nil, fmt.Errorf("unable to retrieve the response body from the Glance API server: %v", err)
    }

    var glance GlanceDetailResponse
    err = json.Unmarshal(bodyBytes, &glance)
    if err != nil {
        return nil, fmt.Errorf("unable to parse the JSON response: %w", err) // 使用%w包装错误
    }

    // 预分配切片以提高效率，或直接使用append
    imageList := make([]string, 0, len(glance.Images)) 
    for _, image := range glance.Images {
        if image.Status == "active" {
            imageList = append(imageList, image.ID)
        }
    }
    return imageList, nil
}

func getToken() (string, error) {
    type TokenResponse struct {
        Auth struct { // 结构体调整，Auth应该是一个对象，而不是数组
            Token struct {
                Expires string `json:"expires"`
                ID      string `json:"id"`
            } `json:"token"` // 确保字段名与JSON键匹配
        } `json:"auth"`
    }

    method := "POST"
    url := "http://192.168.1.2:5000/v2.0/tokens"
    headers := map[string]string{"Content-type": "application/json"}
    // 替换为实际的密码和租户ID
    creds := []byte(`{"auth":{"passwordCredentials":{"username": "glance", "password":"YOUR_PASSWORD"}, "tenantId":"YOUR_TENANT_KEY"}}`) 

    bodyBytes, err := getBody(method, url, headers, creds)
    if err != nil {
        return "", err
    }

    var keystone TokenResponse
    err = json.Unmarshal(bodyBytes, &keystone)
    if err != nil {
        return "", fmt.Errorf("unable to parse token JSON response: %w", err)
    }

    // 访问路径根据JSON结构调整
    authToken := keystone.Auth.Token.ID 
    return authToken, nil
}

func main() {
    hostname, err := os.Hostname()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error getting hostname: %v\n", err)
        os.Exit(1)
    }

    authToken, err := getToken()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error retrieving authentication token: %v\n", err)
        os.Exit(1)
    }
    fmt.Println("Auth Token retrieved successfully.")

    imageList, err := getImages(authToken)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error getting images: %v\n", err)
        os.Exit(1)
    }
    fmt.Printf("Retrieved %d active images.\n", len(imageList))

    err = queueImages(hostname, imageList)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error queuing images for pre-fetching: %v\n", err)
        os.Exit(1)
    }
    fmt.Println("Images queued successfully.")

    err = prefetchImages()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error pre-fetching images: %v\n", err)
        os.Exit(1)
    }
    fmt.Println("Images pre-fetched successfully.")
}