DRb as a server for long-running web processes: creating a website in Ruby that is responsive and progressive.

get '/start' do
  @result = do_long_running_thing()
  haml :results
end

require 'sinatra'
require 'haml'
require 'drb'
require 'json'

DRBSERVER = 'druby://localhost:9001'
MCP = DRbObject.new_with_uri(DRBSERVER)

class MyServer < Sinatra::Application
  set :haml, :format => :html5

  get '/' do
    @title = "Welcome to the MCP"
    @finished,@running = MCP.processes.partition{ |o| o[:results] }
    haml :home
  end

  get '/start' do
    @process_id = MCP.start_new_long_running_thingy
    @title = "Process ##{@process_id} Running"
    haml :start
  end

  get '/status' do
    content_type :json
    MCP.status_for(params[:process_id].to_i).to_json
  end

  get '/results/:process_id' do
    @title = "Results for Process ##{params[:process_id]}"
    @results = MCP.results_for( params[:process_id].to_i )
    haml :results
  end
end

require 'drb'
require 'thread'

DRBSERVER = 'druby://localhost:9001'

module MasterControlProgram
  @scheduler = Mutex.new
  @process_by_id = {}
  def self.start_new_long_running_thingy
    @process_by_id.length.tap do |process_id|
      process = Process.new
      @process_by_id[process_id] = process
      process.go
    end
  end

  def self.status_for( process_id )
    if process = @process_by_id[process_id]
      process.status 
    end
  end

  def self.results_for( process_id )
    if process = @process_by_id[process_id]
      process.results 
    end
  end

  def self.processes
    @process_by_id.map do |id,process|
      if r = process.results
        { id: id, results: r }
      else
        { id: id, status: process.status }
      end
    end
  end
end

class MasterControlProgram::Process
  attr_reader :results
  def initialize
    @percent_done = 0.0
    @status = :starting
    @results = nil
    @data_accessor = Mutex.new
    @start = Time.now
  end

  def status
    # Ensure that nobody is changing the status while we read it
    @data_accessor.synchronize do
      { percent_done: @percent_done, status: @status }
    end
  end

  def go
    # silly simulation of process
    # will take on average 10 seconds to complete
    states = %w[ globbing_dirs aggregating_data undermixing_signals
                 damping_transients detecting_resonances
                 emptying_buffers computing_final_result ].map(&:to_sym)
    Thread.new do
      until @percent_done >= 1.0
        sleep rand * 1
        # Ensure that nobody is reading the status while we change it
        @data_accessor.synchronize do
          @status = states[ (states.length * @percent_done).floor ]
          @percent_done += rand * 0.03
        end
      end
      @data_accessor.synchronize do
        @percent_done = 1.0
        @status = :complete
      end
      @results = {
        signal_strength: [:excellent,:moderate,:poor].sample,
        score: rand * 100
      }
    end
  end
end

DRb.start_service( DRBSERVER, MasterControlProgram )
DRb.thread.join

# This Rackup file helps start the web server from `thin start`
# if you are using Thin (or another Rack-based web server)
require ::File.join( ::File.dirname(__FILE__), 'webserver' )
run MyServer.new

MCP = DRbObject.new_with_uri(DRBSERVER)