Go os/exec 命令执行后捕获环境变更的挑战与策略

#!/bin/bash
# my_script.sh
export MY_CUSTOM_VAR="value_from_script"
echo "MY_CUSTOM_VAR is set to: $MY_CUSTOM_VAR"

package main

import (
    "fmt"
    "os"
    "os/exec"
    "strings"
)

func main() {
    // 1. 尝试通过Go程序设置初始环境
    os.Setenv("PARENT_VAR", "initial_value")
    fmt.Println("Parent's initial PARENT_VAR:", os.Getenv("PARENT_VAR"))

    // 2. 准备一个会修改环境变量的外部命令
    // 注意：这里使用bash -c来模拟一个脚本，该脚本会设置一个新变量并修改一个现有变量
    cmdStr := `export CHILD_VAR="new_child_value"; export PARENT_VAR="modified_by_child"; echo "Child's PARENT_VAR: $PARENT_VAR"; echo "Child's CHILD_VAR: $CHILD_VAR"`
    cmd := exec.Command("bash", "-c", cmdStr)

    // 可以选择为子进程设置一个初始环境，这里我们使用父进程的环境
    cmd.Env = os.Environ()

    fmt.Println("\n--- Executing child command ---")
    output, err := cmd.CombinedOutput()
    if err != nil {
        fmt.Printf("Error executing command: %v\n", err)
        return
    }
    fmt.Printf("Child command output:\n%s", string(output))
    fmt.Println("--- Child command finished ---\n")

    // 3. 检查父进程的环境
    fmt.Println("Parent's PARENT_VAR after child execution:", os.Getenv("PARENT_VAR"))
    fmt.Println("Parent's CHILD_VAR after child execution:", os.Getenv("CHILD_VAR"))

    // 4. 尝试运行另一个命令，看它是否能感知到CHILD_VAR
    fmt.Println("\n--- Executing another command to check environment ---")
    checkCmd := exec.Command("bash", "-c", "echo \"Another command's CHILD_VAR: $CHILD_VAR\"")
    checkOutput, err := checkCmd.CombinedOutput()
    if err != nil {
        fmt.Printf("Error executing check command: %v\n", err)
        return
    }
    fmt.Printf("Another command output:\n%s", string(checkOutput))
    fmt.Println("--- Another command finished ---\n")

    // 5. 打印父进程的完整环境，确认没有CHILD_VAR
    fmt.Println("Parent's full environment:")
    for _, env := range os.Environ() {
        if strings.HasPrefix(env, "CHILD_VAR=") {
            fmt.Println(env)
        }
    }
}

package main

import (
    "bufio"
    "bytes"
    "fmt"
    "os"
    "os/exec"
    "strings"
)

func main() {
    fmt.Println("Starting Go program...")

    // 准备一个会修改环境变量并打印其完整环境的外部命令
    // 注意：使用`env`命令可以打印当前所有环境变量
    cmdStr := `export MY_VAR_FROM_CHILD="value_from_child_process"; export ANOTHER_VAR="some_other_value"; echo "Child's specific output..."; env`
    cmd := exec.Command("bash", "-c", cmdStr)

    // 捕获标准输出
    var stdoutBuf bytes.Buffer
    cmd.Stdout = &stdoutBuf
    cmd.Stderr = os.Stderr // 将错误输出到Go程序的stderr

    fmt.Println("Executing child command...")
    err := cmd.Run()
    if err != nil {
        fmt.Printf("Error executing command: %v\n", err)
        return
    }
    fmt.Println("Child command finished.")

    // 解析标准输出，提取环境变量
    childEnv := make(map[string]string)
    scanner := bufio.NewScanner(&stdoutBuf)
    inEnvSection := false // 标志是否进入了env命令的输出部分

    for scanner.Scan() {
        line := scanner.Text()
        // 简单的判断，如果行包含等号，且之前没有特定的"Child's specific output..."，则可能是环境变量
        // 更健壮的方式是让子进程在打印env前打印一个明确的标记
        if strings.Contains(line, "=") {
            parts := strings.SplitN(line, "=", 2)
            if len(parts) == 2 {
                childEnv[parts[0]] = parts[1]
                inEnvSection = true // 假设从第一个等号开始就是env输出
            }
        } else if inEnvSection && line == "" { // 如果在env部分遇到空行，可能表示env输出结束
            // 这种判断方式不够健壮，最好是子进程在env输出前后加标记
        }
    }

    if err := scanner.Err(); err != nil {
        fmt.Printf("Error scanning output: %v\n", err)
        return
    }

    fmt.Println("\n--- Captured Environment from Child Process ---")
    if val, ok := childEnv["MY_VAR_FROM_CHILD"]; ok {
        fmt.Printf("MY_VAR_FROM_CHILD: %s\n", val)
    } else {
        fmt.Println("MY_VAR_FROM_CHILD not found in child's output.")
    }
    if val, ok := childEnv["ANOTHER_VAR"]; ok {
        fmt.Printf("ANOTHER_VAR: %s\n", val)
    } else {
        fmt.Println("ANOTHER_VAR not found in child's output.")
    }
    // 也可以打印所有捕获到的变量
    // for k, v := range childEnv {
    //  fmt.Printf("%s=%s\n", k, v)
    // }

    fmt.Println("\nGo program finished.")
}

package main

import (
    "fmt"
    "io/ioutil"
    "os"
    "os/exec"
    "strings"
)

func main() {
    fmt.Println("Starting Go program...")

    // 创建一个临时文件用于子进程写入环境
    tempFile, err := ioutil.TempFile("", "child_env_*.txt")
    if err != nil {
        fmt.Printf("Error creating temp file: %v\n", err)
        return
    }
    tempFileName := tempFile.Name()
    tempFile.Close() // 关闭文件句柄，让子进程可以写入
    defer os.Remove(tempFileName) // 确保程序退出时删除临时文件

    fmt.Printf("Temp file for child env: %s\n", tempFileName)

    // 准备一个会修改环境变量并将其完整环境写入文件的外部命令
    cmdStr := fmt.Sprintf(`export MY_VAR_FROM_CHILD="value_from_child_process_in_file"; export ANOTHER_VAR_IN_FILE="file_value"; env > %s`, tempFileName)
    cmd := exec.Command("bash", "-c", cmdStr)

    cmd.Stderr = os.Stderr // 将错误输出到Go程序的stderr

    fmt.Println("Executing child command...")
    err = cmd.Run()
    if err != nil {
        fmt.Printf("Error executing command: %v\n", err)
        return
    }
    fmt.Println("Child command finished.")

    // 从临时文件读取并解析环境变量
    content, err := ioutil.ReadFile(tempFileName)
    if err != nil {
        fmt.Printf("Error reading temp file: %v\n", err)
        return
    }

    childEnv := make(map[string]string)
    lines := strings.Split(string(content), "\n")
    for _, line := range lines {
        line = strings.TrimSpace(line)
        if line == "" {
            continue
        }
        parts := strings.SplitN(line, "=", 2)
        if len(parts) == 2 {
            childEnv[parts[0]] = parts[1]
        }
    }

    fmt.Println("\n--- Captured Environment from Temp File ---")
    if val, ok := childEnv["MY_VAR_FROM_CHILD"]; ok {
        fmt.Printf("MY_VAR_FROM_CHILD: %s\n", val)
    } else {
        fmt.Println("MY_VAR_FROM_CHILD not found in file.")
    }
    if val, ok := childEnv["ANOTHER_VAR_IN_FILE"]; ok {
        fmt.Printf("ANOTHER_VAR_IN_FILE: %s\n", val)
    } else {
        fmt.Println("ANOTHER_VAR_IN_FILE not found in file.")
    }

    fmt.Println("\nGo program finished.")
}