fate 0.2.20 → 0.3.0

data/bin/fate

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

data/lib/fate.rb

@@ -13,104 +13,67 @@ class Fate
     self.new(specification).start(&block)
   end
 
-  attr_reader :service, :manager, :completions, :logger
+  attr_reader :service, :manager, :control
+  def initialize(specification, options)
+    @service = Fate::Service.new(specification, options)
+    @manager = Fate::ProcessManager.new(service, options)
+    @control = Fate::Control.new(@manager, options)
+  end
 
-  def initialize(spec, options={})
-    @service = Service.new(spec, options)
-    @completions = @service.completions
+  class Control
 
-    @spec = spec
-    @logger = @service.logger["Fate Control"]
+    attr_reader :service, :manager, :completions, :logger
 
-    @manager = ProcessManager.new(@service, options)
-  end
+    def initialize(manager, options={})
+      @manager = manager
+      @service = @manager.service
+      @completions = @service.completions
 
-  def log(*args, &block)
-    @logger.log(*args, &block)
-  end
+      @spec = @service.specification
+      @logger = @service.logger["Fate Control"]
+    end
 
-  def run(&block)
-    if start
-      if block
-        yield(self)
-        stop
-      end
-    else
-      logger.error "Failed to start"
+    def log(*args, &block)
+      @logger.log(*args, &block)
     end
-  end
 
-  def start(command_specs=[])
-    if command_specs.size > 0
-      command_specs.each do |command_spec|
-        self.start_command(command_spec)
-      end
-    else
-      if manager.start_group(@service.commands)
-        logger.green "All commands are running."
-        true
+    def start(*command_strings)
+      if manager.start(command_strings)
+        logger.green "All processes are running."
       else
-        false
+        logger.error "Failed to start."
       end
     end
-  end
-
-  def stop
-    manager.stop_all
-  end
 
-  def restart
-    stop
-    start
-  end
-
-  def start_command(command_spec)
-    names = @service.resolve_commands(command_spec)
-    if names.empty?
-      puts "No commands found for: #{command_spec}"
-    else
-      commands = {}
-      names.each do |name|
-        command = @service.commands[name]
-        commands[name] = command
-      end
-      if manager.start_group(commands)
-        logger.green "All commands in '#{command_spec}' running."
-      else
-        logger.error "Failed to start '#{command_spec}'."
-      end
+    def stop(*command_strings)
+      manager.stop(command_strings)
     end
-  end
 
-  def stop_command(command_spec)
-    names = @service.resolve_commands(command_spec)
-    if names.empty?
-      puts "No commands found for: #{command_spec}"
-    else
-      names.each do |name|
-        manager.stop_command(name)
-      end
+    def restart(*command_strings)
+      stop(command_strings)
+      start(command_strings)
     end
-  end
 
-  def restart_command(name)
-    stop_command(name)
-    start_command(name)
-  end
+    # Run only the processes specified by the arguments.  Any existing
+    # processes outside this set will be stopped.
+    def run(*command_strings)
+      manager.run(command_strings)
+    end
 
-  def running
-    manager.running
-  end
+    def running
+      manager.running
+    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}"
+    # 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
 end
 

data/lib/fate/process_manager.rb

@@ -6,7 +6,7 @@ class Fate
   # processes, tracking them by name, and handling unexpected exits and signals.
   class ProcessManager
 
-    attr_reader :logger, :output_handlers
+    attr_reader :logger, :output_handlers, :service
     def initialize(service, options={})
       @directory = options[:directory]
       @mutex = Mutex.new
@@ -19,32 +19,66 @@ class Fate
       @names_by_pid = {}
       @pids_by_name = {}
       at_exit do
-        stop_all
+        stop_group(running)
       end
     end
 
-    def stop_all
-      @mutex.synchronize do
-        ordered = @service.stop_order(running)
-        ordered.each do |name|
-          term(name)
-        end
+    def run(command_strings=[])
+      if command_strings.empty?
+        run(@service.commands.keys)
+      else
+        commands = @service.resolve(command_strings)
+        # don't need to start processes that are already running
+        noop = commands & running
+        to_start = commands - noop
+        to_stop = running - commands
+
+        stop_group(to_stop)
+        start_group(to_start)
+      end
+    end
+
+    def start(command_strings=[])
+      if command_strings.empty?
+        start_group(@service.commands.keys)
+      else
+        commands = @service.resolve(command_strings)
+        start_group(commands)
+      end
+    end
+
+    def stop(command_strings=[])
+      if command_strings.empty?
+        stop_group(running)
+      else
+        names = @service.resolve(command_strings)
+        stop_group(names)
       end
     end
 
-    def start_group(hash)
-      hash.each do |name, command|
+    def start_group(names)
+      ordered = @service.start_order(names)
+      ordered.each do |name|
+        command = service.commands[name]
         @commands_by_name[name] = command
         start_command(name, command) unless @down_in_flames
       end
-
-      until hash.keys.all? { |key| @threads[key] }
+      until names.all? { |name| @threads[name] }
         return false if @down_in_flames
         sleep 0.1
       end
       return true
     end
 
+    def stop_group(names)
+      @mutex.synchronize do
+        ordered = @service.stop_order(names)
+        ordered.each do |name|
+          term(name)
+        end
+      end
+    end
+
     def start_command(name, command)
       if pid = @pids_by_name[name]
         logger.warn "'#{name}' is already running with pid #{pid}"
@@ -53,10 +87,6 @@ class Fate
       end
     end
 
-    def stop_command(name)
-      term(name)
-    end
-
     def term(name)
       if pid = @pids_by_name[name]
         @names_by_pid.delete(pid)
@@ -164,22 +194,11 @@ class Fate
       end
       logger.info "Shutting down all processes."
 
-      stop_all
+      stop_group(running)
       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
-        Kernel.system command
-      #rescue => error
-        #puts "Exception raised when executing '#{command}': #{error.inspect}"
-      #end
-    end
-
-
 
   end
 end

data/lib/fate/repl.rb

@@ -1,53 +1,68 @@
 require "harp"
 class Fate
+  class Control
 
-  include Harp
+    include Harp
 
-  setup_harp do |harp|
+    setup_harp do |harp|
 
-    command("help") do
-      commands = harp.command_names.select {|c| c.size > 1 } + ["!"]
-      puts "* Available commands: " << commands.sort.join(" ")
-    end
+      command("help") do
+        commands = harp.command_names.select {|c| c.size > 1 } + ["!"]
+        puts "* Available commands: " << commands.sort.join(" ")
+      end
 
-    command("quit", :alias => "q") { exit }
-    command("exit") { exit }
+      command("quit", :alias => "q") { exit }
+      command("exit") { exit }
 
-    command("stop") do
-      self.stop
-    end
+      command("stop") do
+        self.stop
+      end
 
-    command("stop", :process_name) do |args|
-      command = args.first
-      self.stop_command(args.first)
-    end
+      command("stop", :process_name) do |args|
+        command = args.first
+        self.stop(args.first)
+      end
 
-    command("start", :process_name) do |args|
-      command = args.first
-      self.start_command(args.first)
-    end
+      command("run") do
+        self.run
+      end
 
-    command("restart") do
-      self.restart
-    end
+      command("run", :process_name) do |args|
+        command = args.first
+        self.run(args.first)
+      end
 
-    command("restart", :process_name) do |args|
-      command = args.first
-      self.restart_command(args.first)
-    end
+      command("start", :process_name) do |args|
+        command = args.first
+        self.start(args.first)
+      end
 
-    command("processes") do
-      puts self.service.names
-    end
+      command("restart") do
+        self.restart
+      end
 
-    command("running") do
-      puts self.running
-    end
+      command("restart", :process_name) do |args|
+        command = args.first
+        self.restart(args.first)
+      end
+
+      command("processes") do
+        puts self.service.names
+      end
+
+      #command("groups") do
+      #end
+
+      command("running") do
+        puts self.running
+      end
+
+      command("configuration") do
+        puts JSON.pretty_generate(self.service.specification)
+      end
 
-    command("configuration") do
-      puts JSON.pretty_generate(self.service.specification)
     end
 
   end
-
 end
+

data/lib/fate/service.rb

@@ -95,6 +95,19 @@ class Fate
       out
     end
 
+    def resolve(specs)
+      command_names = []
+      specs.each do |spec|
+        names = resolve_commands(spec)
+        if names.empty?
+          logger.warn "Fate", "No commands found for: #{spec}"
+        else
+          command_names.concat(names)
+        end
+      end
+      names = command_names.uniq
+    end
+
     def resolve_commands(name)
       targets = []
       if @commands.has_key?(name)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fate
 version: !ruby/object:Gem::Version
-  version: 0.2.20
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-06 00:00:00.000000000 Z
+date: 2013-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json