fate 0.2.3 → 0.2.6

data/bin/fate

@@ -6,8 +6,8 @@ require "json"
 
 # set up loadpath
 here = File.dirname(__FILE__)
-SPAWN_CONTROL_ROOT = File.expand_path("#{here}/..")
-$LOAD_PATH.unshift("#{SPAWN_CONTROL_ROOT}/lib")
+FATE_ROOT = File.expand_path("#{here}/..")
+$LOAD_PATH.unshift("#{FATE_ROOT}/lib")
 
 require "fate"
 
@@ -25,14 +25,14 @@ end.parse!
 
 string = File.read(options[:configuration])
 configuration = JSON.parse(string, :symbolize_names => true)
-spawner = Fate.new(configuration)
+fate = Fate.new(configuration)
 
 trap("INT") do
   exit
 end
 
-require "fate/console"
-spawner.start
-spawner.console
+require "fate/repl"
+fate.start
+fate.repl
 
 

data/lib/fate.rb

@@ -5,193 +5,122 @@ gem "squeeze"
 require "term/ansicolor"
 require "squeeze/hash_tree"
 
-# Cross-VM compatibility
-# thanks to http://ku1ik.com/2010/09/18/open3-and-the-pid-of-the-spawn.html
-# TODO: consider using systemu: https://github.com/ahoward/systemu/
-if IO.respond_to?(:popen4)
-  def open4(*args)
-    IO.popen4(*args)
-  end
-else
-  require 'open4'
-end
+require "fate/formatter"
+require "fate/manager"
+
+Thread.abort_on_exception = true
 
 class Fate
+  include Formatter
 
-  def self.start(configuration, &block)
-    self.new(configuration).start(&block)
+  def self.start(specification, &block)
+    self.new(specification).start(&block)
   end
 
-  attr_reader :commands, :configuration, :completions
+  attr_reader :manager, :specification, :completions, :name_commands
 
-  def initialize(configuration, options={})
-    @configuration = configuration
+  def initialize(specification, options={})
+    @specification = specification
     @options = options
     if logfile = options[:service_log]
       @log = File.new(logfile, "a")
     else
       @log = STDOUT
     end
-    commands = Squeeze::HashTree[@configuration[:commands]]
+    commands = Squeeze::HashTree[@specification[:commands]]
 
     @completions = Set.new
 
-    @commands = {}
+    @name_commands = {}
     commands.each_path do |path, value|
       key = path.join(".")
-      @completions += path
+      # add dot-delimited command names to the completions
+      @completions += path.map {|s| s.to_s }
       @completions << key
-      @commands[key] = value
+      # register each command under the dot-delimited name
+      @name_commands[key] = value
     end
+    @command_width = @name_commands.keys.sort_by {|k| k.size }.last.size
 
-    @threads = {}
-    @pid_tracker = {}
-    @command_tracker = {}
+    @manager = Manager.new(@specification, :log => @log, :command_width => @command_width)
   end
 
-  def start(&block)
-    @running = []
-    @command_width = commands.keys.sort_by {|k| k.size }.last.size
-    @commands.each do |name, command|
-      spawn(name, command)
-    end
-
-    at_exit { stop }
-
-    Thread.new do
-      # pid of -1 means to wait for any child process
-      pid, status = Process.wait2(-1)
-      # when we stop processes intentionally, we must remove the pid
-      # from the tracker
-      if name = @pid_tracker.delete(pid)
-        @command_tracker.delete(name)
-        command = @commands[name]
-        if status.exitstatus != 0
-          puts "Process '#{name}' (pid #{pid}) exited with code #{status}:"
-          puts "Shutting down all processes."
-          exit(status.exitstatus)
-        end
-      end
-    end
-
-    # Command threads add themselves to the array when they believe
-    # their commands are ready.
-    until @threads.size == @commands.size
-      sleep 0.1
-    end
-
-    message = format_line("Fate", "All commands are running. ")
-    puts colorize("green", message)
-
+  def run(&block)
+    start
     if block
       yield(self)
-      stop
+      manager.stop
     end
-
   end
 
-  def spawn(name, command)
-    return Thread.new do
-      pid, stdin, stdout, stderr = open4(command)
-      puts colorize("yellow", format_line("Fate", "Starting (#{pid}): #{command}"))
-      @pid_tracker[pid] = name
-      @command_tracker[name] = pid
-
-      Thread.new do
-        while line = stderr.gets
-          STDERR.puts "(#{name}) #{line}"
-        end
-      end
-
-      # First line written to STDOUT is interpreted as the service
-      # signalling that it is ready.
-      line = stdout.gets
-      @log.puts format_line(name, line)
-      @threads[name] = Thread.current
-      #@threads << Thread.current
-
-      while line = stdout.gets
-        @log.puts format_line(name, line)
-      end
-    end
+  def start
+    manager.start_group(@name_commands)
+    message = format_line("Fate Control", "All commands are running. ")
+    puts colorize("green", message)
   end
 
   def stop
-    if @pid_tracker.size != 0
-      command = "kill #{@pid_tracker.keys.join(' ')}"
-      system command
-      @pid_tracker.clear
-      @command_tracker.clear
-      @threads.clear
+    keys = @name_commands.keys
+    # presuming the spec file ordered the commands where the dependencies
+    # come before the dependers, we should stop the processes in reverse order,
+    # then start them back up again in forward order.
+    names = manager.running.sort_by {|name| keys.index(name) }
+    names.reverse.each do |name|
+      manager.stop_command(name)
     end
   end
 
-  def format_line(identifier, line)
-    if identifier == @last_identifier
-      "%-#{@command_width}s - %s" % [nil, line]
-    else
-      @last_identifier = identifier
-      "%-#{@command_width}s - %s" % [identifier, line]
-    end
+  def restart
+    stop
+    # FIXME: this is here to prevent redis-server from crying
+    sleep 0.5
+    start
   end
 
-  def stop_command(name)
+  def resolve_commands(name)
     targets = []
-    if command = @commands[name]
+    if @name_commands.has_key?(name)
       targets << name
     else
-      @commands.each do |cname, _command|
+      @name_commands.each do |cname, _command|
         if cname.split(".").first == name
           targets << cname
         end
       end
     end
+    targets
+  end
 
-    if targets.empty?
-      puts "No such command registered: #{name}"
-    end
-
-    targets.each do |name|
-      if pid = @command_tracker[name]
-        @pid_tracker.delete(pid)
-        @command_tracker.delete(name)
-        @threads.delete(name)
-        system "kill -s INT #{pid}"
-        puts colorize("yellow", format_line("Fate", "Sent a kill signal to #{name} running at #{pid}"))
+  def start_command(spec)
+    names = resolve_commands(spec)
+    if names.empty?
+      puts "No commands found for: #{spec}"
+    else
+      names.each do |name|
+        command = @name_commands[name]
+        manager.start_command(name, command)
       end
     end
-
   end
 
-  def start_command(name)
-    if command = @commands[name]
-      if pid = @command_tracker[name]
-        puts "#{name} is already running with pid #{pid}"
-      else
-        spawn(name, command)
-        until @threads[name]
-          sleep 0.1
-        end
-        puts colorize("green", format_line("Fate", "#{command} is running."))
-      end
+  def stop_command(spec)
+    names = resolve_commands(spec)
+    if names.empty?
+      puts "No commands found for: #{spec}"
     else
-      puts "No such command registered: #{name}"
+      names.each do |name|
+        manager.stop_command(name)
+      end
     end
   end
 
-  def restart
-    stop
-    start
-  end
-
   def restart_command(name)
     stop_command(name)
     start_command(name)
   end
 
-  # list currently running commands
   def running
-    names = @command_tracker.map {|name, command| name }
+    manager.running
   end
 
   # ad hoc shell out, with rescuing because of some apparent bugs
@@ -200,13 +129,9 @@ class Fate
     begin
       Kernel.system command
     rescue => error
-      puts "Exception raised when shelling out: #{error.inspect}"
+      puts "Exception raised when executing '#{command}': #{error.inspect}"
     end
   end
 
-  def colorize(name, string)
-    [Term::ANSIColor.send(name), string, Term::ANSIColor.reset].join
-  end
-
 end
 

data/lib/fate/formatter.rb

@@ -0,0 +1,18 @@
+class Fate
+
+  module Formatter
+    def format_line(identifier, line)
+      if identifier == @last_identifier
+        "%-#{@command_width}s - %s" % [nil, line]
+      else
+        @last_identifier = identifier
+        "%-#{@command_width}s - %s" % [identifier, line]
+      end
+    end
+
+    def colorize(name, string)
+      [Term::ANSIColor.send(name), string, Term::ANSIColor.reset].join
+    end
+  end
+
+end

data/lib/fate/manager.rb

@@ -0,0 +1,139 @@
+require "pp"
+# Cross-VM compatibility
+# thanks to http://ku1ik.com/2010/09/18/open3-and-the-pid-of-the-spawn.html
+# TODO: consider using systemu: https://github.com/ahoward/systemu/
+if IO.respond_to?(:popen4)
+  def open4(*args)
+    IO.popen4(*args)
+  end
+else
+  require 'open4'
+end
+
+class Fate
+  class Manager
+    include Formatter
+
+    def initialize(specification, options)
+      @service_log = options[:log]
+      @command_width = options[:command_width]
+      @threads = {}
+      @commands_by_name = {}
+      @names_by_pid = {}
+      @pids_by_name = {}
+      at_exit { stop }
+    end
+
+
+    def stop
+      @names_by_pid.each do |pid, name|
+        kill(name)
+      end
+    end
+
+    def start_group(hash)
+      hash.each do |name, command|
+        @commands_by_name[name] = command
+        start_command(name, command)
+      end
+
+      until @threads.size == hash.size
+        sleep 0.1
+      end
+    end
+
+    def start_command(name, command)
+      if pid = @pids_by_name[name]
+        puts "#{name} is already running with pid #{pid}"
+      else
+        spawn(name, command)
+      end
+    end
+
+    def kill(name)
+      if pid = @pids_by_name[name]
+        @names_by_pid.delete(pid)
+        @pids_by_name.delete(name)
+        @threads.delete(name)
+        system "kill -s INT #{pid}"
+        puts colorize "yellow",
+          format_line("Fate Manager", "Sent a kill signal to #{name} running at #{pid}")
+      else
+        puts "Could not find pid for #{name}"
+      end
+    end
+
+    def stop_command(name)
+      kill(name)
+    end
+
+    def spawn(name, command)
+      # TODO: check to see if command is already running
+      return Thread.new do
+        pid, stdin, stdout, stderr = open4(command)
+        puts colorize("yellow", format_line("Fate Manager", "Starting (#{pid}): #{name}"))
+        @names_by_pid[pid] = name
+        @pids_by_name[name] = pid
+
+        Thread.new do
+          while line = stderr.gets
+            STDERR.puts "(#{name}) #{line}"
+          end
+        end
+
+        # First line written to STDOUT is interpreted as the service
+        # signalling that it is ready.
+        line = stdout.gets
+        puts colorize("yellow", format_line("Fate Manager", "#{name} is running."))
+        @service_log.puts format_line(name, line)
+        @threads[name] = Thread.current
+        #@threads << Thread.current
+
+        while line = stdout.gets
+          @service_log.puts format_line(name, line)
+        end
+        status = Process.wait(pid)
+        handle_child_termination(pid, status)
+      end
+    end
+
+    # list currently running commands
+    def running
+      names = @pids_by_name.map {|name, command| name }.sort
+    end
+
+    private
+
+    def handle_child_termination(pid, status)
+      if name = @names_by_pid.delete(pid)
+        @pids_by_name.delete(name)
+        # TODO: CLI and instantiation flags for @mode
+        if (@mode != :production) && status.exitstatus != 0
+          down_in_flames(name, pid, status)
+        else
+          # Probably should notify somebody somehow
+        end
+      end
+    end
+
+    def down_in_flames(name, pid, status)
+      puts "Process '#{name}' (pid #{pid}) exited with code #{status}:"
+      puts "Shutting down all processes."
+      exit(status.exitstatus)
+    end
+
+
+    # ad hoc shell out, with rescuing because of some apparent bugs
+    # in MRI 1.8.7's ability to cope with unusual exit codes.
+    def system(command)
+      begin
+        Kernel.system command
+      rescue => error
+        puts "Exception raised when executing '#{command}': #{error.inspect}"
+      end
+    end
+
+
+
+  end
+end

data/lib/fate/{console.rb → repl.rb}

@@ -1,12 +1,13 @@
-require "consolize"
+gem "harp"
+require "harp"
 class Fate
 
-  include Consolize
+  include Harp
 
-  setup_console do |console|
+  setup_repl do |repl|
 
     on("help") do
-      commands = console.commands.select {|c| c.size > 1 } + ["!"]
+      commands = repl.commands.select {|c| c.size > 1 } + ["!"]
       puts "* Available commands: " << commands.sort.join(" ")
     end
 
@@ -14,12 +15,16 @@ class Fate
       exit
     end
 
-    on(/stop (\S+)$/) do |args|
+    on("stop") do
+      self.stop
+    end
+
+    on(/^stop (\S+)$/) do |args|
       command = args.first
       self.stop_command(args.first)
     end
 
-    on(/start (\S+)$/) do |args|
+    on(/^start (\S+)$/) do |args|
       command = args.first
       self.start_command(args.first)
     end
@@ -38,7 +43,7 @@ class Fate
     end
 
     on("commands") do
-      puts JSON.pretty_generate(commands)
+      puts JSON.pretty_generate(self.name_commands)
     end
 
     on("running") do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fate
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,16 +9,16 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-30 00:00:00.000000000 Z
+date: 2012-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: consolize
+  name: harp
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.2.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.2.4
 - !ruby/object:Gem::Dependency
   name: open4
   requirement: !ruby/object:Gem::Requirement
@@ -86,7 +86,9 @@ files:
 - LICENSE
 - README.md
 - lib/fate.rb
-- lib/fate/console.rb
+- lib/fate/repl.rb
+- lib/fate/formatter.rb
+- lib/fate/manager.rb
 homepage: https://github.com/automatthew/fate
 licenses: []
 post_install_message: