fate 0.2.7 → 0.2.8

data/bin/fate

@@ -12,7 +12,8 @@ $LOAD_PATH.unshift("#{FATE_ROOT}/lib")
 require "fate"
 
 options = {
-  :configuration => "fate.json"
+  :configuration => "fate.json",
+  :default_log => STDOUT
 }
 
 # TODO: config file flag
@@ -20,16 +21,17 @@ OptionParser.new do |parser|
   parser.on("-c", "--configuration=FILE", "The origin of the events") do |file|
     options[:configuration] = file
   end
+  parser.on("-l", "--log=FILE", "Processes log to FILE") do |file|
+    options[:default_log] = File.new(file, "a")
+  end
 end.parse!
 
 
 string = File.read(options[:configuration])
 configuration = JSON.parse(string, :symbolize_names => true)
-fate = Fate.new(configuration)
+fate = Fate.new(configuration, options)
+
 
-trap("INT") do
-  exit
-end
 
 require "fate/repl"
 fate.start

data/lib/fate.rb

@@ -5,44 +5,33 @@ gem "squeeze"
 require "term/ansicolor"
 require "squeeze/hash_tree"
 
-require "fate/formatter"
-require "fate/manager"
+require "fate/logger"
+require "fate/service"
+require "fate/output"
+require "fate/process_manager"
 
 Thread.abort_on_exception = true
 
 class Fate
-  include Formatter
 
   def self.start(specification, &block)
     self.new(specification).start(&block)
   end
 
-  attr_reader :manager, :specification, :completions, :name_commands
+  attr_reader :service, :manager, :completions, :logger
 
-  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[@specification[:commands]]
-
-    @completions = Set.new
-
-    @name_commands = {}
-    commands.each_path do |path, value|
-      key = path.join(".")
-      # add dot-delimited command names to the completions
-      @completions += path.map {|s| s.to_s }
-      @completions << key
-      # 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
+  def initialize(spec, options={})
+    @service = Service.new(spec, options)
+    @completions = @service.completions
+
+    @spec = spec
+    @logger = @service.logger["Fate Control"]
+
+    @manager = ProcessManager.new(@service)
+  end
 
-    @manager = Manager.new(@specification, :log => @log, :command_width => @command_width)
+  def log(*args, &block)
+    @logger.log(*args, &block)
   end
 
   def run(&block)
@@ -54,18 +43,13 @@ class Fate
   end
 
   def start
-    manager.start_group(@name_commands)
-    message = format_line("Fate Control", "All commands are running. ")
-    puts colorize("green", message)
+    manager.start_group(@service.commands)
+    logger.green "All commands are running."
   end
 
   def stop
-    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|
+    ordered = @service.stop_order(manager.running)
+    ordered.each do |name|
       manager.stop_command(name)
     end
   end
@@ -77,34 +61,20 @@ class Fate
     start
   end
 
-  def resolve_commands(name)
-    targets = []
-    if @name_commands.has_key?(name)
-      targets << name
-    else
-      @name_commands.each do |cname, _command|
-        if cname.split(".").first == name
-          targets << cname
-        end
-      end
-    end
-    targets
-  end
-
   def start_command(spec)
-    names = resolve_commands(spec)
+    names = @service.resolve_commands(spec)
     if names.empty?
       puts "No commands found for: #{spec}"
     else
       names.each do |name|
-        command = @name_commands[name]
+        command = @service.commands[name]
         manager.start_command(name, command)
       end
     end
   end
 
   def stop_command(spec)
-    names = resolve_commands(spec)
+    names = @service.resolve_commands(spec)
     if names.empty?
       puts "No commands found for: #{spec}"
     else

data/lib/fate/logger.rb

@@ -0,0 +1,91 @@
+class Fate
+
+  # Simple logging class designed to interleave the output from multiple
+  # processes while making it obvious which lines were logged by which process.
+
+  class MultiLogger
+
+    attr_reader :width, :io
+    def initialize(options)
+      @width = options[:width]
+      if file = options[:file]
+        @io = File.new(file, "a")
+      elsif io = options[:io]
+        @io = io
+      end
+    end
+
+    def [](name)
+      Sublogger.new(self, name)
+    end
+
+    class Sublogger
+      def initialize(master, name)
+        @master = master
+        @io = @master.io
+        @name = name
+      end
+
+      # duck typing for IO
+      def write(string)
+        num = @io.write(@master.format(@name, string))
+        @io.flush
+        num
+      end
+
+      def method_missing(method, *args, &block)
+        if @master.respond_to?(method)
+          # insert this logger's name into every relayed call.
+          @master.send(method, @name, *args, &block)
+        elsif @io.respond_to?(method)
+          @io.send(method, *args, &block)
+        else
+          super
+        end
+      end
+    end
+
+    def write(name, string, color=nil)
+      if color
+        line = colorize(color, format(name, string))
+      else
+        line = format(name, string)
+      end
+      num = @io.write line
+      @io.flush
+      num
+    end
+
+    def error(name, string)
+      write(name, string, "red")
+    end
+
+    def green(name, string)
+      write(name, string, "green")
+    end
+
+    def info(name, string)
+      write(name, string, "yellow")
+    end
+
+    def debug(name, string)
+      write(name, string)
+    end
+
+    def format(name, string)
+      string.chomp!
+      if name == @last_identifier
+        "%-#{width}s - %s\n" % [nil, string]
+      else
+        @last_identifier = name
+        "%-#{width}s - %s\n" % [name, string]
+      end
+    end
+
+    def colorize(name, string)
+      [Term::ANSIColor.send(name), string, Term::ANSIColor.reset].join
+    end
+
+  end
+
+end

data/lib/fate/output.rb

@@ -0,0 +1,77 @@
+class Fate
+  module Output
+
+    class Handlers
+
+      def initialize(service, handlers)
+        @service = service
+        @handlers = handlers
+      end
+
+      def [](name)
+        if handler = @handlers[name]
+          handler
+        elsif @handlers["default"]
+          @handlers[name] = @handlers["default"][name]
+        else
+          @handlers[name] = @service.logger[name]
+        end
+      end
+
+    end
+
+    class IOFilter
+      def initialize(master, name)
+        @master = master
+        @io = @master.io
+        @name = name
+      end
+
+      # duck typing for IO
+      def write(string)
+        num = @io.write(@master.format(@name, string))
+        @io.flush
+        num
+      end
+
+      def method_missing(method, *args, &block)
+        if @io.respond_to?(method)
+          @io.send(method, *args, &block)
+        else
+          super
+        end
+      end
+    end
+
+    class IOMux
+      attr_reader :io
+      attr_accessor :last_identifier
+      def initialize(options)
+        @last_identifier = nil
+        if file = options[:file]
+          @io = File.new(file, "a")
+        elsif io = options[:io]
+          @io = io
+        end
+        @handlers = {}
+      end
+
+      def [](name)
+        @handlers[name] ||= IOFilter.new(self, name)
+      end
+
+      def format(name, string)
+        if name == @last_identifier
+          string
+        else
+          @last_identifier = name
+          "==> #{name} <==\n#{string}"
+        end
+      end
+
+
+    end
+
+  end
+end
+

data/lib/fate/{manager.rb → process_manager.rb}

@@ -1,7 +1,7 @@
+require "fileutils"
 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)
@@ -11,21 +11,28 @@ else
 end
 
 class Fate
-  class Manager
-    include Formatter
 
-    def initialize(specification, options)
-      @service_log = options[:log]
-      @command_width = options[:command_width]
+  # A process management tool, concerned primarily with spawning child
+  # processes, tracking them by name, and handling unexpected exits and signals.
+  class ProcessManager
+
+    attr_reader :logger, :output_handlers
+    def initialize(service)
+      @service = service
+      @output_handlers = @service.output_handlers
+      @logger = @service.logger["Fate Manager"]
+
       @threads = {}
       @commands_by_name = {}
       @names_by_pid = {}
       @pids_by_name = {}
-      at_exit { stop }
+      at_exit do
+        stop
+      end
     end
 
-
     def stop
+      # FIXME: race condition involving spawn and stop at the same time
       @names_by_pid.each do |pid, name|
         kill(name)
       end
@@ -44,7 +51,7 @@ class Fate
 
     def start_command(name, command)
       if pid = @pids_by_name[name]
-        puts "#{name} is already running with pid #{pid}"
+        logger.error "'#{name}' is already running with pid #{pid}"
       else
         spawn(name, command)
       end
@@ -56,10 +63,9 @@ class Fate
         @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}")
+        logger.info "Sent a kill signal to '#{name}' running at #{pid}"
       else
-        puts "Could not find pid for #{name}"
+        logger.error "Could not find pid for '#{name}'"
       end
     end
 
@@ -70,29 +76,27 @@ class Fate
     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}"))
+        logger.info "Starting '#{name}' (pid #{pid})"
         @names_by_pid[pid] = name
         @pids_by_name[name] = pid
 
+        io = output_handlers[name]
         Thread.new do
-          while line = stderr.gets
-            STDERR.puts "(#{name}) #{line}"
-          end
+          IO.copy_stream(stderr, io)
         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)
+        logger.info "#{name} is running."
+
+        io.write(line)
         @threads[name] = Thread.current
-        #@threads << Thread.current
 
-        while line = stdout.gets
-          @service_log.puts format_line(name, line)
-        end
-        status = Process.wait(pid)
+        IO.copy_stream(stdout, io)
+        pid, status = Process.wait2(pid)
         handle_child_termination(pid, status)
       end
     end
@@ -117,20 +121,24 @@ class Fate
     end
 
     def down_in_flames(name, pid, status)
-      puts "Process '#{name}' (pid #{pid}) exited with code #{status}:"
-      puts "Shutting down all processes."
-      exit(status)
+      if status.exitstatus
+        logger.error "Process '#{name}' (pid #{pid}) exited with code #{status.exitstatus}."
+      else
+        logger.info "Process '#{name}' (pid #{pid}) was sent signal #{status.termsig}."
+      end
+      logger.info "Shutting down all processes."
+      exit(1)
     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
+      #begin
         Kernel.system command
-      rescue => error
-        puts "Exception raised when executing '#{command}': #{error.inspect}"
-      end
+      #rescue => error
+        #puts "Exception raised when executing '#{command}': #{error.inspect}"
+      #end
     end
 
 

data/lib/fate/repl.rb

@@ -43,7 +43,7 @@ class Fate
     end
 
     on("commands") do
-      puts JSON.pretty_generate(self.name_commands)
+      puts self.service.names
     end
 
     on("running") do
@@ -51,7 +51,7 @@ class Fate
     end
 
     on("configuration", "config") do
-      puts JSON.pretty_generate(configuration)
+      puts JSON.pretty_generate(self.service.specification)
     end
 
   end

data/lib/fate/service.rb

@@ -0,0 +1,63 @@
+class Fate
+
+  class Service
+
+    attr_reader :longest_name, :names, :commands, :completions, :specification
+    attr_reader :output_handlers, :logger
+    def initialize(specification, options)
+      @specification = specification
+      @options = options
+
+      @commands = process_commands(@specification[:commands])
+      @names = @commands.keys
+      @longest_name = @commands.keys.sort_by {|k| k.size }.last.size
+      @logger = Fate::MultiLogger.new(:io => STDOUT, :width => @longest_name)
+      @output_handlers = Output::Handlers.new(self, options[:output] || {})
+    end
+
+    def process_commands(hash)
+      hash = Squeeze::HashTree[hash]
+
+      out = {}
+      @completions ||= Set.new
+      hash.each_path do |path, value|
+        key = path.join(".")
+        # add dot-delimited command names to the completions
+        @completions += path.map {|s| s.to_s }
+        @completions << key
+        # register each command under the dot-delimited name
+        out[key] = value
+      end
+      out
+    end
+
+    def resolve_commands(name)
+      targets = []
+      if @commands.has_key?(name)
+        targets << name
+      else
+        @commands.each do |cname, _command|
+          if cname.split(".").first == name
+            targets << cname
+          end
+        end
+      end
+      targets
+    end
+
+
+    def start_order(command_names)
+      # 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.
+      command_names.sort_by {|name| self.names.index(name) }
+    end
+
+    def stop_order(command_names)
+      start_order(command_names).reverse
+    end
+
+  end
+
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fate
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-04 00:00:00.000000000 Z
+date: 2012-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -101,10 +101,13 @@ files:
 - bin/fate
 - LICENSE
 - README.md
-- lib/fate.rb
-- lib/fate/repl.rb
 - lib/fate/formatter.rb
-- lib/fate/manager.rb
+- lib/fate/logger.rb
+- lib/fate/output.rb
+- lib/fate/process_manager.rb
+- lib/fate/repl.rb
+- lib/fate/service.rb
+- lib/fate.rb
 homepage: https://github.com/automatthew/fate
 licenses: []
 post_install_message: