plugin.go

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net"
	"net/http"
	"path/filepath"
	"regexp"
)

// VolumePlugin implements the Docker volume plugin protocol.
type VolumePlugin struct {
	state     *PluginState
	mountBase string
}

func NewVolumePlugin(state *PluginState, mountBase string) *VolumePlugin {
	return &VolumePlugin{
		state:     state,
		mountBase: mountBase,
	}
}

func (vp *VolumePlugin) save() {
	if err := vp.state.Save(); err != nil {
		log.Printf("save state error: %v", err)
	}
}

// --- Docker Plugin Protocol handlers ---

// ping is called by Docker to check plugin health.
func (vp *VolumePlugin) ping(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusOK)
	fmt.Fprint(w, "OK")
}

// proto advertises the plugin protocol version.
func (vp *VolumePlugin) proto(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/vnd.docker.plugins.http.v1.+")
	w.WriteHeader(http.StatusOK)
}

// activate handles /Plugin.Activate and advertises implemented interfaces.
func (vp *VolumePlugin) activate(w http.ResponseWriter, r *http.Request) {
	writeJSON(w, http.StatusOK, map[string]any{
		"Implements": []string{"VolumeDriver"},
	})
}

// capabilities handles /VolumeDriver.Capabilities.
func (vp *VolumePlugin) capabilities(w http.ResponseWriter, r *http.Request) {
	writeJSON(w, http.StatusOK, map[string]any{
		"Capabilities": map[string]any{
			"Scope": "local",
		},
	})
}

// path handles /VolumeDriver.Path: return a volume's mount path without mounting.
func (vp *VolumePlugin) path(w http.ResponseWriter, r *http.Request) {
	req, err := parsePathRequest(r)
	if err != nil {
		badRequest(w, fmt.Sprintf("parse request: %v", err))
		return
	}

	vol, ok := vp.state.GetVolume(req.name)
	if !ok {
		notFound(w, fmt.Sprintf("volume %s not found", req.name))
		return
	}

	lun, ok := vp.state.GetLUN(vol.Portal, vol.IQN)
	mountpoint := filepath.Join(vp.mountBase, lunDirName(vol.Portal, vol.IQN))
	if ok && lun.MountPoint != "" {
		mountpoint = lun.MountPoint
	}
	writeJSON(w, http.StatusOK, map[string]any{"Mountpoint": mountpoint})
}

// Create handles /VolumeDriver.Create: validate driver_opts and ensure the
// LUN is logged in and mounted.
func (vp *VolumePlugin) create(w http.ResponseWriter, r *http.Request) {
	req, err := parseCreateRequest(r)
	if err != nil {
		badRequest(w, fmt.Sprintf("parse request: %v", err))
		return
	}

	portal, iqn := req.opts["portal"], req.opts["iqn"]
	if err := validatePortal(portal); err != nil {
		badRequest(w, err.Error())
		return
	}
	if err := validateIQN(iqn); err != nil {
		badRequest(w, err.Error())
		return
	}

	// If LUN is already mounted, just register the volume name.
	lun, ok := vp.state.GetLUN(portal, iqn)
	if ok {
		mounted, _ := isMounted(lun.MountPoint)
		if mounted {
			vp.state.PutVolume(req.name, &VolumeEntry{
				Portal: portal,
				IQN:    iqn,
				FSType: req.opts["fs_type"],
			})
			vp.save()
			writeJSON(w, http.StatusOK, emptyMap())
			return
		}
	}

	// Ensure full mount chain: login → resolve → mount.
	info, err := EnsureMount(vp.mountBase, portal, iqn, req.opts["fs_type"])
	if err != nil {
		badRequest(w, fmt.Sprintf("mount LUN: %v", err))
		return
	}

	vp.state.UpsertLUN(portal, iqn, func(lun *LUNState) {
		lun.Portal = portal
		lun.IQN = iqn
		lun.DevicePath = info.DevicePath
		lun.MountPoint = info.LUNDir
		lun.Formatted = info.IsFormatted
	})
	vp.state.PutVolume(req.name, &VolumeEntry{
		Portal: portal,
		IQN:    iqn,
		FSType: req.opts["fs_type"],
	})
	vp.save()

	writeJSON(w, http.StatusOK, emptyMap())
}

// Get handles /VolumeDriver.Get: return info about a single volume.
func (vp *VolumePlugin) get(w http.ResponseWriter, r *http.Request) {
	req, err := parseGetRequest(r)
	if err != nil {
		badRequest(w, fmt.Sprintf("parse request: %v", err))
		return
	}

	// Look up volume by name from our stored mappings.
	vol, ok := vp.state.GetVolume(req.name)
	if !ok {
		notFound(w, fmt.Sprintf("volume %s not found", req.name))
		return
	}

	lun, ok := vp.state.GetLUN(vol.Portal, vol.IQN)
	mountpoint := filepath.Join(vp.mountBase, lunDirName(vol.Portal, vol.IQN))
	if ok && lun.MountPoint != "" {
		mountpoint = lun.MountPoint
	}

	writeJSON(w, http.StatusOK, map[string]any{
		"Volume": map[string]any{
			"Name":       req.name,
			"Mountpoint": mountpoint,
			"Status":     map[string]any{},
		},
	})
}

// ListVolumes returns all volumes managed by this plugin on this node.
func (vp *VolumePlugin) list(w http.ResponseWriter, r *http.Request) {
	volumes := make([]map[string]any, 0)

	for name, vol := range vp.state.ListVolumes() {
		lun, ok := vp.state.GetLUN(vol.Portal, vol.IQN)
		mountpoint := ""
		if ok {
			mountpoint = lun.MountPoint
		}
		volumes = append(volumes, map[string]any{
			"Name":       name,
			"Mountpoint": mountpoint,
		})
	}

	writeJSON(w, http.StatusOK, map[string]any{
		"Volumes": volumes,
		"Err":     "",
	})
}

// Mount handles /VolumeDriver.Mount: ensure the volume is accessible and
// return the mount path. Increments the per-LUN ref count.
func (vp *VolumePlugin) mount(w http.ResponseWriter, r *http.Request) {
	req, err := parseMountRequest(r)
	if err != nil {
		badRequest(w, fmt.Sprintf("parse request: %v", err))
		return
	}

	// Look up volume by name from stored mappings.
	vol, ok := vp.state.GetVolume(req.name)
	if !ok {
		badRequest(w, fmt.Sprintf("mount: volume %s not found", req.name))
		return
	}

	portal, iqn := vol.Portal, vol.IQN
	fsType := vol.FSType

	lun, ok := vp.state.GetLUN(portal, iqn)
	needsMount := !ok
	if ok {
		mounted, _ := isMounted(lun.MountPoint)
		if !mounted {
			needsMount = true
		}
	}

	if needsMount {
		info, err := EnsureMount(vp.mountBase, portal, iqn, fsType)
		if err != nil {
			badRequest(w, fmt.Sprintf("mount LUN: %v", err))
			return
		}
		vp.state.UpsertLUN(portal, iqn, func(lun *LUNState) {
			lun.Portal = portal
			lun.IQN = iqn
			lun.DevicePath = info.DevicePath
			lun.MountPoint = info.LUNDir
			lun.Formatted = info.IsFormatted
		})
		vp.save()
		lun, _ = vp.state.GetLUN(portal, iqn)
	}

	if _, ok := vp.state.IncrRef(portal, iqn); !ok {
		badRequest(w, fmt.Sprintf("mount: LUN %s@%s disappeared from state", portal, iqn))
		return
	}
	vp.save()

	writeJSON(w, http.StatusOK, map[string]any{
		"Mountpoint": lun.MountPoint,
	})
}

// Unmount handles /VolumeDriver.Unmount: decrement ref count, possibly
// unmount+logout.
func (vp *VolumePlugin) unmount(w http.ResponseWriter, r *http.Request) {
	req, err := parseUnmountRequest(r)
	if err != nil {
		badRequest(w, fmt.Sprintf("parse request: %v", err))
		return
	}

	// Look up volume by name.
	vol, ok := vp.state.GetVolume(req.name)
	if !ok {
		// Volume not tracked; nothing to do.
		writeJSON(w, http.StatusOK, emptyMap())
		return
	}

	portal, iqn := vol.Portal, vol.IQN

	ref, ok := vp.state.DecrRef(portal, iqn)
	if !ok {
		writeJSON(w, http.StatusOK, emptyMap())
		return
	}
	vp.save()

	if ref <= 0 {
		if err := UnmountLUN(vp.mountBase, portal, iqn); err != nil {
			log.Printf("unmount error: %v", err)
		}
		vp.state.DeleteLUN(portal, iqn)
		vp.save()
	}

	writeJSON(w, http.StatusOK, emptyMap())
}

// Destroy handles /VolumeDriver.Remove: remove volume mapping and unmount if
// no other volumes reference this LUN.
func (vp *VolumePlugin) destroy(w http.ResponseWriter, r *http.Request) {
	req, err := parseDestroyRequest(r)
	if err != nil {
		badRequest(w, fmt.Sprintf("parse request: %v", err))
		return
	}

	// Look up volume by name.
	vol, ok := vp.state.GetVolume(req.name)
	if !ok {
		writeJSON(w, http.StatusOK, emptyMap())
		return
	}

	portal, iqn := vol.Portal, vol.IQN

	// Remove volume mapping.
	vp.state.DeleteVolume(req.name)

	// Check if any other volumes still reference this LUN.
	hasOtherRefs := false
	for _, v := range vp.state.ListVolumes() {
		if v.Portal == portal && v.IQN == iqn {
			hasOtherRefs = true
			break
		}
	}

	if !hasOtherRefs {
		if err := UnmountLUN(vp.mountBase, portal, iqn); err != nil {
			log.Printf("destroy unmount error: %v", err)
		}
		vp.state.DeleteLUN(portal, iqn)
	}
	vp.save()

	writeJSON(w, http.StatusOK, emptyMap())
}

// --- Validation helpers ---

var iqnRegex = regexp.MustCompile(`^iqn\.\d{4}-\d{2}\.[a-zA-Z0-9][-a-zA-Z0-9]*(?:\.[a-zA-Z0-9][-a-zA-Z0-9]*)*:[a-zA-Z0-9._-]+$`)

func validatePortal(portal string) error {
	if portal == "" {
		return fmt.Errorf("portal is required")
	}
	host, port, err := net.SplitHostPort(portal)
	if err != nil {
		return fmt.Errorf("invalid portal format %q (expected host:port): %v", portal, err)
	}
	if host == "" {
		return fmt.Errorf("portal host is empty")
	}
	if port == "" {
		return fmt.Errorf("portal port is empty")
	}
	for i := 0; i < len(port); i++ {
		if port[i] < '0' || port[i] > '9' {
			return fmt.Errorf("portal port %q is not numeric", port)
		}
	}
	return nil
}

func validateIQN(iqn string) error {
	if iqn == "" {
		return fmt.Errorf("iqn is required")
	}
	if !iqnRegex.MatchString(iqn) {
		return fmt.Errorf("invalid IQN format %q", iqn)
	}
	return nil
}


// --- Request parsing helpers ---

type createRequest struct {
	name string
	opts map[string]string
}

type getRequest struct {
	name string
	opts map[string]string
}

type pathRequest struct {
	name string
	opts map[string]string
}

type mountRequest struct {
	name string
	id   string
	opts map[string]string
}

type unmountRequest struct {
	name string
	id   string
	opts map[string]string
}

type destroyRequest struct {
	name string
	opts map[string]string
}

func parseCreateRequest(r *http.Request) (*createRequest, error) {
	body, err := io.ReadAll(r.Body)
	if err != nil {
		return nil, err
	}
	var raw struct {
		Name       string            `json:"Name"`
		Opts       map[string]string `json:"Opts"`
		StatusCode int               `json:"StatusCode"`
	}
	if err := json.Unmarshal(body, &raw); err != nil {
		return nil, err
	}
	return &createRequest{name: raw.Name, opts: raw.Opts}, nil
}

func parseGetRequest(r *http.Request) (*getRequest, error) {
	body, err := io.ReadAll(r.Body)
	if err != nil {
		return nil, err
	}
	var raw struct {
		Name       string            `json:"Name"`
		Opts       map[string]string `json:"Opts"`
		StatusCode int               `json:"StatusCode"`
	}
	if err := json.Unmarshal(body, &raw); err != nil {
		return nil, err
	}
	return &getRequest{name: raw.Name, opts: raw.Opts}, nil
}

func parsePathRequest(r *http.Request) (*pathRequest, error) {
	body, err := io.ReadAll(r.Body)
	if err != nil {
		return nil, err
	}
	var raw struct {
		Name       string            `json:"Name"`
		Opts       map[string]string `json:"Opts"`
		StatusCode int               `json:"StatusCode"`
	}
	if err := json.Unmarshal(body, &raw); err != nil {
		return nil, err
	}
	return &pathRequest{name: raw.Name, opts: raw.Opts}, nil
}

func parseMountRequest(r *http.Request) (*mountRequest, error) {
	body, err := io.ReadAll(r.Body)
	if err != nil {
		return nil, err
	}
	var raw struct {
		Name       string            `json:"Name"`
		ID         string            `json:"ID"`
		Opts       map[string]string `json:"Opts"`
		StatusCode int               `json:"StatusCode"`
	}
	if err := json.Unmarshal(body, &raw); err != nil {
		return nil, err
	}
	return &mountRequest{name: raw.Name, id: raw.ID, opts: raw.Opts}, nil
}

func parseUnmountRequest(r *http.Request) (*unmountRequest, error) {
	body, err := io.ReadAll(r.Body)
	if err != nil {
		return nil, err
	}
	var raw struct {
		Name       string            `json:"Name"`
		ID         string            `json:"ID"`
		Opts       map[string]string `json:"Opts"`
		StatusCode int               `json:"StatusCode"`
	}
	if err := json.Unmarshal(body, &raw); err != nil {
		return nil, err
	}
	return &unmountRequest{name: raw.Name, id: raw.ID, opts: raw.Opts}, nil
}

func parseDestroyRequest(r *http.Request) (*destroyRequest, error) {
	body, err := io.ReadAll(r.Body)
	if err != nil {
		return nil, err
	}
	var raw struct {
		Name       string            `json:"Name"`
		Opts       map[string]string `json:"Opts"`
		StatusCode int               `json:"StatusCode"`
	}
	if err := json.Unmarshal(body, &raw); err != nil {
		return nil, err
	}
	return &destroyRequest{name: raw.Name, opts: raw.Opts}, nil
}

// --- HTTP helper functions ---

func writeJSON(w http.ResponseWriter, code int, v any) {
	if v == nil {
		v = emptyMap()
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(code)
	json.NewEncoder(w).Encode(v)
}

func badRequest(w http.ResponseWriter, msg string) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusBadRequest)
	json.NewEncoder(w).Encode(map[string]any{"Err": msg})
}

func notFound(w http.ResponseWriter, msg string) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusNotFound)
	json.NewEncoder(w).Encode(map[string]any{"Err": msg})
}

func emptyMap() map[string]any {
	return map[string]any{}
}