seaweedfs/weed/storage/blockvol/csi/iscsi_util.go

package csi

import (
	"context"
	"fmt"
	"os/exec"
	"path/filepath"
	"strings"
	"time"
)

// ISCSIUtil provides iSCSI initiator operations.
type ISCSIUtil interface {
	Discovery(ctx context.Context, portal string) error
	Login(ctx context.Context, iqn, portal string) error
	Logout(ctx context.Context, iqn string) error
	GetDeviceByIQN(ctx context.Context, iqn string) (string, error)
	IsLoggedIn(ctx context.Context, iqn string) (bool, error)
	RescanDevice(ctx context.Context, iqn string) error
}

// MountUtil provides filesystem mount operations.
type MountUtil interface {
	FormatAndMount(ctx context.Context, device, target, fsType string) error
	Mount(ctx context.Context, source, target, fsType string, readOnly bool) error
	BindMount(ctx context.Context, source, target string, readOnly bool) error
	Unmount(ctx context.Context, target string) error
	IsFormatted(ctx context.Context, device string) (bool, error)
	IsMounted(ctx context.Context, target string) (bool, error)
	ResizeFS(ctx context.Context, devicePath, mountPath, fsType string) error
}

// realISCSIUtil uses iscsiadm CLI.
type realISCSIUtil struct{}

func (r *realISCSIUtil) Discovery(ctx context.Context, portal string) error {
	cmd := exec.CommandContext(ctx, "iscsiadm", "-m", "discovery", "-t", "sendtargets", "-p", portal)
	out, err := cmd.CombinedOutput()
	if err != nil {
		return fmt.Errorf("iscsiadm discovery: %s: %w", string(out), err)
	}
	return nil
}

func (r *realISCSIUtil) Login(ctx context.Context, iqn, portal string) error {
	cmd := exec.CommandContext(ctx, "iscsiadm", "-m", "node", "-T", iqn, "-p", portal, "--login")
	out, err := cmd.CombinedOutput()
	if err != nil {
		return fmt.Errorf("iscsiadm login: %s: %w", string(out), err)
	}
	return nil
}

func (r *realISCSIUtil) Logout(ctx context.Context, iqn string) error {
	cmd := exec.CommandContext(ctx, "iscsiadm", "-m", "node", "-T", iqn, "--logout")
	out, err := cmd.CombinedOutput()
	if err != nil {
		// Treat "not logged in" as success.
		if strings.Contains(string(out), "No matching sessions") {
			return nil
		}
		return fmt.Errorf("iscsiadm logout: %s: %w", string(out), err)
	}
	return nil
}

func (r *realISCSIUtil) GetDeviceByIQN(ctx context.Context, iqn string) (string, error) {
	// Poll for device to appear (iSCSI login is async).
	deadline := time.After(10 * time.Second)
	ticker := time.NewTicker(200 * time.Millisecond)
	defer ticker.Stop()

	for {
		select {
		case <-ctx.Done():
			return "", ctx.Err()
		case <-deadline:
			return "", fmt.Errorf("timeout waiting for device for IQN %s", iqn)
		case <-ticker.C:
			// Look for block device symlinks under /dev/disk/by-path/
			pattern := fmt.Sprintf("/dev/disk/by-path/*%s*", iqn)
			matches, err := filepath.Glob(pattern)
			if err != nil {
				continue
			}
			for _, m := range matches {
				// Skip partitions.
				if strings.Contains(m, "-part") {
					continue
				}
				// Resolve symlink to actual device.
				dev, err := filepath.EvalSymlinks(m)
				if err != nil {
					continue
				}
				return dev, nil
			}
		}
	}
}

func (r *realISCSIUtil) IsLoggedIn(ctx context.Context, iqn string) (bool, error) {
	cmd := exec.CommandContext(ctx, "iscsiadm", "-m", "session")
	out, err := cmd.CombinedOutput()
	if err != nil {
		// Exit code 21 = no sessions, not an error.
		outStr := string(out)
		if strings.Contains(outStr, "No active sessions") {
			return false, nil
		}
		// Also handle exit code 21 directly (nsenter may suppress output).
		if exitErr, ok := err.(*exec.ExitError); ok && exitErr.ExitCode() == 21 {
			return false, nil
		}
		return false, fmt.Errorf("iscsiadm session: %s: %w", outStr, err)
	}
	return strings.Contains(string(out), iqn), nil
}

func (r *realISCSIUtil) RescanDevice(ctx context.Context, iqn string) error {
	cmd := exec.CommandContext(ctx, "iscsiadm", "-m", "node", "-T", iqn, "--rescan")
	out, err := cmd.CombinedOutput()
	if err != nil {
		return fmt.Errorf("iscsiadm rescan: %s: %w", string(out), err)
	}
	return nil
}

// realMountUtil uses mount/umount/mkfs CLI.
type realMountUtil struct{}

func (r *realMountUtil) FormatAndMount(ctx context.Context, device, target, fsType string) error {
	formatted, err := r.IsFormatted(ctx, device)
	if err != nil {
		return err
	}
	if !formatted {
		cmd := exec.CommandContext(ctx, "mkfs."+fsType, device)
		out, err := cmd.CombinedOutput()
		if err != nil {
			return fmt.Errorf("mkfs.%s: %s: %w", fsType, string(out), err)
		}
	}
	return r.Mount(ctx, device, target, fsType, false)
}

func (r *realMountUtil) Mount(ctx context.Context, source, target, fsType string, readOnly bool) error {
	args := []string{"-t", fsType}
	if readOnly {
		args = append(args, "-o", "ro")
	}
	args = append(args, source, target)
	cmd := exec.CommandContext(ctx, "mount", args...)
	out, err := cmd.CombinedOutput()
	if err != nil {
		return fmt.Errorf("mount: %s: %w", string(out), err)
	}
	return nil
}

func (r *realMountUtil) BindMount(ctx context.Context, source, target string, readOnly bool) error {
	args := []string{"--bind", source, target}
	cmd := exec.CommandContext(ctx, "mount", args...)
	out, err := cmd.CombinedOutput()
	if err != nil {
		return fmt.Errorf("bind mount: %s: %w", string(out), err)
	}
	if readOnly {
		cmd = exec.CommandContext(ctx, "mount", "-o", "remount,bind,ro", target)
		out, err = cmd.CombinedOutput()
		if err != nil {
			return fmt.Errorf("remount ro: %s: %w", string(out), err)
		}
	}
	return nil
}

func (r *realMountUtil) Unmount(ctx context.Context, target string) error {
	cmd := exec.CommandContext(ctx, "umount", target)
	out, err := cmd.CombinedOutput()
	if err != nil {
		// Treat "not mounted" as success.
		if strings.Contains(string(out), "not mounted") {
			return nil
		}
		return fmt.Errorf("umount: %s: %w", string(out), err)
	}
	return nil
}

func (r *realMountUtil) IsFormatted(ctx context.Context, device string) (bool, error) {
	cmd := exec.CommandContext(ctx, "blkid", "-p", device)
	out, err := cmd.CombinedOutput()
	if err != nil {
		// Exit code 2 = no filesystem found.
		if cmd.ProcessState != nil && cmd.ProcessState.ExitCode() == 2 {
			return false, nil
		}
		return false, fmt.Errorf("blkid: %s: %w", string(out), err)
	}
	return strings.Contains(string(out), "TYPE="), nil
}

func (r *realMountUtil) IsMounted(ctx context.Context, target string) (bool, error) {
	cmd := exec.CommandContext(ctx, "mountpoint", "-q", target)
	err := cmd.Run()
	if err == nil {
		return true, nil
	}
	// Non-zero exit = not a mount point.
	return false, nil
}

func (r *realMountUtil) ResizeFS(ctx context.Context, devicePath, mountPath, fsType string) error {
	switch fsType {
	case "ext4", "ext3", "ext2":
		cmd := exec.CommandContext(ctx, "resize2fs", devicePath)
		out, err := cmd.CombinedOutput()
		if err != nil {
			return fmt.Errorf("resize2fs: %s: %w", string(out), err)
		}
	case "xfs":
		cmd := exec.CommandContext(ctx, "xfs_growfs", mountPath)
		out, err := cmd.CombinedOutput()
		if err != nil {
			return fmt.Errorf("xfs_growfs: %s: %w", string(out), err)
		}
	default:
		return fmt.Errorf("unsupported filesystem type for resize: %s", fsType)
	}
	return nil
}

// mockISCSIUtil is a test double for ISCSIUtil.
type mockISCSIUtil struct {
	discoveryErr    error
	loginErr        error
	logoutErr       error
	rescanErr       error
	getDeviceResult string
	getDeviceErr    error
	loggedIn        map[string]bool
	calls           []string
}

func newMockISCSIUtil() *mockISCSIUtil {
	return &mockISCSIUtil{loggedIn: make(map[string]bool)}
}

func (m *mockISCSIUtil) Discovery(_ context.Context, portal string) error {
	m.calls = append(m.calls, "discovery:"+portal)
	return m.discoveryErr
}

func (m *mockISCSIUtil) Login(_ context.Context, iqn, portal string) error {
	m.calls = append(m.calls, "login:"+iqn)
	if m.loginErr != nil {
		return m.loginErr
	}
	m.loggedIn[iqn] = true
	return nil
}

func (m *mockISCSIUtil) Logout(_ context.Context, iqn string) error {
	m.calls = append(m.calls, "logout:"+iqn)
	if m.logoutErr != nil {
		return m.logoutErr
	}
	delete(m.loggedIn, iqn)
	return nil
}

func (m *mockISCSIUtil) GetDeviceByIQN(_ context.Context, iqn string) (string, error) {
	m.calls = append(m.calls, "getdevice:"+iqn)
	return m.getDeviceResult, m.getDeviceErr
}

func (m *mockISCSIUtil) IsLoggedIn(_ context.Context, iqn string) (bool, error) {
	return m.loggedIn[iqn], nil
}

func (m *mockISCSIUtil) RescanDevice(_ context.Context, iqn string) error {
	m.calls = append(m.calls, "rescan:"+iqn)
	return m.rescanErr
}

// mockMountUtil is a test double for MountUtil.
type mockMountUtil struct {
	formatAndMountErr error
	mountErr          error
	unmountErr        error
	resizeFSErr       error
	isFormattedResult bool
	isMountedTargets  map[string]bool
	calls             []string
}

func newMockMountUtil() *mockMountUtil {
	return &mockMountUtil{isMountedTargets: make(map[string]bool)}
}

func (m *mockMountUtil) FormatAndMount(_ context.Context, device, target, fsType string) error {
	m.calls = append(m.calls, "formatandmount:"+device+":"+target)
	if m.formatAndMountErr != nil {
		return m.formatAndMountErr
	}
	m.isMountedTargets[target] = true
	return nil
}

func (m *mockMountUtil) Mount(_ context.Context, source, target, fsType string, readOnly bool) error {
	m.calls = append(m.calls, "mount:"+source+":"+target)
	if m.mountErr != nil {
		return m.mountErr
	}
	m.isMountedTargets[target] = true
	return nil
}

func (m *mockMountUtil) BindMount(_ context.Context, source, target string, readOnly bool) error {
	m.calls = append(m.calls, "bindmount:"+source+":"+target)
	if m.mountErr != nil {
		return m.mountErr
	}
	m.isMountedTargets[target] = true
	return nil
}

func (m *mockMountUtil) Unmount(_ context.Context, target string) error {
	m.calls = append(m.calls, "unmount:"+target)
	if m.unmountErr != nil {
		return m.unmountErr
	}
	delete(m.isMountedTargets, target)
	return nil
}

func (m *mockMountUtil) IsFormatted(_ context.Context, device string) (bool, error) {
	return m.isFormattedResult, nil
}

func (m *mockMountUtil) IsMounted(_ context.Context, target string) (bool, error) {
	return m.isMountedTargets[target], nil
}

func (m *mockMountUtil) ResizeFS(_ context.Context, devicePath, mountPath, fsType string) error {
	m.calls = append(m.calls, "resizefs:"+devicePath+":"+mountPath+":"+fsType)
	return m.resizeFSErr
}