magistrate 0.1.0 → 0.2.0

data/bin/magistrate

@@ -8,6 +8,7 @@ require "optparse"
 
 action = :start
 config_file = nil
+verbose = false
 
 ARGV.options do |opts|
   opts.banner = "Usage:  #{File.basename($PROGRAM_NAME)} COMMAND [OPTIONS]"
@@ -28,6 +29,10 @@ ARGV.options do |opts|
     config_file = f
   end
   
+  opts.on( '-v', '--verbose') do
+    verbose = true
+  end
+  
   begin
     opts.parse!
   rescue
@@ -40,4 +45,4 @@ config_file ||= File.join('config', 'magistrate.yaml')
 
 ARGV[0] ||= 'run'
 
-Magistrate::Supervisor.new(config_file).send(ARGV[0], ARGV[1])
+Magistrate::Supervisor.new(config_file, :verbose => verbose).send(ARGV[0], ARGV[1])

data/lib/magistrate/process.rb

@@ -1,6 +1,7 @@
-class Magistrate::Process
+module Magistrate
+class Process
 
-  attr_reader :name, :daemonize, :start_cmd, :stop_cmd, :pid_file, :working_dir, :env
+  attr_reader :name, :daemonize, :start_cmd, :stop_cmd, :pid_file, :working_dir, :env, :logs
   attr_accessor :target_state, :monitored
 
   def initialize(name, options = {})
@@ -8,9 +9,10 @@ class Magistrate::Process
     @daemonize    = options[:daemonize]
     @working_dir  = options[:working_dir]
     @start_cmd    = options[:start_cmd]
+    @pid_path     = options[:pid_path]
     
     if @daemonize
-      @pid_file   = File.join('tmp', 'pids', "#{@name}.pid")
+      @pid_file   = File.join(@pid_path, "#{@name}.pid")
       @stop_signal = options[:stop_signal] || 'TERM'
     else
       @stop_cmd     = options[:end_cmd]
@@ -23,6 +25,20 @@ class Magistrate::Process
     @env = {}
 
     @target_state = :unknown
+    @logs = []
+  end
+  
+  def log(str)
+    @logs << str
+  end
+  
+  def status
+    {
+      :state => self.state,
+      :target_state => self.target_state,
+      :pid => self.pid,
+      :logs => @logs
+    }
   end
   
   def running?
@@ -44,7 +60,7 @@ class Magistrate::Process
   # It will check if the pid exists and if so, is the process responding OK?
   # It will take action based on the target state
   def supervise!
-    LOGGER.info("#{@name} supervising.  Is: #{state}.  Target: #{@target_state}")
+    log "Supervising.  Is: #{state}.  Target: #{@target_state}"
     if state != @target_state
       if @target_state == :running
         start
@@ -55,7 +71,7 @@ class Magistrate::Process
   end
   
   def start
-    LOGGER.info("#{@name} starting")
+    log "#{@name} starting"
     if @daemonize
       @pid = double_fork(@start_cmd)
       # TODO: Should check if the pid really exists as we expect
@@ -76,7 +92,7 @@ class Magistrate::Process
           ::Process.kill(0, pid)
         rescue Errno::ESRCH
           # It died. Good.
-          LOGGER.info("#{@name} process stopped")
+          log "Process stopped"
           return
         end
         
@@ -84,7 +100,7 @@ class Magistrate::Process
       end
       
       signal('KILL', pid)
-      LOGGER.warn("#{@name} still alive after #{@stop_timeout}s; sent SIGKILL")
+      log "Still alive after #{@stop_timeout}s; sent SIGKILL"
     else
       single_fork(@stop_cmd)
       ensure_stop
@@ -99,7 +115,7 @@ class Magistrate::Process
     exit_code = status[1] >> 8
     
     if exit_code != 0
-      LOGGER.warn("#{@name} command exited with non-zero code = #{exit_code}")
+      log "Command exited with non-zero code = #{exit_code}"
     end
     pid
   end
@@ -140,7 +156,8 @@ class Magistrate::Process
       dir = @working_dir || '/'
       Dir.chdir dir
       
-      $0 = command
+      #$0 = command
+      $0 = "Magistrate Worker: #{@name}"
       STDIN.reopen "/dev/null"
       
       STDOUT.reopen '/dev/null'
@@ -178,10 +195,10 @@ class Magistrate::Process
   #
   # Returns nothing
   def ensure_stop
-    LOGGER.warn("#{@name} ensuring stop...")
+    log "Ensuring stop..."
 
     unless self.pid
-      LOGGER.warn("#{@name} stop called but pid is uknown")
+      log "Stop called but pid is unknown"
       return
     end
     
@@ -199,7 +216,7 @@ class Magistrate::Process
     
     # last resort
     signal('KILL')
-    LOGGER.warn("#{@name} still alive after #{@stop_timeout}s; sent SIGKILL")
+    log "Still alive after #{@stop_timeout}s; sent SIGKILL"
   end
   
   # Send the given signal to this process.
@@ -208,7 +225,7 @@ class Magistrate::Process
   def signal(sig, target_pid = nil)
     target_pid ||= self.pid
     sig = sig.to_i if sig.to_i != 0
-    LOGGER.info("#{@name} sending signal '#{sig}' to pid #{self.pid}")
+    log "Sending signal '#{sig}' to pid #{target_pid}"
     ::Process.kill(sig, target_pid) rescue nil
   end
   
@@ -244,3 +261,4 @@ class Magistrate::Process
   end
 
 end
+end

data/lib/magistrate/supervisor.rb

@@ -10,42 +10,57 @@ require 'uri'
 
 module Magistrate
   class Supervisor    
-    def initialize(config_file)
+    def initialize(config_file, overrides = {})
       @workers = {}
       
       #File.expand_path('~')
-      @pid_path = File.join( 'tmp', 'pids' )
-      
-      FileUtils.mkdir_p(@pid_path) unless File.directory? @pid_path
-      
+      @config_file = config_file
       @config = File.open(config_file) { |file| YAML.load(file) }    
       @config.recursive_symbolize_keys!
 
       @uri = URI.parse @config[:monitor_url]
+      @pid_path = @config[:pid_path] || File.join( 'tmp', 'pids' )
+      
+      FileUtils.mkdir_p(@pid_path) unless File.directory? @pid_path
 
       @config[:workers].each do |k,v|
+        v[:pid_path] ||= @pid_path
         @workers[k] = Process.new(k,v)
       end
       
       @loaded_from = nil
+      @logs = []
+      @verbose = overrides[:verbose]
+      
+      if @verbose
+        require 'pp'
+      end
     end
 
     def run(params = nil)
-      puts "Starting Magistrate [[[#{self.name}]]] talking to [[[#{@config[:monitor_url]}]]]"
+      log "Run started at: #{Time.now}"
+      
+      log "Starting Magistrate [[[#{self.name}]]] talking to [[[#{@config[:monitor_url]}]]]"
       set_target_states!
       
       # Pull in all already-running workers and set their target states
       @workers.each do |k, worker|
         worker.supervise!
+        if @verbose
+          puts "==== Worker: #{k}"
+          worker.logs.join("\n")
+        end
       end
       
       send_status
+      
+      log "Run Complete at: #{Time.now}" #This is only good in verbose mode, but that's ok
     end
     
     # 
     def start(params = nil)
       worker = params
-      puts "Starting: #{worker}"
+      log "Starting: #{worker}"
       @workers[worker.to_sym].supervise!
       
       # Save that we've requested this to be started
@@ -53,7 +68,7 @@ module Magistrate
     
     def stop(params = nil)
       worker = params
-      puts "Stopping: #{worker}"
+      log "Stopping: #{worker}"
       @workers[worker.to_sym].stop
       
       # Save that we've requested this to be stopped
@@ -68,18 +83,27 @@ module Magistrate
     
     # Returns the actual hash of all workers and their status
     def status
-      s = {}
+      s = {
+           :name => self.name,
+           :pid_path => @pid_path,
+           :monitor_url => @config[:monitor_url],
+           :config_file => @config_file,
+           :logs => @logs,
+           :workers => {}
+          }
       
       @workers.each do |k,process|
-        s[k] = {
-          :state => process.state,
-          :target_state => process.target_state
-        }
+        s[:workers][k] = process.status
       end
       
       s
     end
     
+    def log(str)
+      @logs << str
+      puts str if @verbose
+    end
+    
     protected
     
     # Loads the @target_states from either the remote server or local cache
@@ -93,7 +117,7 @@ module Magistrate
           if @workers[name]
             @workers[name].target_state = target['target_state'].to_sym if target['target_state']
           else
-            puts "Worker #{name} not found in local config"
+            log "Worker #{name} has an entry in the target_state but it's not listed in the local config file and will be ignored."
           end
         end
       end
@@ -102,25 +126,21 @@ module Magistrate
     # Gets and sets @target_states from the server
     # Automatically falls back to the local cache
     def load_remote_target_states!
-      http = Net::HTTP.new(@uri.host, @uri.port)
-      http.read_timeout = 30
-      request = Net::HTTP::Get.new(@uri.request_uri + "api/status/#{self.name}")
-
-      response = http.request(request)
+      response = remote_request(Net::HTTP::Get)
       
       if response.code == '200'
         @loaded_from = :server
         @target_states = JSON.parse(response.body)
         save_target_states! # The double serialization here might not be best for performance, but will guarantee that the locally stored file is internally consistent
       else
-        puts "Server responded with error #{response.code} : [[[#{response.body}]]].  Using saved target states..."
+        log "Server responded with error #{response.code} : [[[#{response.body}]]].  Using saved target states..."
         load_saved_target_states!
       end
       
     rescue StandardError => e
-      puts "Connection to server #{@config[:monitor_url]} failed."
-      puts "Error: #{e}"
-      puts "Using saved target states..."
+      log "Connection to server #{@config[:monitor_url]} failed."
+      log "Error: #{e}"
+      log "Using saved target states..."
       load_saved_target_states!
     end
     
@@ -142,18 +162,29 @@ module Magistrate
     # Currently only sends basic worker info, but could start sending lots more:
     # 
     def send_status
-      http = Net::HTTP.new(@uri.host, @uri.port)
-      http.read_timeout = 30
-      request = Net::HTTP::Post.new(@uri.request_uri + "api/status/#{self.name}")
-      request.set_form_data({ :status => JSON.generate(status) })
-      response = http.request(request)
+      remote_request Net::HTTP::Post, { :status => JSON.generate(status) }
     rescue StandardError => e
-      puts "Sending status to #{@config[:monitor_url]} failed"
+      log "Sending status to #{@config[:monitor_url]} failed"
+      log "Error: #{e}"
     end
     
     # This is the name that the magistrate_monitor will identify us as
     def name
-      @_name ||= (@config[:supervisor_name_override] || "#{`hostname`.chomp}-#{`whoami`.chomp}").gsub(/[^a-zA-Z0-9\-\_]/, ' ').gsub(/\s+/, '-').downcase
+      @_name ||= (@config[:supervisor_name_override] || "#{@config[:root_name]}-#{`hostname`.chomp}").gsub(/[^a-zA-Z0-9\-\_]/, ' ').gsub(/\s+/, '-').downcase
+    end
+    
+    # Wrapper method for easy remote requests
+    def remote_request(klass, form_data = nil)
+      http = Net::HTTP.new(@uri.host, @uri.port)
+      http.read_timeout = 30
+      request = klass.new(@uri.request_uri + "api/status/#{self.name}")
+      request.set_form_data(form_data) if form_data
+      
+      if @config[:http_username] && @config[:http_password]
+        request.basic_auth @config[:http_username], @config[:http_password]
+      end
+      
+      http.request(request)
     end
   end
 end

data/lib/magistrate/version.rb

@@ -1,3 +1,3 @@
 module Magistrate
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/magistrate.rb

@@ -5,10 +5,6 @@ require 'magistrate/version'
 require 'magistrate/supervisor'
 require 'magistrate/process'
 
-require 'logger'
-# App wide logging system
-LOGGER = Logger.new(STDOUT)
-
 module Magistrate
   
 end

data/spec/magistrate/process_spec.rb

@@ -30,10 +30,6 @@ describe "Magistrate::Process" do
         @process.state.should == :stopped
       end
     end
-    
-    it "should " do
-      true
-    end
   end
   
   describe 'Self-Daemonizing Worker' do

data/spec/magistrate/supervisor_spec.rb

@@ -11,9 +11,27 @@ describe "Magistrate::Supervisor" do
   end
   
   it "should show basic status for its workers" do
-    @supervisor.status.should == { :daemon_worker=>{:state=>:unmonitored, :target_state=>:unknown}, 
-                                   :rake_like_worker=>{:state=>:unmonitored, :target_state=>:unknown} }
+    s = @supervisor.status
+    
+    s[:name].should == 'test_name'
+    s[:pid_path].should == File.join('tmp','pids')
+    
   end
   
-#  it 'should'
+  it 'should run successfully' do
+    body = {}
+    body = JSON.generate(body)
+    stub_request(:get, "http://localhost:3000/magistrate/api/status/test_name").
+      to_return(:status => 200, :body => body, :headers => {})
+      
+    stub_request(:post, "http://localhost:3000/magistrate/api/status/test_name").
+      to_return(:status => 200, :body => 'OK', :headers => {})
+      
+    
+    
+    @supervisor.run
+    
+    a_request(:get, "http://localhost:3000/magistrate/api/status/test_name").should have_been_made
+    a_request(:post, "http://localhost:3000/magistrate/api/status/test_name").should have_been_made
+  end
 end

data/spec/resources/example.yml

@@ -1,21 +1,28 @@
-monitor_url: http://localhost
+# Should have a trailing slash
+monitor_url: http://localhost:3000/magistrate/
 
-#Normal magistrate reports itself as: `hostname`-`user`
-#supervisor_name_override: some_other_name
+# By default, if this isn't set, it'll use tmp/pids
+# pid_path: /var/www/app/current/tmp/pids
+
+#Normal magistrate reports itself as: root_name-`hostname`
+root_name: super1
+
+#Use this to avoid using the hostname at all.  The supervisor name will be this instead of root_name-`hostname`
+supervisor_name_override: test_name
 
 workers:
   # If daemonize is true, then Magistrate will daemonize this process (it doesn't daemonize itself)
   # Magistrate will track the pid of the underlying process
   # And will stop it by killing the pid
   # It will ping the status by sending USR1 signal to the process
-  rake_like_worker:
+  rake_like_worker1:
     daemonize: true
     working_dir: /data/app/
     start_cmd: rake my:task RAILS_ENV=production
   
   # If daemonize is false, then Magistrate will use a separate start and stop command
   # You must also manually specify the pid that this daemonized process creates
-  daemon_worker:
+  daemon_worker1:
     daemonize: false
     working_dir: /data/app/
     start_cmd: mongrel_rails start -d

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 require "rubygems"
+require 'webmock/rspec'
 require "rspec"
 #require "fakefs/safe"
 #require "fakefs/spec_helpers"
@@ -40,4 +41,9 @@ RSpec.configure do |config|
   config.color_enabled = true
   #config.include FakeFS::SpecHelpers
   config.mock_with :rr
+  
+  config.before(:suite) do
+    f = 'tmp/pids/target_states.yml'
+    File.delete(f) if File.exist?(f)
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: magistrate
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Drew Blas
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-16 00:00:00 -05:00
+date: 2011-08-22 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency