Golang中临时IP的创建与删除

在Golang中创建和删除临时IP地址可以通过net包结合系统调用实现。以下是一个完整的示例，展示如何创建虚拟IP、测试gRPC服务器，并在测试后清理IP地址：

package main

import (
    "context"
    "fmt"
    "net"
    "os/exec"
    "time"

    "google.golang.org/grpc"
    pb "your/proto/package" // 替换为实际的proto包
)

// 创建虚拟IP地址
func createVirtualIP(ip string) error {
    cmd := exec.Command("ip", "addr", "add", ip+"/24", "dev", "lo")
    return cmd.Run()
}

// 删除虚拟IP地址
func deleteVirtualIP(ip string) error {
    cmd := exec.Command("ip", "addr", "del", ip+"/24", "dev", "lo")
    return cmd.Run()
}

// gRPC客户端测试函数
func testGRPCServer(addr string) error {
    conn, err := grpc.Dial(addr, grpc.WithInsecure())
    if err != nil {
        return err
    }
    defer conn.Close()

    client := pb.NewYourServiceClient(conn)
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    // 示例：调用gRPC方法
    resp, err := client.YourMethod(ctx, &pb.YourRequest{})
    if err != nil {
        return err
    }

    fmt.Printf("gRPC响应: %v\n", resp)
    return nil
}

func main() {
    virtualIP := "192.168.99.100"
    grpcAddr := virtualIP + ":50051"

    // 1. 创建虚拟IP
    if err := createVirtualIP(virtualIP); err != nil {
        fmt.Printf("创建虚拟IP失败: %v\n", err)
        return
    }
    fmt.Printf("已创建虚拟IP: %s\n", virtualIP)
    defer deleteVirtualIP(virtualIP) // 确保测试后清理

    // 2. 等待网络接口就绪
    time.Sleep(2 * time.Second)

    // 3. 测试gRPC服务器
    if err := testGRPCServer(grpcAddr); err != nil {
        fmt.Printf("gRPC测试失败: %v\n", err)
        return
    }

    fmt.Println("测试完成，虚拟IP已自动清理")
}

对于Jenkins集成，可以使用以下Pipeline脚本：

pipeline {
    agent any
    
    stages {
        stage('Setup Virtual IP') {
            steps {
                sh '''
                    # 创建虚拟IP
                    sudo ip addr add 192.168.99.100/24 dev lo
                '''
            }
        }
        
        stage('Run Tests') {
            steps {
                sh '''
                    # 运行Go测试
                    go test -v ./...
                '''
            }
        }
        
        stage('Cleanup') {
            steps {
                sh '''
                    # 删除虚拟IP
                    sudo ip addr del 192.168.99.100/24 dev lo || true
                '''
            }
        }
    }
    
    post {
        always {
            sh '''
                # 确保清理虚拟IP
                sudo ip addr del 192.168.99.100/24 dev lo || true
            '''
        }
    }
}

如果需要更精细的控制，可以使用Go的syscall包直接进行系统调用：

package main

import (
    "syscall"
    "unsafe"
)

func setIPAddress(ip string, add bool) error {
    fd, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_DGRAM, 0)
    if err != nil {
        return err
    }
    defer syscall.Close(fd)

    var req ifreq
    copy(req.Name[:], "lo\x00")
    
    addr := syscall.RawSockaddrInet4{
        Family: syscall.AF_INET,
    }
    copy(addr.Addr[:], net.ParseIP(ip).To4())

    if add {
        req.Data = (*ifreqAddr)(unsafe.Pointer(&addr))
        _, _, errno := syscall.Syscall(
            syscall.SYS_IOCTL,
            uintptr(fd),
            syscall.SIOCSIFADDR,
            uintptr(unsafe.Pointer(&req)),
        )
        if errno != 0 {
            return errno
        }
    } else {
        // 删除IP的类似逻辑
    }
    
    return nil
}

type ifreq struct {
    Name [16]byte
    Data uintptr
}

type ifreqAddr struct {
    Addr syscall.RawSockaddrInet4
}

这个实现提供了完整的虚拟IP生命周期管理，包括创建、测试使用和清理。通过defer语句确保即使在测试失败时也能正确清理资源。