Spooling in OS — Print Jobs Lost to Silent Disk Full

package io.thecodeforge.spooling;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * SpoolQueueDemo.java
 *
 * Simulates the core mechanic of OS spooling:
 *   - A fast 'application' thread produces print jobs quickly
 *   - A slow 'printer' thread consumes them at device speed
 *   - A shared BlockingQueue acts as the spool (disk buffer)
 *
 * This mirrors exactly how the OS print spooler works:
 * applications write to the queue and return immediately,
 * while the printer daemon drains it independently.
 */
public class SpoolQueueDemo {

    // The spool buffer — in a real OS this lives on disk.
    // Capacity 5 simulates a bounded spool directory.
    private static final LinkedBlockingQueue<String> spoolQueue =
            new LinkedBlockingQueue<>(5);

    public static void main(String[] args) throws InterruptedException {

        // --- PRODUCER: simulates an application sending print jobs ---
        Thread applicationThread = new Thread(() -> {
            String[] documents = {
                "Invoice_April.pdf",
                "MeetingNotes.docx",
                "SalesReport_Q1.xlsx",
                "EmployeeHandbook.pdf",
                "ProjectPlan.pptx"
            };

            for (String document : documents) {
                try {
                    // The app 'submits' a print job — this is near-instant.
                    // put() will block ONLY if the spool queue is full (back-pressure).
                    spoolQueue.put(document);
                    System.out.println("[APP]     Spooled: " + document +
                            "  (queue size: " + spoolQueue.size() + ")");

                    // Application moves on immediately — no waiting for printer.
                    // Simulating the user doing other work between prints.
                    Thread.sleep(200); // 200ms between submissions
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            System.out.println("[APP]     All jobs submitted. Application is free!");
        }, "Application-Thread");

        // --- CONSUMER: simulates the OS printer spooler daemon ---
        Thread printerDaemon = new Thread(() -> {
            int jobsProcessed = 0;
            while (jobsProcessed < 5) {
                try {
                    // poll() waits up to 3 seconds for a job before timing out.
                    // This mirrors a real daemon that wakes when new jobs arrive.
                    String job = spoolQueue.poll(3, TimeUnit.SECONDS);

                    if (job != null) {
                        System.out.println("[PRINTER] Printing: " + job + " ...");
                        // Printer is SLOW — takes 800ms per job.
                        // Application is not affected by this delay at all.
                        Thread.sleep(800);
                        System.out.println("[PRINTER] Done:     " + job);
                        jobsProcessed++;
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            System.out.println("[PRINTER] Spool queue empty. Printer idle.");
        }, "Printer-Daemon");

        // Daemon threads die when the main program exits —
        // just like real OS spooler processes.
        printerDaemon.setDaemon(true);

        printerDaemon.start(); // Start printer daemon first (it waits for jobs)
        applicationThread.start();

        applicationThread.join();  // Wait for all jobs to be submitted
        printerDaemon.join();      // Wait for all jobs to be printed

        System.out.println("\n[SYSTEM]  Spooling demo complete.");
    }
}

package io.thecodeforge.spooling;

/**
 * BufferingVsSpooling.java
 *
 * Demonstrates the structural difference between:
 *   - BUFFERING: RAM-based, in-process, one producer writes then one consumer reads
 *   - SPOOLING:  Disk-based, cross-process, multiple producers, daemon consumer
 *
 * This is a conceptual demonstration — not a full I/O implementation.
 */
public class BufferingVsSpooling {

    // ============================================================
    // BUFFERING: A simple in-memory circular buffer.
    // Producer fills it; consumer drains it.
    // If the buffer is full, the producer MUST wait.
    // ============================================================
    static class PrintBuffer {
        private final byte[] memoryBuffer;
        private int writePosition = 0;
        private int readPosition  = 0;
        private int occupiedBytes = 0;

        PrintBuffer(int capacityBytes) {
            // Buffer lives entirely in RAM — small and fast
            this.memoryBuffer = new byte[capacityBytes];
            System.out.println("[BUFFER]  Created in-RAM buffer, capacity: "
                    + capacityBytes + " bytes");
        }

        // Returns false if buffer is full — producer must block or back off
        synchronized boolean write(byte dataByte) {
            if (occupiedBytes == memoryBuffer.length) {
                return false; // Buffer full — producer is BLOCKED
            }
            memoryBuffer[writePosition] = dataByte;
            writePosition = (writePosition + 1) % memoryBuffer.length;
            occupiedBytes++;
            return true;
        }

        synchronized int read() {
            if (occupiedBytes == 0) return -1; // Nothing to read
            byte data = memoryBuffer[readPosition];
            readPosition = (readPosition + 1) % memoryBuffer.length;
            occupiedBytes--;
            return data;
        }

        int getOccupied() { return occupiedBytes; }
    }

    // ============================================================
    // SPOOLING: Simulated as a named file on disk.
    // Any number of producers can append jobs.
    // Consumer (daemon) reads independently, even after producers exit.
    // ============================================================
    static class PrintSpooler {
        private final java.util.Queue<String> spoolDirectory;
        private final String spoolPath;

        PrintSpooler(String spoolDirectory) {
            // In a real OS: /var/spool/cups (Linux) or C:\Windows\System32\spool (Windows)
            this.spoolPath = spoolDirectory;
            this.spoolDirectory = new java.util.LinkedList<>();
            System.out.println("[SPOOLER] Spool directory ready at: " + spoolPath);
        }

        // Multiple callers can spool simultaneously — jobs persist until printed
        synchronized void spoolJob(String producerName, String documentName) {
            String spoolEntry = producerName + ":" + documentName
                    + ":" + System.currentTimeMillis();
            spoolDirectory.offer(spoolEntry);
            // In a real OS, this writes a file to disk and returns immediately.
            System.out.println("[SPOOLER] Job added by " + producerName
                    + " -> " + documentName
                    + " (" + spoolDirectory.size() + " jobs pending)");
        }

        // Daemon calls this — drains jobs one at a time
        synchronized String getNextJob() {
            return spoolDirectory.poll();
        }

        int getPendingCount() { return spoolDirectory.size(); }
    }

    public static void main(String[] args) throws InterruptedException {
        System.out.println("=== BUFFERING DEMO ===");
        PrintBuffer buffer = new PrintBuffer(4); // Tiny 4-byte buffer

        // Producer writes 3 bytes — succeeds
        System.out.println("Write byte A: " + buffer.write((byte) 'A'));
        System.out.println("Write byte B: " + buffer.write((byte) 'B'));
        System.out.println("Write byte C: " + buffer.write((byte) 'C'));
        System.out.println("Write byte D: " + buffer.write((byte) 'D'));
        // Buffer is full — 5th write FAILS (producer must wait in a real system)
        System.out.println("Write byte E (buffer full): " + buffer.write((byte) 'E'));
        System.out.println("Buffer occupied: " + buffer.getOccupied() + "/4 bytes");

        System.out.println("\n=== SPOOLING DEMO ===");
        PrintSpooler spooler = new PrintSpooler("/var/spool/myprinter");

        // Multiple independent producers — none of them block each other
        spooler.spoolJob("Alice", "Presentation.pptx");
        spooler.spoolJob("Bob",   "TaxReturn.pdf");
        spooler.spoolJob("Alice", "Backup_Report.docx"); // Alice submits again
        spooler.spoolJob("Carol", "LabResults.pdf");

        System.out.println("\n[DAEMON]  Printer daemon waking up, draining spool...");
        String job;
        while ((job = spooler.getNextJob()) != null) {
            System.out.println("[DAEMON]  Processing: " + job);
            Thread.sleep(100); // Simulate slow printing
        }
        System.out.println("[DAEMON]  Spool empty. All jobs printed.");
    }
}

package io.thecodeforge.spooling;

import java.util.PriorityQueue;
import java.util.Comparator;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * PrioritySpooler.java
 *
 * Models a realistic OS spool scheduler that supports job priorities.
 * Lower priority number = higher urgency (like OS process scheduling).
 *
 * This is how CUPS and Windows Print Spooler actually handle
 * situations where multiple jobs compete for one printer.
 */
public class PrioritySpooler {

    // Represents a single spooled print job
    static class PrintJob implements Comparable<PrintJob> {
        private static final AtomicInteger jobCounter = new AtomicInteger(1);

        final int    jobId;           // Unique ID assigned by spooler
        final String ownerUsername;   // Who submitted this job
        final String documentName;    // The actual document
        final int    priorityLevel;   // 1 = urgent, 5 = low priority
        final long   submittedAtMs;   // Timestamp for FIFO within same priority

        PrintJob(String owner, String document, int priority) {
            this.jobId          = jobCounter.getAndIncrement();
            this.ownerUsername  = owner;
            this.documentName   = document;
            this.priorityLevel  = priority;
            this.submittedAtMs  = System.currentTimeMillis();
        }

        // Jobs with lower priority number print first.
        // If priority is equal, earlier submission wins (FIFO).
        @Override
        public int compareTo(PrintJob other) {
            if (this.priorityLevel != other.priorityLevel) {
                return Integer.compare(this.priorityLevel, other.priorityLevel);
            }
            return Long.compare(this.submittedAtMs, other.submittedAtMs);
        }

        @Override
        public String toString() {
            return String.format("Job#%02d [P%d] %-10s -> %s",
                    jobId, priorityLevel, ownerUsername, documentName);
        }
    }

    // The spooler maintains a priority queue — exactly like a real OS scheduler
    private final PriorityQueue<PrintJob> spoolQueue =
            new PriorityQueue<>();

    // Adds a job to the spool directory (disk write in a real OS)
    public void submitJob(String owner, String document, int priority) {
        PrintJob job = new PrintJob(owner, document, priority);
        spoolQueue.offer(job);
        System.out.printf("[SUBMIT]  %s%n", job);
    }

    // Simulates the printer daemon draining jobs in priority order
    public void drainAndPrint() throws InterruptedException {
        System.out.println("\n[DAEMON]  Printer daemon starting — processing spool queue...");
        System.out.println("[DAEMON]  " + spoolQueue.size() + " jobs in queue.\n");

        while (!spoolQueue.isEmpty()) {
            PrintJob nextJob = spoolQueue.poll(); // Always returns highest-priority job
            System.out.printf("[PRINT]   Processing %s%n", nextJob);
            Thread.sleep(300); // Simulate print time
            System.out.printf("[DONE]    Finished   %s%n%n", nextJob);
        }
        System.out.println("[DAEMON]  Spool queue empty. Printer going idle.");
    }

    public static void main(String[] args) throws InterruptedException {
        PrioritySpooler spooler = new PrioritySpooler();

        // Multiple users submit jobs — all at roughly the same time
        System.out.println("=== JOBS BEING SUBMITTED TO SPOOL ===");
        spooler.submitJob("bob",   "FinancialReport.xlsx",  3); // Normal
        spooler.submitJob("alice", "BoardPresentation.pptx", 1); // URGENT
        spooler.submitJob("carol", "LunchMenu.docx",         5); // Low priority
        spooler.submitJob("admin", "SecurityPolicy.pdf",     1); // Also urgent
        spooler.submitJob("bob",   "MeetingAgenda.docx",     2); // High priority

        // Now the daemon processes them — order depends on priority, not submission order
        spooler.drainAndPrint();
    }
}

// io.thecodeforge — cs-fundamentals tutorial

import shutil
import time
import logging
from pathlib import Path

SPOOL_PATH = Path('/var/spool/print')
WARN_PERCENT = 70.0
CRIT_PERCENT = 90.0
CHECK_INTERVAL = 60  # seconds

logging.basicConfig(level=logging.INFO)

def check_spool_disk():
    usage = shutil.disk_usage(SPOOL_PATH)
    used_pct = (usage.used / usage.total) * 100

    if used_pct >= CRIT_PERCENT:
        logging.critical(f"Spool disk at {used_pct:.1f}%% — deadlock imminent")
        # Trigger alert: PagerDuty, email, carrier pigeon
    elif used_pct >= WARN_PERCENT:
        logging.warning(f"Spool disk at {used_pct:.1f}%% — drain jobs")
    else:
        logging.info(f"Spool disk healthy: {used_pct:.1f}%%")

while True:
    check_spool_disk()
    time.sleep(CHECK_INTERVAL)

// io.thecodeforge — cs-fundamentals tutorial

from dataclasses import dataclass, field
from typing import List

@dataclass
class SpoolJob:
    pid: int
    owner: str
    pages: int
    priority: int = 0

class SpoolQueue:
    def __init__(self, algorithm='fcfs'):
        self.jobs: List[SpoolJob] = []
        self.algorithm = algorithm

    def enqueue(self, job: SpoolJob):
        if self.algorithm == 'sjf':
            # Sort by pages ascending for Shortest Job First
            self.jobs.append(job)
            self.jobs.sort(key=lambda j: j.pages)
        else:
            self.jobs.append(job)

    def dequeue(self) -> SpoolJob:
        return self.jobs.pop(0) if self.jobs else None

    def __len__(self):
        return len(self.jobs)

# Production scenario: 3 jobs enqueued
tasks = SpoolQueue(algorithm='sjf')
tasks.enqueue(SpoolJob(pid=101, owner='alice', pages=200))
tasks.enqueue(SpoolJob(pid=102, owner='bob', pages=5))
tasks.enqueue(SpoolJob(pid=103, owner='carol', pages=50))

while tasks:
    job = tasks.dequeue()
    print(f"Printing {job.pages} pages for {job.owner} (pid={job.pid})")

// io.thecodeforge — cs-fundamentals tutorial

import threading, time, queue

def cpu_producer(spool_queue, job_count):
    for i in range(job_count):
        print(f"CPU: generating job {i}")
        spool_queue.put(f"print_job_{i}")
        # CPU doesn't wait for printer — it's free immediately
    spool_queue.put(None)  # sentinel

def printer_consumer(spool_queue):
    while True:
        job = spool_queue.get()
        if job is None:
            break
        print(f"Printer: processing {job} (takes 2s)")
        time.sleep(2)
        print(f"Printer: {job} done")

q = queue.Queue()
t1 = threading.Thread(target=cpu_producer, args=(q, 3))
t2 = threading.Thread(target=printer_consumer, args=(q,))
t1.start(); t2.start()
t1.join(); t2.join()
print("All done — CPU never waited on printer")

// io.thecodeforge — cs-fundamentals tutorial

import os, tempfile, time

class Spooler:
    def __init__(self, max_jobs=5, buffer_size=1024):
        self.max_jobs = max_jobs
        self.buffer_size = buffer_size
        self.spool_dir = tempfile.mkdtemp()
        self.job_count = 0

    def enqueue(self, data):
        if self.job_count >= self.max_jobs:
            print("Spool full — rejecting job")
            return False
        # Buffer: write directly to disk at memory speed
        with open(f"{self.spool_dir}/job_{self.job_count}", "wb") as f:
            f.write(data.encode())
        self.job_count += 1
        print(f"Buffered + Queued job_{self.job_count-1}")
        return True

    def drain(self):
        for i in range(self.job_count):
            # Queue: process in FIFO order
            with open(f"{self.spool_dir}/job_{i}", "rb") as f:
                data = f.read()
            time.sleep(0.5)  # simulate slow device
            print(f"Processed job_{i}: {len(data)} bytes")

s = Spooler(max_jobs=3)
s.enqueue("A" * 512)
s.enqueue("B" * 256)
s.enqueue("C" * 128)
s.enqueue("D" * 64)  # This will be rejected
s.drain()

// io.thecodeforge — cs-fundamentals tutorial

import threading, time

spool = []  // shared list, unsafe

def print_job(job_id):
    global spool
    temp = spool[:]  // race window
    temp.append(f"Job-{job_id}")
    time.sleep(0.001)  // imitates context switch
    spool = temp  // overwrites other writes

t1 = threading.Thread(target=print_job, args=(1,))
t2 = threading.Thread(target=print_job, args=(2,))
t1.start(); t2.start()
t1.join(); t2.join()
print(spool)  // output: may lose one job

// io.thecodeforge — cs-fundamentals tutorial

import threading, time

mutex = threading.Lock()
empty_slots = threading.Semaphore(3)  // max 3 queued
spool = []

def produce(job):
    empty_slots.acquire()
    with mutex:
        spool.append(job)
        print(f"Queued {job}")

def consume():
    while True:
        with mutex:
            if not spool:
                break
            job = spool.pop(0)
        time.sleep(0.1)  // print time
        print(f"Printed {job}")
        empty_slots.release()

t1 = threading.Thread(target=produce, args=("Invoice",))
t2 = threading.Thread(target=produce, args=("Report",))
c = threading.Thread(target=consume, daemon=True)
t1.start(); t2.start(); c.start()