Handle disk io

Author: sjmiller609

lib/instances/manager.go

@@ -340,6 +340,7 @@ func (m *manager) ListInstanceAllocations(ctx context.Context) ([]resources.Inst
 			VolumeOverlayBytes: volumeOverlayBytes,
 			NetworkDownloadBps: inst.NetworkBandwidthDownload,
 			NetworkUploadBps:   inst.NetworkBandwidthUpload,
+			DiskIOBps:          inst.DiskIOBps,
 			State:              string(inst.State),
 			VolumeBytes:        volumeBytes,
 		})

lib/resources/disk.go

@@ -126,3 +126,42 @@ func parseDiskIOLimit(limit string) (int64, error) {
 
 	return int64(ds.Bytes()), nil
 }
+
+// DiskIOResource implements Resource for disk I/O bandwidth tracking.
+type DiskIOResource struct {
+	capacity       int64 // bytes per second
+	instanceLister InstanceLister
+}
+
+// NewDiskIOResource creates a disk I/O resource with the given capacity.
+func NewDiskIOResource(capacity int64, instLister InstanceLister) *DiskIOResource {
+	return &DiskIOResource{capacity: capacity, instanceLister: instLister}
+}
+
+// Type returns the resource type.
+func (d *DiskIOResource) Type() ResourceType {
+	return ResourceDiskIO
+}
+
+// Capacity returns the total disk I/O capacity in bytes per second.
+func (d *DiskIOResource) Capacity() int64 {
+	return d.capacity
+}
+
+// Allocated returns total disk I/O allocated across all active instances.
+func (d *DiskIOResource) Allocated(ctx context.Context) (int64, error) {
+	if d.instanceLister == nil {
+		return 0, nil
+	}
+	instances, err := d.instanceLister.ListInstanceAllocations(ctx)
+	if err != nil {
+		return 0, err
+	}
+	var total int64
+	for _, inst := range instances {
+		if isActiveState(inst.State) {
+			total += inst.DiskIOBps
+		}
+	}
+	return total, nil
+}

lib/resources/resource.go

@@ -21,6 +21,7 @@ const (
 	ResourceMemory  ResourceType = "memory"
 	ResourceDisk    ResourceType = "disk"
 	ResourceNetwork ResourceType = "network"
+	ResourceDiskIO  ResourceType = "disk_io"
 )
 
 // SourceType identifies how a resource capacity was determined.
@@ -100,6 +101,7 @@ type InstanceAllocation struct {
 	VolumeOverlayBytes int64  // Sum of volume overlay sizes
 	NetworkDownloadBps int64  // Download rate limit (external→VM)
 	NetworkUploadBps   int64  // Upload rate limit (VM→external)
+	DiskIOBps          int64  // Disk I/O rate limit (bytes/sec)
 	State              string // Only count running/paused/created instances
 	VolumeBytes        int64  // Sum of attached volume base sizes (for per-instance reporting)
 }
@@ -211,6 +213,10 @@ func (m *Manager) Initialize(ctx context.Context) error {
 	}
 	m.resources[ResourceNetwork] = net
 
+	// Discover disk I/O (reuses existing DiskIOCapacity method)
+	diskIO := NewDiskIOResource(m.DiskIOCapacity(), m.instanceLister)
+	m.resources[ResourceDiskIO] = diskIO
+
 	return nil
 }
 
@@ -227,6 +233,8 @@ func (m *Manager) GetOversubRatio(rt ResourceType) float64 {
 		ratio = m.cfg.OversubDisk
 	case ResourceNetwork:
 		ratio = m.cfg.OversubNetwork
+	case ResourceDiskIO:
+		ratio = m.cfg.OversubDiskIO
 	default:
 		return 1.0
 	}
@@ -413,6 +421,20 @@ func (m *Manager) ValidateAllocation(ctx context.Context, vcpus int, memoryBytes
 		}
 	}
 
+	// Check Disk I/O
+	if diskIOBps > 0 {
+		status, err := m.GetStatus(ctx, ResourceDiskIO)
+		if err != nil {
+			return fmt.Errorf("check disk I/O capacity: %w", err)
+		}
+		if diskIOBps > status.Available {
+			return fmt.Errorf("insufficient disk I/O: requested %s/s, but only %s/s available (currently allocated: %s/s, effective limit: %s/s with %.1fx oversubscription)",
+				datasize.ByteSize(diskIOBps).HR(), datasize.ByteSize(status.Available).HR(),
+				datasize.ByteSize(status.Allocated).HR(), datasize.ByteSize(status.EffectiveLimit).HR(),
+				status.OversubRatio)
+		}
+	}
+
 	// Check GPU if needed
 	if needsGPU {
 		gpuStatus := GetGPUStatus()