diskio

type ActiveMount struct {
	Device    string
	MountPath string
}

type CloudDiskClient interface {
	AcquireLease(ctx context.Context, volumeID string) (nonce string, err error)
	ReleaseLease(ctx context.Context, volumeID string, nonce string) error
	// ListLogSegments returns the volume's log segments whose TAI64N label
	// sorts after `after`. Passing the caller's replay horizon keeps the server
	// from walking, and returning, a volume's entire backup history. An empty
	// `after` asks for everything.
	ListLogSegments(ctx context.Context, volumeID string, after string) ([]LogSegmentInfo, error)
	DownloadLogSegment(ctx context.Context, volumeID, segmentID string) (io.ReadCloser, error)
}

type CloudSegmentUploader struct {
	// contains filtered or unexported fields
}

type CloudUpdatesClient interface {
	// Upload sends one update and returns the cloud's ID for it. size must be
	// the exact byte length of body.
	Upload(ctx context.Context, volumeID string, req UploadRequest, body io.Reader, size int64) (string, error)

	// List returns a volume's active updates in replay order.
	List(ctx context.Context, volumeID string, opts ListOptions) ([]UpdateInfo, error)

	// Download opens an update's payload. The caller closes it.
	Download(ctx context.Context, volumeID, updateID string) (io.ReadCloser, error)
}

type CloudVolumeRegistrar interface {
	// EnsureVolume registers the volume and returns its cloud identifier. It is
	// safe to call repeatedly: the same local volume always resolves to the
	// same cloud volume.
	EnsureVolume(ctx context.Context, req RegisterVolumeRequest) (string, error)
}

type DeletedVolumeEntry struct {
	Metadata *DeletedVolumeMetadata
	Path     string
}

type DeletedVolumeGC struct {
	Log      *slog.Logger
	DataPath string
	Config   DeletedVolumeGCConfig
	// contains filtered or unexported fields
}

type DeletedVolumeGCConfig struct {
	CheckInterval time.Duration
	RetentionDays int
}

type DeletedVolumeGCResult struct {
	Purged   int
	Retained int
	Errors   int
}

type DeletedVolumeMetadata struct {
	DiskID     string         `json:"disk_id"`
	DiskName   string         `json:"disk_name"`
	SizeGb     int64          `json:"size_gb"`
	Filesystem string         `json:"filesystem"`
	VolumeID   string         `json:"volume_id"`
	VolumeMode string         `json:"volume_mode"`
	CreatedBy  string         `json:"created_by,omitempty"`
	NodeID     compute.NodeId `json:"node_id"`
	DeletedAt  time.Time      `json:"deleted_at"`
}

type DiskMountController struct {
	// contains filtered or unexported fields
}

type DiskMountOps interface {
	CreateDir(path string, perm os.FileMode) error
	LoopAttach(imagePath string) (devicePath string, err error)
	LoopDetach(devicePath string) error
	// FindLoopByBacking returns the loop device path (e.g. /dev/loop3) currently
	// backing the given image file, or "" if no loop device is attached to it.
	// Used to detect stale/double attachments of the same disk image.
	FindLoopByBacking(imagePath string) (devicePath string, err error)
	// FindAllLoopBackings returns a map of loop device path to the backing
	// file currently attached to it, for every loop device in the kernel.
	// Used by boot-time orphan reconciliation to find stale attachments.
	FindAllLoopBackings() (map[string]string, error)
	LbdAttach(ctx context.Context, imagePath, logDir string) (devicePath string, err error)
	LbdDetach(ctx context.Context, devicePath string) error
	Mount(device, mountPath, filesystem string, readOnly bool) error
	Unmount(path string) error
	IsMounted(path string) bool
	// IsDeviceMounted reports whether device is currently mounted at any
	// path in the kernel mount table. Used as a safety check before
	// running fsck, which must never run against a live filesystem.
	// Returns an error if the mount table cannot be read — callers must
	// treat that as "unknown" and refuse the destructive operation they
	// were gating on this check.
	IsDeviceMounted(device string) (bool, error)
	IsFormatted(ctx context.Context, device, filesystem string) (bool, error)
	FormatDevice(ctx context.Context, device, filesystem string) error
	// Fsck runs a filesystem check-and-repair on device. The device must
	// not be mounted anywhere when this is called. Used to recover from
	// EUCLEAN ("Structure needs cleaning") mount failures after an
	// unclean shutdown.
	Fsck(ctx context.Context, device, filesystem string) error

	// FindMounts returns all mounts whose mount path starts with the given prefix.
	FindMounts(pathPrefix string) []ActiveMount
}

type DiskVolumeController struct {
	// contains filtered or unexported fields
}

type DiskVolumeOps interface {
	CreateVolumeDir(path string) error
	RemoveVolumeDir(path string) error
	MoveVolumeDir(src, dst string) error
	VolumePathExists(path string) bool
	CreateDiskImage(path string, sizeBytes int64) error
}

type ImageSnapshotter struct {
	// contains filtered or unexported fields
}

type ListOptions struct {
	Kind  UpdateKind
	After string
	Until string

	// Descending returns newest first instead of replay order. Paired with
	// Limit 1 it answers "what is the most recent update" in one round trip,
	// rather than paging a volume's whole history to keep the last row.
	Descending bool

	// Limit caps how many updates come back. Zero walks every page, which is
	// what replay wants; a positive value stops as soon as it has enough.
	Limit int
}

type LogSegmentInfo struct {
	SegmentID string
	Label     string
}

type LogSegmentUploader interface {
	// UploadSegment uploads a log segment and returns the cloud segment ID.
	UploadSegment(ctx context.Context, volumeID, segmentPath string) (segmentID string, err error)
}

type LogWatcher struct {
	// contains filtered or unexported fields
}

type MountState struct {
	// EntityId is the ID of the disk_mount entity
	EntityId string `json:"entity_id"`

	// VolumeId is the ID of the disk_volume entity
	VolumeId string `json:"volume_id"`

	// CloudVolumeId is the backing volume's miren.cloud identifier, captured
	// when the mount is created. Every cloud lease call keys off it, and
	// recording it here means lease release still works after the volume's
	// VolumeState is gone (e.g. orphan cleanup). Empty for mounts persisted
	// before this field existed, or volumes never registered with the cloud.
	CloudVolumeId string `json:"cloud_volume_id,omitempty"`

	// DevicePath is the path to the loop device node
	DevicePath string `json:"device_path"`

	// MountPath is where the volume is mounted
	MountPath string `json:"mount_path"`

	// Mounted indicates if the volume is currently mounted
	Mounted bool `json:"mounted"`

	// ReadOnly indicates if the mount is read-only
	ReadOnly bool `json:"read_only"`

	// Mode is the disk I/O mode used for this mount (universal or accelerator)
	Mode storage_v1alpha.DiskVolumeVolumeMode `json:"mode,omitempty"`

	// LeaseNonce is the volume lease nonce from remote Disk API
	LeaseNonce string `json:"lease_nonce,omitempty"`
}

type RegisterVolumeRequest struct {
	// LocalVolumeID is the node's identifier for the volume. It seeds the
	// cloud volume's name and UUID, which is what makes registration
	// idempotent across retries.
	LocalVolumeID string
	// ClusterID scopes the name, so two clusters in one organization that each
	// hold a disk called "data" do not land on the same cloud volume and
	// interleave their backups.
	ClusterID string
	// DisplayName is the operator-facing disk name, recorded as metadata.
	DisplayName string
	SizeBytes   int64
	Filesystem  string
}

type SnapshotRequest struct {
	// VolumeID is the cloud volume the update belongs to.
	VolumeID string
	// ImagePath is the backing file to snapshot.
	ImagePath string
	// Name and Filesystem are recorded in the snapshot header so a restore
	// knows what it is rebuilding.
	Name       string
	Filesystem string
	// SnapshotName optionally pins this as a named restore point.
	SnapshotName string
	// LeaseNonce is required when the volume has an active lease.
	LeaseNonce string
	// StagingDir is where the compressed snapshot is written before upload.
	// Defaults to the image's own directory.
	StagingDir string
}

type State struct {
	Volumes map[string]*VolumeState `json:"volumes"`
	Mounts  map[string]*MountState  `json:"mounts"`
	// contains filtered or unexported fields
}

type UpdateInfo struct {
	UpdateID     string `json:"update_id"`
	Kind         string `json:"kind"`
	OrderingKey  string `json:"ordering_key"`
	EndKey       string `json:"end_key,omitempty"`
	Size         int64  `json:"size"`
	SnapshotName string `json:"snapshot_name,omitempty"`
}

type UpdateKind string

type UploadRequest struct {
	Kind        UpdateKind
	OrderingKey string
	// EndKey bounds range-valued kinds. Neither kind here uses it; the cloud
	// rejects it for lbd_log and loop_image.
	EndKey string
	// SnapshotName names a restore point, pinning the update against cleanup.
	// It must be unique per volume among live updates.
	SnapshotName string
	// Metadata is kind-specific payload detail. The cloud writes it to a
	// sidecar object beside the payload rather than indexing it.
	Metadata map[string]any
	// LeaseNonce is required when the volume has an active lease.
	LeaseNonce string
}

type VolumeState struct {
	// EntityId is the ID of the disk_volume entity
	EntityId string `json:"entity_id"`

	// VolumeId is the local volume identifier. It names the mount point, so it
	// is deliberately not the cloud's id: repointing it would relocate a live
	// mount out from under whatever is using it.
	VolumeId string `json:"volume_id"`

	// CloudVolumeId is this volume's identifier in miren.cloud, empty until it
	// has been registered there. Every cloud call keys off it, so empty means
	// "not backed up yet" rather than "fall back to the local id", which the
	// cloud would only reject.
	CloudVolumeId string `json:"cloud_volume_id,omitempty"`

	// Name is the human-readable name (from parent disk)
	Name string `json:"name,omitempty"`

	// DiskPath is the path to the volume data directory
	DiskPath string `json:"disk_path"`

	// SizeBytes is the volume size
	SizeBytes int64 `json:"size_bytes"`

	// Filesystem type (ext4, xfs, btrfs)
	Filesystem string `json:"filesystem"`

	// RemoteOnly indicates if this uses only remote storage
	RemoteOnly bool `json:"remote_only"`

	// Mode is the disk I/O mode (universal or accelerator)
	Mode storage_v1alpha.DiskVolumeVolumeMode `json:"mode,omitempty"`

	// DevicePath is the loop device backing this volume (alwaysMount modes only)
	DevicePath string `json:"device_path,omitempty"`

	// MountPath is where the volume is mounted (alwaysMount modes only)
	MountPath string `json:"mount_path,omitempty"`

	// Mounted indicates if the volume is currently mounted (alwaysMount modes only)
	Mounted bool `json:"mounted,omitempty"`
}