Building a Go-Powered Industrial Scheduling System with FSM, Saga, and WAL

01 Core Architecture: Giving the Factory a "Brain"

The system consists of three core components that mirror factory departments:

Workflow Engine – defines the production steps (e.g., material loading → assembly → quality check → unloading) and acts as the production line's instruction manual.

Scheduler – distributes tasks, decides execution order, and serves as the factory's commander.

Station – concrete nodes that simulate physical equipment and perform the actual work.

Why Choose Go?

Industrial scenarios demand extremely high concurrency and real‑time performance. Go's native goroutine and channel mechanisms are tailor‑made for high‑throughput pipelines.

02 Pain Point 1: VIP Orders Need to Jump the Queue

In a FIFO queue, a sudden high‑priority order can cause massive penalties if it gets stuck behind thousands of regular orders.

Solution: Priority Queue

Using Go's standard container/heap package, we implement a max‑heap that orders tasks by priority.

// Core snippet: let VIP orders take the fast lane
func (pq PriorityQueue) Less(i, j int) bool {
    // Higher priority comes first!
    return pq[i].Product.Priority > pq[j].Product.Priority
}

// Scheduler logic
func (s *Scheduler) SubmitTask(p *types.Product) {
    s.mu.Lock()
    heap.Push(&s.pq, &Item{Product: p}) // Auto‑sort on push
    s.cond.Signal()                  // Wake up idle workers
    s.mu.Unlock()
}

Effect: Even if regular orders form a long queue, a newly submitted VIP order is dispatched to the next free station immediately.

03 Pain Point 2: Faulty Quality Check Requires Rollback

When a product fails quality inspection after several upstream steps, the factory must reverse the work, record the issue, and possibly recycle components.

Solution: Saga Transaction Pattern + FSM State Machine

In distributed systems, Saga handles long‑running transactions. Here it guarantees eventual consistency, while an FSM precisely tracks each product's lifecycle (e.g., PROCESSING → QUALITY_CHECK → FAILED).

// Core logic of the workflow engine
func (e *WorkflowEngine) Process(p *types.Product) {
    // Initialize FSM
    productFSM := fsm.NewFSM(p.ID)
    _ = productFSM.Fire(fsm.EventStart) // CREATED → PROCESSING

    for _, step := range sequence {
        // ... execute step ...
        if !res.Success {
            _ = productFSM.Fire(fsm.EventFail) // → FAILED
            // Trigger compensation and rollback
            e.rollback(executedStations, p, productFSM)
            return
        }
    }
    _ = productFSM.Fire(fsm.EventFinish) // → COMPLETED
}

This provides both code‑level rollback and a physical‑world "undo" mechanism.

04 Pain Point 3: Parallelism Over Serial Execution

Modern factories can perform many steps in parallel (e.g., chassis assembly while the body is being painted).

Solution: Abstract Stations as Interfaces and Use Concurrent Orchestration

We define Station as an interface and employ Go's sync.WaitGroup to run stations concurrently.

// executeStep runs a single step with parallel stations
func (e *WorkflowEngine) executeStep(step types.WorkflowStep, p *types.Product) {
    var wg sync.WaitGroup
    for _, sID := range step.StationIDs {
        wg.Add(1)
        go func(s station.Station) {
            defer wg.Done()
            s.Execute(p) // Concurrent execution!
        }(st)
    }
    wg.Wait() // Wait for all parallel stations to finish
}

This design boosts throughput and decouples station implementations, paving the way for future hardware integration.

05 Pain Point 4: System Crash Leads to Data Loss

Power outages or server crashes can erase in‑memory queues, causing catastrophic loss of pending orders.

Solution: Write‑Ahead Logging (WAL) Persistence

Inspired by databases, we log each task to disk before placing it in the in‑memory queue. On restart, the scheduler replays the log to recover unfinished tasks.

// Submit task: write log first, then enqueue
func (s *Scheduler) SubmitTask(p *types.Product) {
    if err := s.wal.Append(p); err != nil {
        // handle error
    }
    heap.Push(&s.pq, &Item{Product: p})
}

// Recover tasks on startup
func (s *Scheduler) RecoverTasks() {
    tasks := s.wal.Recover()
    for _, p := range tasks {
        heap.Push(&s.pq, &Item{Product: p})
    }
}

06 Summary and Outlook

The demo revisits Go's concurrency model and showcases its potential in real‑world industrial automation.

Priority Queue – balances fairness and efficiency in resource allocation.

Saga + FSM – provides fault tolerance and precise state management for long processes.

Concurrent Orchestration – improves production efficiency and decouples station logic.

WAL Persistence – ensures data reliability across crashes.

Prometheus Monitoring – offers clear visibility into system health.

The full source code is available in the associated GitHub repository, enabling further exploration of Go in IoT and Industry 4.0 contexts.