forklifter 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,5 @@
+source :rubygems
+
+# Specify your gem's dependencies in forklift.gemspec
+gemspec
+

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Ivan Vanderbyl
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# Forklift
+
+Forklift is a process manager with middleware allowing it to be used for building a multitude of background
+processing applications. It can be controlled using AMQP, has process managing and reporting over AMQP,
+autoscaling based on machine usage, pure unix forking model, socket based IPC, and an auto-healing highly redundent design.
+
+_The design goal is to be the perfect replacement for Resque, Sidekiq, and the like._
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'forklift'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install forklift
+
+## Usage
+
+    $ forklift help
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Author
+
+- [Ivan Vanderbyl](http://twitter.com/ivanvanderbyl)
+
+

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/forklift

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# resolve bin path, ignoring symlinks
+require "pathname"
+bin_file = Pathname.new(__FILE__).realpath
+
+# add self to libpath
+$:.unshift File.expand_path("../../lib", bin_file)
+
+# require "bundler"
+# Bundler.setup
+
+require "forklift/ui"
+
+# start up the CLI
+Forklift::UI.start

data/forklift.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/forklift/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Ivan Vanderbyl"]
+  gem.email         = ["ivanvanderbyl@me.com"]
+  gem.description   = %q{Forklift is a preforking, autoscaling process manager for building background processing applications}
+  gem.summary       = %q{"Unicorn for background processing"}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "forklifter"
+  gem.require_paths = ["lib"]
+  gem.version       = Forklift::VERSION
+
+  gem.add_dependency 'activesupport', '~> 3.2.0'
+  gem.add_dependency 'thor'
+  gem.add_dependency 'eventmachine'
+  gem.add_dependency 'kgio'
+end

data/lib/forklift.rb

@@ -0,0 +1,18 @@
+require 'fcntl'
+require 'etc'
+require 'stringio'
+require 'kgio'
+require 'eventmachine'
+
+module Forklift
+  autoload :VERSION, 'forklift/version'
+  autoload :Master, 'forklift/master'
+  autoload :Worker, 'forklift/worker'
+
+  def self.log_error(logger, prefix, exc)
+    message = exc.message
+    message = message.dump if /[[:cntrl:]]/ =~ message
+    logger.error "#{prefix}: #{message} (#{exc.class})"
+    exc.backtrace.each { |line| logger.error(line) }
+  end
+end

data/lib/forklift/master.rb

@@ -0,0 +1,296 @@
+require "logger"
+require "socket"
+
+module Forklift
+  class Master
+
+    # This hash maps PIDs to Workers
+    WORKERS = {}
+
+    attr_reader :pid, :logger
+    attr_accessor :worker_processes, :master_pid, :reexec_pid, :timeout
+
+    SELF_PIPE = []
+
+    # signal queue used for self-piping
+    SIG_QUEUE = []
+
+    # list of signals we care about and trap in master.
+    QUEUE_SIGS = [ :WINCH, :QUIT, :INT, :TERM, :USR1, :USR2, :HUP, :TTIN, :TTOU ]
+
+    START_CTX = {
+      :argv => ARGV.map { |arg| arg.dup },
+      0 => $0.dup,
+    }
+    # We favor ENV['PWD'] since it is (usually) symlink aware for Capistrano
+    # and like systems
+    START_CTX[:cwd] = begin
+      a = File.stat(pwd = ENV['PWD'])
+      b = File.stat(Dir.pwd)
+      a.ino == b.ino && a.dev == b.dev ? pwd : Dir.pwd
+    rescue
+      Dir.pwd
+    end
+
+    def initialize
+      self.reexec_pid = 0
+      self.worker_processes = 2
+      @logger = Logger.new($stdout)
+      @timeout = 100
+    end
+
+    def start
+      init_self_pipe!
+      # setup signal handlers before writing pid file in case people get
+      # trigger happy and send signals as soon as the pid file exists.
+      # Note that signals don't actually get handled until the #join method
+      QUEUE_SIGS.each { |sig| trap(sig) { SIG_QUEUE << sig; awaken_master } }
+      trap(:CHLD) { awaken_master }
+
+      self.master_pid = $$
+
+      logger.info "Starting master"
+
+      spawn_missing_workers
+
+      self
+    end
+
+    def join
+      respawn = true
+      last_check = Time.now
+
+      proc_name 'master'
+      logger.info "master process ready" # test_exec.rb relies on this message
+      if @ready_pipe
+        @ready_pipe.syswrite($$.to_s)
+        @ready_pipe = @ready_pipe.close rescue nil
+      end
+
+      begin
+        reap_all_workers
+
+        case SIG_QUEUE.shift
+        when nil
+          # avoid murdering workers after our master process (or the
+          # machine) comes out of suspend/hibernation
+          if (last_check + @timeout) >= (last_check = Time.now)
+            sleep_time = murder_lazy_workers
+          else
+            sleep_time = @timeout/2.0 + 1
+            @logger.debug("waiting #{sleep_time}s after suspend/hibernation")
+          end
+          maintain_worker_count if respawn
+          master_sleep(sleep_time)
+
+        when :QUIT # graceful shutdown
+          break
+        when :TERM, :INT # immediate shutdown
+          stop(false)
+          break
+        when :USR1 # rotate logs
+          logger.info "master done reopening logs"
+          kill_each_worker(:USR1)
+        when :USR2 # exec binary, stay alive in case something went wrong
+          # reexec
+        end
+
+      rescue => e
+        Forklift.log_error(@logger, "master loop error", e)
+      end while true
+
+      stop # gracefully shutdown all workers on our way out
+      logger.info "master complete"
+      unlink_pid_safe(pid) if pid
+    end
+
+    private
+
+    # wait for a signal hander to wake us up and then consume the pipe
+    def master_sleep(sec)
+      IO.select([ SELF_PIPE[0] ], nil, nil, sec) or return
+      SELF_PIPE[0].kgio_tryread(11)
+    end
+
+    def awaken_master
+      SELF_PIPE[1].kgio_trywrite('.') # wakeup master process from select
+    end
+
+    def worker_loop(worker)
+      ppid = master_pid
+      init_worker_process(worker)
+
+      logger.info "worker=#{worker.number} ready"
+
+      begin
+        nr = 0
+        worker.tick = Time.now.to_i
+
+        worker.perform
+
+        ppid == Process.ppid or return
+
+        # timeout used so we can detect parent death:
+        worker.tick = Time.now.to_i
+        # ret = IO.select(l, nil, SELF_PIPE, @timeout) and ready = ret[0]
+      rescue => e
+        redo if nr < 0 && (Errno::EBADF === e || IOError === e) # reopen logs
+        Forklift.log_error(@logger, "listen loop error", e) if worker
+        exit
+      end while worker
+    end
+
+    EXIT_SIGS = [ :QUIT, :TERM, :INT ]
+    WORKER_QUEUE_SIGS = QUEUE_SIGS - EXIT_SIGS
+
+    # gets rid of stuff the worker has no business keeping track of
+    # to free some resources and drops all sig handlers.
+    # traps for USR1, USR2, and HUP may be set in the after_fork Proc
+    # by the user.
+    def init_worker_process(worker)
+      # we'll re-trap :QUIT later for graceful shutdown iff we accept clients
+      EXIT_SIGS.each { |sig| trap(sig) { exit!(0) } }
+      exit!(0) if (SIG_QUEUE & EXIT_SIGS)[0]
+      WORKER_QUEUE_SIGS.each { |sig| trap(sig, nil) }
+      trap(:CHLD, 'DEFAULT')
+      SIG_QUEUE.clear
+      proc_name "worker[#{worker.number}]"
+      START_CTX.clear
+      init_self_pipe!
+      WORKERS.clear
+      # after_fork.call(self, worker) # can drop perms
+      # worker.user(*user) if user.kind_of?(Array) && ! worker.switched
+      self.timeout /= 2.0 # halve it for select()
+      @config = nil
+      @after_fork = @listener_opts = @orig_app = nil
+    end
+
+    def spawn_missing_workers
+      worker_nr = -1
+      until (worker_nr += 1) == self.worker_processes
+        WORKERS.value?(worker_nr) and next
+        worker = Worker.new(logger, worker_nr)
+        # before_fork.call(self, worker)
+        if pid = fork
+          WORKERS[pid] = worker
+        else
+          worker_loop(worker)
+          exit
+        end
+      end
+    rescue => e
+      @logger.error(e) rescue nil
+      exit!
+    end
+
+    def maintain_worker_count
+      (off = WORKERS.size - worker_processes) == 0 and return
+      off < 0 and return spawn_missing_workers
+      WORKERS.dup.each_pair { |wpid,w|
+        w.number >= worker_processes and kill_worker(:QUIT, wpid) rescue nil
+      }
+    end
+
+    # forcibly terminate all workers that haven't checked in in timeout seconds.  The timeout is implemented using an unlinked File
+    def murder_lazy_workers
+      next_sleep = @timeout - 1
+      now = Time.now.to_i
+      WORKERS.dup.each_pair do |wpid, worker|
+        tick = worker.tick
+        0 == tick and next # skip workers that haven't processed any clients
+        diff = now - tick
+        tmp = @timeout - diff
+        if tmp >= 0
+          next_sleep > tmp and next_sleep = tmp
+          next
+        end
+        next_sleep = 0
+        logger.error "worker=#{worker.number} PID:#{wpid} timeout " \
+                     "(#{diff}s > #{@timeout}s), killing"
+        kill_worker(:KILL, wpid) # take no prisoners for timeout violations
+      end
+      next_sleep <= 0 ? 1 : next_sleep
+    end
+
+    def proc_name(tag)
+      $0 = tag
+      # $0 = ([ File.basename(START_CTX[0]), tag
+      #       ]).concat(START_CTX[:argv]).join(' ')
+    end
+
+    def redirect_io(io, path)
+      File.open(path, 'ab') { |fp| io.reopen(fp) } if path
+      io.sync = true
+    end
+
+    # Terminates all workers, but does not exit master process
+    def stop(graceful = true)
+      limit = Time.now + timeout
+      until WORKERS.empty? || Time.now > limit
+        kill_each_worker(graceful ? :QUIT : :TERM)
+        sleep(0.1)
+        reap_all_workers
+      end
+      kill_each_worker(:KILL)
+    end
+
+    # delivers a signal to a worker and fails gracefully if the worker
+    # is no longer running.
+    def kill_worker(signal, wpid)
+      Process.kill(signal, wpid)
+      rescue Errno::ESRCH
+        worker = WORKERS.delete(wpid) and worker.close rescue nil
+    end
+
+    # delivers a signal to each worker
+    def kill_each_worker(signal)
+      WORKERS.keys.each { |wpid| kill_worker(signal, wpid) }
+    end
+
+    def init_self_pipe!
+      SELF_PIPE.each { |io| io.close rescue nil }
+      SELF_PIPE.replace(Kgio::Pipe.new)
+      SELF_PIPE.each { |io| io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
+    end
+
+    # reaps all unreaped workers
+    def reap_all_workers
+      begin
+        wpid, status = Process.waitpid2(-1, Process::WNOHANG)
+        wpid or return
+        if reexec_pid == wpid
+          logger.error "reaped #{status.inspect} exec()-ed"
+          self.reexec_pid = 0
+          self.pid = pid.chomp('.oldbin') if pid
+          proc_name 'master'
+        else
+          worker = WORKERS.delete(wpid) and worker.close rescue nil
+          m = "reaped #{status.inspect} worker=#{worker.number rescue 'unknown'}"
+          status.success? ? logger.info(m) : logger.error(m)
+        end
+      rescue Errno::ECHILD
+        break
+      end while true
+    end
+
+    # unlinks a PID file at given +path+ if it contains the current PID
+    # still potentially racy without locking the directory (which is
+    # non-portable and may interact badly with other programs), but the
+    # window for hitting the race condition is small
+    def unlink_pid_safe(path)
+      (File.read(path).to_i == $$ and File.unlink(path)) rescue nil
+    end
+
+    # returns a PID if a given path contains a non-stale PID file,
+    # nil otherwise.
+    def valid_pid?(path)
+      wpid = File.read(path).to_i
+      wpid <= 0 and return
+      Process.kill(0, wpid)
+      wpid
+      rescue Errno::ESRCH, Errno::ENOENT
+        # don't unlink stale pid files, racy without non-portable locking...
+    end
+
+  end
+end

data/lib/forklift/master_old.rb

@@ -0,0 +1,257 @@
+require "logger"
+
+module Forklift
+  class Master
+    attr_accessor :app, :timeout, :worker_processes,
+                :before_fork, :after_fork, :before_exec,
+                :listener_opts, :preload_app,
+                :reexec_pid, :orig_app, :init_listeners,
+                :master_pid, :config, :ready_pipe, :user
+
+    attr_reader :pid, :logger
+
+    # This hash maps PIDs to Workers
+    WORKERS = {}
+
+    SELF_PIPE = []
+
+    # signal queue used for self-piping
+    SIG_QUEUE = []
+
+    # list of signals we care about and trap in master.
+    QUEUE_SIGS = [ :WINCH, :QUIT, :INT, :TERM, :USR1, :USR2, :HUP, :TTIN, :TTOU ]
+
+    START_CTX = {
+      :argv => ARGV.map { |arg| arg.dup },
+      0 => $0.dup,
+    }
+    # We favor ENV['PWD'] since it is (usually) symlink aware for Capistrano
+    # and like systems
+    START_CTX[:cwd] = begin
+      a = File.stat(pwd = ENV['PWD'])
+      b = File.stat(Dir.pwd)
+      a.ino == b.ino && a.dev == b.dev ? pwd : Dir.pwd
+    rescue
+      Dir.pwd
+    end
+
+    def initialize
+      self.reexec_pid = 0
+    end
+
+    def start
+      # this pipe is used to wake us up from select(2) in #join when signals
+      # are trapped.  See trap_deferred.
+      init_self_pipe!
+
+      # setup signal handlers before writing pid file in case people get
+      # trigger happy and send signals as soon as the pid file exists.
+      # Note that signals don't actually get handled until the #join method
+      QUEUE_SIGS.each { |sig| trap(sig) { SIG_QUEUE << sig; awaken_master } }
+      trap(:CHLD) { awaken_master }
+
+      self.master_pid = $$
+
+      @logger = Logger.new($stdout)
+      @timeout = 10
+
+      logger.info "Starting master"
+
+      @worker_processes = 2
+
+      spawn_missing_workers
+
+      self
+    end
+
+    # monitors children and receives signals forever
+    # (or until a termination signal is sent).  This handles signals
+    # one-at-a-time time and we'll happily drop signals in case somebody
+    # is signalling us too often.
+    def join
+      respawn = true
+      last_check = Time.now
+
+      proc_name 'master'
+      logger.info "master process ready" # test_exec.rb relies on this message
+
+      if @ready_pipe
+        @ready_pipe.syswrite($$.to_s)
+        @ready_pipe = @ready_pipe.close rescue nil
+      end
+
+      begin
+        reap_all_workers
+
+        case SIG_QUEUE.shift
+        when nil
+
+        when :QUIT # graceful shutdown
+          break
+        when :TERM, :INT # immediate shutdown
+          stop(false)
+          break
+        when :USR1 # rotate logs
+          logger.info "master done reopening logs"
+          kill_each_worker(:USR1)
+        when :USR2 # exec binary, stay alive in case something went wrong
+          reexec
+        end
+
+      rescue => e
+        Forklift.log_error(@logger, "master loop error", e)
+      end while true
+    end
+
+    private
+
+    def worker_loop(worker)
+      ppid = master_pid
+      ppid = master_pid
+      init_worker_process(worker)
+      nr = 0 # this becomes negative if we need to reopen logs
+      # ready = l.dup
+
+      # closing anything we IO.select on will raise EBADF
+      trap(:USR1) { nr = -65536; SELF_PIPE[0].close rescue nil }
+      trap(:QUIT) { worker = nil; LISTENERS.each { |s| s.close rescue nil }.clear }
+      logger.info "worker=#{worker.nr} ready"
+
+      begin
+        nr < 0 and reopen_worker_logs(worker.nr)
+        nr = 0
+
+        logger.info "Working"
+
+        EM.run {
+
+        }
+
+        ppid == Process.ppid or return
+
+        # timeout used so we can detect parent death:
+        # ret = IO.select(l, nil, SELF_PIPE, @timeout) and ready = ret[0]
+
+      rescue => e
+        redo if nr < 0 && (Errno::EBADF === e || IOError === e) # reopen logs
+        Forklift.log_error(@logger, "listen loop error", e) if worker
+        exit
+      end while worker
+    end
+
+    EXIT_SIGS = [ :QUIT, :TERM, :INT ]
+    WORKER_QUEUE_SIGS = QUEUE_SIGS - EXIT_SIGS
+
+    # gets rid of stuff the worker has no business keeping track of
+    # to free some resources and drops all sig handlers.
+    # traps for USR1, USR2, and HUP may be set in the after_fork Proc
+    # by the user.
+    def init_worker_process(worker)
+      # we'll re-trap :QUIT later for graceful shutdown iff we accept clients
+      EXIT_SIGS.each { |sig| trap(sig) { exit!(0) } }
+      exit!(0) if (SIG_QUEUE & EXIT_SIGS)[0]
+      WORKER_QUEUE_SIGS.each { |sig| trap(sig, nil) }
+      trap(:CHLD, 'DEFAULT')
+      SIG_QUEUE.clear
+      proc_name "worker[#{worker.nr}]"
+      START_CTX.clear
+      init_self_pipe!
+      WORKERS.clear
+      # after_fork.call(self, worker) # can drop perms
+      # worker.user(*user) if user.kind_of?(Array) && ! worker.switched
+      self.timeout /= 2.0 # halve it for select()
+      @config = nil
+      @after_fork = @listener_opts = @orig_app = nil
+    end
+
+    def spawn_missing_workers
+      worker_nr = -1
+      until (worker_nr += 1) == @worker_processes
+        WORKERS.value?(worker_nr) and next
+        worker = Worker.new(worker_nr)
+        # before_fork.call(self, worker)
+        if pid = fork
+          WORKERS[pid] = worker
+        else
+          after_fork_internal
+          worker_loop(worker)
+          exit
+        end
+      end
+    rescue => e
+      @logger.error(e) rescue nil
+      exit!
+    end
+
+
+    def after_fork_internal
+      @ready_pipe.close if @ready_pipe
+      @ready_pipe = @init_listeners = @before_exec = @before_fork = nil
+
+      srand # http://redmine.ruby-lang.org/issues/4338
+
+      # The OpenSSL PRNG is seeded with only the pid, and apps with frequently
+      # dying workers can recycle pids
+      OpenSSL::Random.seed(rand.to_s) if defined?(OpenSSL::Random)
+    end
+
+    # wait for a signal hander to wake us up and then consume the pipe
+    def master_sleep(sec)
+      IO.select([ SELF_PIPE[0] ], nil, nil, sec) or return
+      SELF_PIPE[0].kgio_tryread(11)
+    end
+
+    def awaken_master
+      SELF_PIPE[1].kgio_trywrite('.') # wakeup master process from select
+    end
+
+    def proc_name(tag)
+      $0 = ([ File.basename(START_CTX[0]), tag
+            ]).concat(START_CTX[:argv]).join(' ')
+    end
+
+    def redirect_io(io, path)
+      File.open(path, 'ab') { |fp| io.reopen(fp) } if path
+      io.sync = true
+    end
+
+    def init_self_pipe!
+      SELF_PIPE.each { |io| io.close rescue nil }
+      SELF_PIPE.replace(Kgio::Pipe.new)
+      SELF_PIPE.each { |io| io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
+    end
+
+    # delivers a signal to a worker and fails gracefully if the worker
+    # is no longer running.
+    def kill_worker(signal, wpid)
+      Process.kill(signal, wpid)
+      rescue Errno::ESRCH
+        worker = WORKERS.delete(wpid) and worker.close rescue nil
+    end
+
+    # delivers a signal to each worker
+    def kill_each_worker(signal)
+      WORKERS.keys.each { |wpid| kill_worker(signal, wpid) }
+    end
+
+    # unlinks a PID file at given +path+ if it contains the current PID
+    # still potentially racy without locking the directory (which is
+    # non-portable and may interact badly with other programs), but the
+    # window for hitting the race condition is small
+    def unlink_pid_safe(path)
+      (File.read(path).to_i == $$ and File.unlink(path)) rescue nil
+    end
+
+    # returns a PID if a given path contains a non-stale PID file,
+    # nil otherwise.
+    def valid_pid?(path)
+      wpid = File.read(path).to_i
+      wpid <= 0 and return
+      Process.kill(0, wpid)
+      wpid
+      rescue Errno::ESRCH, Errno::ENOENT
+        # don't unlink stale pid files, racy without non-portable locking...
+    end
+
+  end
+end

data/lib/forklift/ui.rb

@@ -0,0 +1,40 @@
+require 'thor'
+require 'thor/group'
+require 'fileutils'
+require 'pathname'
+
+require "forklift"
+
+module Forklift
+  class UI < ::Thor
+    map "-T" => :list, "-v" => :version
+
+    # If a task is not found on Thor::Runner, method missing is invoked and
+    # Thor::Runner is then responsable for finding the task in all classes.
+    #
+    def method_missing(meth, *args)
+      meth = meth.to_s
+      klass, task = Thor::Util.find_class_and_task_by_namespace(meth)
+      args.unshift(task) if task
+      klass.start(args, :shell => self.shell)
+    end
+
+    def self.banner(task, all = false, subcommand = false)
+      "forklift " + task.formatted_usage(self, all, subcommand)
+    end
+
+    desc :start, "Start master"
+    def start
+      Forklift::Master.new.start.join
+    end
+
+    class Remote < Thor
+      namespace :remote
+
+      desc "#{namespace}:start", "Start"
+      def start
+        puts "Start"
+      end
+    end
+  end
+end

data/lib/forklift/version.rb

@@ -0,0 +1,3 @@
+module Forklift
+  VERSION = "0.0.1"
+end

data/lib/forklift/worker.rb

@@ -0,0 +1,41 @@
+module Forklift
+  class Worker
+
+    attr_reader :number, :logger
+
+    def initialize(logger, number)
+      @i = 0
+      @number = number
+      @tick = Time.now.to_i
+      @logger = logger
+      logger.debug "Worker #{number} spawned"
+    end
+
+    # worker objects may be compared to just plain Integers
+    def ==(other_nr) # :nodoc:
+      @number == other_nr
+    end
+
+    def tick=(int)
+      @tick = int
+    end
+
+    def tick
+      @tick
+    end
+
+    def nr
+      @number
+    end
+
+    def close # :nodoc:
+      @tmp.close if @tmp
+    end
+
+    def perform
+      @i += 1
+      logger.info "Working #{@i}"
+      sleep 5
+    end
+  end
+end

data/play/pipes.rb

@@ -0,0 +1,12 @@
+reader, writer = IO.pipe
+fork do
+  reader.close
+  10.times do
+    # heavy lifting
+    writer.puts "Another one bites the dust"
+  end
+end
+writer.close
+while message = reader.gets
+  $stdout.puts message
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: forklifter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ivan Vanderbyl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70179603660300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70179603660300
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: &70179603659880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70179603659880
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &70179603659420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70179603659420
+- !ruby/object:Gem::Dependency
+  name: kgio
+  requirement: &70179603659000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70179603659000
+description: Forklift is a preforking, autoscaling process manager for building background
+  processing applications
+email:
+- ivanvanderbyl@me.com
+executables:
+- forklift
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/forklift
+- forklift.gemspec
+- lib/forklift.rb
+- lib/forklift/master.rb
+- lib/forklift/master_old.rb
+- lib/forklift/ui.rb
+- lib/forklift/version.rb
+- lib/forklift/worker.rb
+- play/pipes.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: ! '"Unicorn for background processing"'
+test_files: []