fate 0.2.2

data/LICENSE

@@ -0,0 +1,10 @@
+Copyright (c) 2012 Matthew King
+
+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/bin/fate

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require "rubygems"
+require "json"
+
+# set up loadpath
+here = File.dirname(__FILE__)
+SPAWN_CONTROL_ROOT = File.expand_path("#{here}/..")
+$LOAD_PATH.unshift("#{SPAWN_CONTROL_ROOT}/lib")
+
+require "fate"
+
+options = {
+  :configuration => "fate.json"
+}
+
+# TODO: config file flag
+OptionParser.new do |parser|
+  parser.on("-c", "--configuration=FILE", "The origin of the events") do |file|
+    options[:configuration] = file
+  end
+end.parse!
+
+
+string = File.read(options[:configuration])
+configuration = JSON.parse(string, :symbolize_names => true)
+spawner = Fate.new(configuration)
+
+trap("INT") do
+  exit
+end
+
+require "fate/console"
+spawner.start
+spawner.console
+
+

data/lib/fate.rb

@@ -0,0 +1,210 @@
+require "set"
+
+require "term/ansicolor"
+
+require "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
+
+class Fate
+
+  def self.start(configuration, &block)
+    self.new(configuration).start(&block)
+  end
+
+  attr_reader :commands, :configuration, :completions
+
+  def initialize(configuration, options={})
+    @configuration = configuration
+    @options = options
+    if logfile = options[:service_log]
+      @log = File.new(logfile, "a")
+    else
+      @log = STDOUT
+    end
+    commands = HashTree[@configuration[:commands]]
+
+    @completions = Set.new
+
+    @commands = {}
+    commands.each_path do |path, value|
+      key = path.join(".")
+      @completions += path
+      @completions << key
+      @commands[key] = value
+    end
+
+    @threads = {}
+    @pid_tracker = {}
+    @command_tracker = {}
+  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)
+
+    if block
+      yield(self)
+      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
+  end
+
+  def stop
+    if @pid_tracker.size != 0
+      command = "kill #{@pid_tracker.keys.join(' ')}"
+      system command
+      @pid_tracker.clear
+      @command_tracker.clear
+      @threads.clear
+    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
+  end
+
+  def stop_command(name)
+    targets = []
+    if command = @commands[name]
+      targets << name
+    else
+      @commands.each do |cname, _command|
+        if cname.split(".").first == name
+          targets << cname
+        end
+      end
+    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}"))
+      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
+    else
+      puts "No such command registered: #{name}"
+    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 }
+  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 shelling out: #{error.inspect}"
+    end
+  end
+
+  def colorize(name, string)
+    [Term::ANSIColor.send(name), string, Term::ANSIColor.reset].join
+  end
+
+end
+

data/lib/fate/console.rb

@@ -0,0 +1,54 @@
+require "consolize"
+class Fate
+
+  include Consolize
+
+  setup_console do |console|
+
+    on("help") do
+      commands = console.commands.select {|c| c.size > 1 } + ["!"]
+      puts "* Available commands: " << commands.sort.join(" ")
+    end
+
+    on("quit", "q", "exit") do
+      exit
+    end
+
+    on(/stop (\S+)$/) do |args|
+      command = args.first
+      self.stop_command(args.first)
+    end
+
+    on(/start (\S+)$/) do |args|
+      command = args.first
+      self.start_command(args.first)
+    end
+
+    on("restart") do
+      self.restart
+    end
+
+    on(/restart (\S+)$/) do |args|
+      command = args.first
+      self.restart_command(args.first)
+    end
+
+    on_bang do |args|
+      self.system args.first
+    end
+
+    on("commands") do
+      puts JSON.pretty_generate(commands)
+    end
+
+    on("running") do
+      puts self.running
+    end
+
+    on("configuration", "config") do
+      puts JSON.pretty_generate(configuration)
+    end
+
+  end
+
+end

data/lib/hash_tree.rb

@@ -0,0 +1,313 @@
+module Traversable
+
+  # Follow or create the path specified by the signature and assign
+  # the value as a terminating leaf node.
+  #  
+  #  h.set([:a, :b, :c], "This is a retrievable value")
+  #
+  def set(sig, val)
+    raise ArgumentError if sig.empty?
+    create_path(sig) do |node, key|
+      node[key] = val
+    end
+  end
+
+  def reduce(sig, base=0)
+    create_path(sig) do |node, key|
+      node[key] = base unless node.has_key?(key)
+      node[key] = yield node[key]
+    end
+  end
+
+  def increment(sig, val=1)
+    val = yield if block_given?
+    create_path(sig) do |node, key|
+      if node.has_key?(key)
+        node[key] = node[key] + val
+      else
+        node[key] = val
+      end
+    end
+  end
+
+   # Usage:
+  # a = ht.reducer([:a, :b, :c], 0) {|acc, v| acc + v }
+  # a[1]
+  def reducer(sig, base, &block)
+    p = nil
+    create_path(sig) do |node, key|
+      unless node.has_key?(key)
+        node[key] = base
+      end
+      p = lambda do |newval|
+        node[key] = block.call(node[key], newval)
+      end
+    end
+    p
+  end
+
+  def sum(*args)
+    out = 0
+    retrieve(*args) { |v| out += v }
+    out
+  end
+
+  def count(*args)
+    args = args + [:_count]
+    sum(*args)
+  end
+
+  def unique(*args)
+    out = 0
+    filter(*args) { |v| out += v.size }
+    out
+  end
+
+  # like retrieve, but will return any kind of node
+  def filter(*sig)
+    results = []
+    search(sig) do |node|
+      results << node
+      yield(node) if block_given?
+    end
+    results
+  end
+
+  # Given a signature array, attempt to retrieve matching leaf values.
+  def retrieve(*sig)
+    results = []
+    search(sig) do |node|
+      results << node unless node.respond_to?(:children)
+      yield(node) if block_given?
+    end
+    results
+  end
+
+  # Generic tree search method
+  def search(sig)
+    current_nodes = [self]
+
+    while !current_nodes.empty?
+      next_nodes = []
+      matcher = sig.shift
+      if matcher
+        current_nodes.each do |node|
+          if node.respond_to?(:children)
+            next_nodes += node.children(matcher)
+          end
+        end
+      else
+        current_nodes.each {|n| yield(n) }
+      end
+      current_nodes = next_nodes
+    end
+  end
+
+  def traverse
+    current_nodes = [self]
+    while !current_nodes.empty?
+      next_nodes = []
+      current_nodes.each do |node|
+        if node.respond_to?(:children)
+          next_nodes += node.children(true)
+          yield(node)
+        end
+      end
+
+      current_nodes = next_nodes
+    end
+  end
+
+end
+
+class HashTree < Hash
+  include Traversable
+
+  # Override the constructor to provide a default_proc
+  # NOTE: there's a better way to do this in 1.9.2, it seems.
+  # See Hash#default_proc=
+  def self.new()
+    hash = Hash.new { |h,k| h[k] = HashTree.new }
+    super.replace(hash)
+  end
+
+  def self.[](hash)
+    ht = self.new
+    ht << hash
+    ht
+  end
+
+  def _dump(depth)
+    h = Hash[self]
+    h.delete_if {|k,v| v.is_a? Proc }
+    Marshal.dump(h)
+  end
+
+  def self._load(*args)
+    h = Marshal.load(*args)
+    ht = self.new
+    ht.replace(h)
+    ht
+  end
+
+  # Follow the path specified, creating new nodes where necessary.
+  # Returns the value at the end of the path. If a block is supplied,
+  # it will be called with the last node and the last key as parameters,
+  # analogous to Hash.new's default proc. This is necessary to allow
+  # setting a value at the end of the path.  See the implementation of #insert.
+  def create_path(sig)
+    final_key = sig.pop
+    hash = self
+    sig.each do |a|
+      hash = hash[a]
+    end
+    yield(hash, final_key) if block_given?
+    hash[final_key]
+  end
+
+  # Attempt to retrieve the value at the end of the path specified,
+  # without creating new nodes.  Returns nil on failure.
+  # TODO: consider whether splatting the signature is wise.
+  def find(sig)
+    stage = self
+    sig.each do |a|
+      if stage.has_key?(a)
+        stage = stage[a]
+      else
+        return nil
+      end
+    end
+    stage
+  end
+
+  def remove(*sig)
+    stage = self
+    s2 = sig.slice(0..-2)
+    s2.each do |a|
+      if stage.has_key?(a)
+        stage = stage[a]
+      else
+        return nil
+      end
+    end
+    stage.delete(sig.last)
+  end
+
+  def children(matcher=true)
+    next_keys = self.keys.select do |key|
+      match?(matcher, key)
+    end
+    self.values_at(*next_keys)
+  end
+
+  def +(other)
+    out = HashTree.new
+    _plus(other, out)
+    out
+  end
+
+  def _plus(ht2, out)
+    self.each do |k1,v1|
+      v1 = v1.respond_to?(:dup) ? v1 : v1.dup
+      if ht2.has_key?(k1)
+        v2 = ht2[k1]
+        if v1.respond_to?(:_plus)
+          out[k1] = v1
+          v1._plus(v2, out[k1])
+        elsif v2.respond_to?(:_plus)
+          raise ArgumentError,
+            "Can't merge leaf with non-leaf:\n#{v1.inspect}\n#{v2.inspect}"
+        else
+          if v2.is_a?(Numeric) && v1.is_a?(Numeric)
+            out[k1] = v1 + v2
+          else
+            out[k1] = [v1, ht2[k1]]
+          end
+        end
+      else
+        # should anything happen here?
+      end
+    end
+    ht2.each do |k,v|
+      if self.has_key?(k)
+        # should anything happen here?
+      else
+        v = v.respond_to?(:dup) ? v : v.dup
+        out[k] = v
+      end
+    end
+  end
+
+  def <<(other)
+    other.each do |k,v1|
+      if self.has_key?(k)
+        v2 = self[k]
+        if v1.respond_to?(:has_key?) && v2.respond_to?(:has_key?)
+          v2 << v1
+        elsif v1.is_a?(Numeric) && v2.is_a?(Numeric)
+          self[k] = v1 + v2
+        else
+          raise ArgumentError,
+            "Can't merge leaf with non-leaf:\n#{v1.inspect}\n#{v2.inspect}"
+        end
+      else
+        if v1.respond_to?(:has_key?)
+          self[k] << v1
+        else
+          self[k] = v1
+        end
+      end
+    end
+  end
+
+  def match?(val, key)
+    case val
+    when true
+      true
+    when String, Symbol
+      key == val
+    when Regexp
+      key =~ val
+    when Proc
+      val.call(key)
+    when nil
+      false
+    else
+      raise ArgumentError, "Unexpected matcher type: #{val.inspect}"
+    end
+  end
+
+  def each_path(stack=[], &block)
+    self.each do |k, v|
+      stack.push(k)
+      if v.respond_to?(:each_path)
+        v.each_path(stack, &block)
+      else
+        block.call(stack, v)
+      end
+      stack.pop
+    end
+  end
+
+  def paths
+    out = []
+  end
+
+  def each_leaf(stack=[], &block)
+    self.each do |k,v|
+      stack.push(k)
+      if v.respond_to?(:each_leaf)
+        v.each_leaf(stack, &block)
+      else
+        block.call(v)
+      end
+      stack.pop
+    end
+  end
+
+end
+
+
+
+
+

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification 
+name: fate
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 2
+  version: 0.2.2
+platform: ruby
+authors: 
+- Matthew King
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-08-29 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: consolize
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 0
+        - 2
+        - 0
+        version: 0.2.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: open4
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: term-ansicolor
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id003
+description: 
+email: 
+executables: 
+- fate
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/fate
+- LICENSE
+- lib/fate.rb
+- lib/hash_tree.rb
+- lib/fate/console.rb
+has_rdoc: true
+homepage: https://github.com/automatthew/fate
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Tool for running and interacting with a multi-process service
+test_files: []
+