package infra import ( "context" "fmt" "os" "os/exec" "strconv" "strings" "time" ) // TargetConfig configures an iSCSI target instance. type TargetConfig struct { VolSize string // e.g. "100M" WALSize string // e.g. "64M" (default), "4M" for WAL pressure tests IQN string Port int } // DefaultTargetConfig returns a default target config for integration tests. func DefaultTargetConfig() TargetConfig { return TargetConfig{ VolSize: "100M", WALSize: "64M", IQN: "iqn.2024.com.seaweedfs:test1", Port: 3260, } } // Target manages the lifecycle of an iscsi-target process on a remote node. type Target struct { Node *Node Config TargetConfig BinPath string // remote path to iscsi-target binary Pid int LogFile string // remote path to target's stderr log VolFile string // remote path to volume file } // NewTarget creates a Target bound to a node. func NewTarget(node *Node, config TargetConfig) *Target { return &Target{ Node: node, Config: config, BinPath: "/tmp/iscsi-target-test", VolFile: "/tmp/blockvol-test.blk", LogFile: "/tmp/iscsi-target-test.log", } } // SetBinPath overrides the remote binary path. func (t *Target) SetBinPath(p string) { t.BinPath = p } // SetVolFile overrides the remote volume file path. func (t *Target) SetVolFile(p string) { t.VolFile = p } // SetLogFile overrides the remote log file path. func (t *Target) SetLogFile(p string) { t.LogFile = p } // Build cross-compiles the iscsi-target binary for linux/amd64. func (t *Target) Build(ctx context.Context, repoDir string) error { binDir := repoDir + "/weed/storage/blockvol/iscsi/cmd/iscsi-target" outPath := repoDir + "/iscsi-target-linux" cmd := exec.CommandContext(ctx, "go", "build", "-o", outPath, ".") cmd.Dir = binDir cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=amd64", "CGO_ENABLED=0") out, err := cmd.CombinedOutput() if err != nil { return fmt.Errorf("build failed: %s\n%w", out, err) } return nil } // Deploy uploads the pre-built binary to the target node. func (t *Target) Deploy(localBin string) error { return t.Node.Upload(localBin, t.BinPath) } // Start launches the target process. If create is true, a new volume is created. func (t *Target) Start(ctx context.Context, create bool) error { // Pre-flight: verify binary exists and is executable. _, _, binCode, _ := t.Node.Run(ctx, fmt.Sprintf("test -x %s", t.BinPath)) if binCode != 0 { return fmt.Errorf("binary not found or not executable on %s: %s", t.Node.Host, t.BinPath) } // Pre-flight: check if iSCSI port is already in use. portOut, _, portCode, _ := t.Node.Run(ctx, fmt.Sprintf("ss -tln | grep ':%d '", t.Config.Port)) if portCode == 0 && strings.TrimSpace(portOut) != "" { owner, _, _, _ := t.Node.Run(ctx, fmt.Sprintf("ss -tlnp | grep ':%d ' | head -1", t.Config.Port)) return fmt.Errorf("port %d (iSCSI) already in use on %s: %s", t.Config.Port, t.Node.Host, strings.TrimSpace(owner)) } // Remove old log t.Node.Run(ctx, fmt.Sprintf("rm -f %s", t.LogFile)) args := fmt.Sprintf("-vol %s -addr :%d -iqn %s", t.VolFile, t.Config.Port, t.Config.IQN) if create { if err := CheckDiskSpace(ctx, t.Node, t.VolFile, t.Config.VolSize, t.Config.WALSize); err != nil { return err } t.Node.Run(ctx, fmt.Sprintf("rm -f %s %s.wal", t.VolFile, t.VolFile)) args += fmt.Sprintf(" -create -size %s", t.Config.VolSize) if t.Config.WALSize != "" { args += fmt.Sprintf(" -wal-size %s", t.Config.WALSize) } } cmd := fmt.Sprintf("setsid -f %s %s >%s 2>&1", t.BinPath, args, t.LogFile) _, stderr, code, err := t.Node.Run(ctx, cmd) if err != nil || code != 0 { return fmt.Errorf("start target: code=%d stderr=%s err=%v", code, stderr, err) } if err := t.WaitForPort(ctx); err != nil { return err } // Discover PID by matching the binary name stdout, _, _, _ := t.Node.Run(ctx, fmt.Sprintf("ps -eo pid,args | grep '%s' | grep -v grep | awk '{print $1}'", t.BinPath)) pidStr := strings.TrimSpace(stdout) if idx := strings.IndexByte(pidStr, '\n'); idx > 0 { pidStr = pidStr[:idx] } pid, err := strconv.Atoi(pidStr) if err != nil { return fmt.Errorf("find target PID: %q: %w", pidStr, err) } t.Pid = pid return nil } // Stop sends SIGTERM, waits up to 10s, then Kill9. func (t *Target) Stop(ctx context.Context) error { if t.Pid == 0 { return nil } t.Node.Run(ctx, fmt.Sprintf("kill %d", t.Pid)) deadline := time.Now().Add(10 * time.Second) for time.Now().Before(deadline) { _, _, code, _ := t.Node.Run(ctx, fmt.Sprintf("kill -0 %d 2>/dev/null", t.Pid)) if code != 0 { t.Pid = 0 return nil } time.Sleep(500 * time.Millisecond) } return t.Kill9() } // Kill9 sends SIGKILL immediately. func (t *Target) Kill9() error { if t.Pid == 0 { return nil } ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() t.Node.Run(ctx, fmt.Sprintf("kill -9 %d", t.Pid)) t.Pid = 0 return nil } // Restart stops the target and starts it again (preserving the volume). func (t *Target) Restart(ctx context.Context) error { if err := t.Stop(ctx); err != nil { return fmt.Errorf("restart stop: %w", err) } return t.Start(ctx, false) } // WaitForPort polls until the target port is listening. func (t *Target) WaitForPort(ctx context.Context) error { for { select { case <-ctx.Done(): return fmt.Errorf("wait for port %d: %w", t.Config.Port, ctx.Err()) default: } stdout, _, code, _ := t.Node.Run(ctx, fmt.Sprintf("ss -tln | grep :%d", t.Config.Port)) if code == 0 && strings.Contains(stdout, fmt.Sprintf(":%d", t.Config.Port)) { return nil } time.Sleep(200 * time.Millisecond) } } // CollectLog downloads the target's log file contents. func (t *Target) CollectLog() (string, error) { ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() stdout, _, _, err := t.Node.Run(ctx, fmt.Sprintf("cat %s 2>/dev/null", t.LogFile)) if err != nil { return "", err } return stdout, nil } // Cleanup removes the volume file, WAL, and log from the target node. func (t *Target) Cleanup(ctx context.Context) { t.Node.Run(ctx, fmt.Sprintf("rm -f %s %s.wal %s", t.VolFile, t.VolFile, t.LogFile)) } // PID returns the current target process ID. func (t *Target) PID() int { return t.Pid } // VolFilePath returns the remote volume file path. func (t *Target) VolFilePath() string { return t.VolFile } // CheckDiskSpace verifies a node has enough space for a volume + WAL. // volSize/walSize are human-readable strings like "100M", "64M". func CheckDiskSpace(ctx context.Context, node *Node, volFile, volSize, walSize string) error { // Parse sizes to MB. volMB := parseSizeMB(volSize) walMB := parseSizeMB(walSize) if walMB == 0 { walMB = 64 // default WAL } neededMB := volMB + walMB + 50 // headroom for metadata/journal // Get available space on the directory containing the volume file. dir := volFile if idx := strings.LastIndex(dir, "/"); idx > 0 { dir = dir[:idx] } stdout, _, code, _ := node.Run(ctx, fmt.Sprintf("df -BM %s 2>/dev/null | tail -1 | awk '{print $4}'", dir)) if code != 0 { return fmt.Errorf("disk space check failed on %s (df returned code %d for %s)", node.Host, code, dir) } availStr := strings.TrimSpace(stdout) availStr = strings.TrimSuffix(availStr, "M") availMB, err := strconv.Atoi(availStr) if err != nil { return fmt.Errorf("disk space check: cannot parse df output %q on %s", availStr, node.Host) } if availMB < neededMB { return fmt.Errorf("insufficient disk space on %s: %dMB available, need %dMB (vol=%s wal=%s + 50MB headroom)", node.Host, availMB, neededMB, volSize, walSize) } return nil } // parseSizeMB parses a human-readable size string (e.g. "100M", "1G", "1073741824") to megabytes. // Raw numbers >= 1048576 are treated as bytes. func parseSizeMB(s string) int { s = strings.TrimSpace(s) if s == "" { return 0 } s = strings.ToUpper(s) multiplier := 1 if strings.HasSuffix(s, "G") { multiplier = 1024 s = strings.TrimSuffix(s, "G") } else if strings.HasSuffix(s, "M") { s = strings.TrimSuffix(s, "M") } else if strings.HasSuffix(s, "K") { s = strings.TrimSuffix(s, "K") v, _ := strconv.Atoi(s) return v / 1024 } v, _ := strconv.Atoi(s) result := v * multiplier // Raw numbers >= 1MB are assumed to be in bytes. if multiplier == 1 && result >= 1048576 { return result / (1024 * 1024) } return result }