ra-bluepill 0.0.44

data/lib/bluepill/trigger.rb

@@ -0,0 +1,60 @@
+module Bluepill
+  class Trigger
+    @implementations = {}
+    def self.inherited(klass)
+      @implementations[klass.name.split('::').last.underscore.to_sym] = klass
+    end
+    
+    def self.[](name)
+      @implementations[name]
+    end
+
+    attr_accessor :process, :logger, :mutex, :scheduled_events
+    
+    def initialize(process, options = {})
+      self.process = process
+      self.logger = options[:logger]
+      self.mutex = Mutex.new
+      self.scheduled_events = []
+    end
+    
+    def reset!
+      self.cancel_all_events
+    end
+    
+    def notify(transition)
+      raise "Implement in subclass"
+    end
+    
+    def dispatch!(event)
+      self.process.dispatch!(event, self.class.name.split("::").last)
+    end
+    
+    def schedule_event(event, delay)
+      # TODO: maybe wrap this in a ScheduledEvent class with methods like cancel
+      thread = Thread.new(self) do |trigger|
+        begin
+          sleep delay.to_f
+          trigger.logger.info("Retrying from flapping")
+          trigger.dispatch!(event)
+          trigger.mutex.synchronize do
+            trigger.scheduled_events.delete_if { |_, thread| thread == Thread.current }
+          end
+        rescue StandardError => e
+          trigger.logger.err(e)
+          trigger.logger.err(e.backtrace.join("\n"))
+        end
+      end
+      
+      self.scheduled_events.push([event, thread])
+    end
+    
+    def cancel_all_events
+      self.logger.info "Canceling all scheduled events"
+      self.mutex.synchronize do
+        self.scheduled_events.each {|_, thread| thread.kill}
+      end
+    end
+    
+  end
+end

data/lib/bluepill/triggers/flapping.rb

@@ -0,0 +1,59 @@
+module Bluepill
+  module Triggers
+    class Flapping < Bluepill::Trigger
+      TRIGGER_STATES = [:starting, :restarting]
+      
+      PARAMS = [:times, :within, :retry_in]
+      
+      attr_accessor *PARAMS
+      attr_reader :timeline
+      
+      def initialize(process, options = {})
+        options.reverse_merge!(:times => 5, :within => 1, :retry_in => 5)
+        
+        options.each_pair do |name, val|
+          instance_variable_set("@#{name}", val) if PARAMS.include?(name)
+        end
+        
+        @timeline = Util::RotationalArray.new(@times)
+        super
+      end
+      
+      def notify(transition)
+        if TRIGGER_STATES.include?(transition.to_name)
+          self.timeline << Time.now.to_i
+          self.check_flapping
+        end
+      end
+      
+      def reset!
+        @timeline.clear
+        super
+      end
+      
+      def check_flapping
+        num_occurances = (@timeline.nitems == self.times)
+        
+        # The process has not flapped if we haven't encountered enough incidents
+        return unless num_occurances
+        
+        # Check if the incident happend within the timeframe
+        duration = (@timeline.last - @timeline.first) <= self.within
+        
+        if duration
+          self.logger.info "Flapping detected: retrying in #{self.retry_in} seconds"
+          
+          self.schedule_event(:start, self.retry_in)
+          
+          # this happens in the process' thread so we don't have to worry about concurrency issues with this event
+          self.dispatch!(:unmonitor)
+          
+          @timeline.clear
+          
+          # This will prevent a transition from happening in the process state_machine
+          throw :halt
+        end
+      end
+    end
+  end
+end

data/lib/bluepill/util/rotational_array.rb

@@ -0,0 +1,72 @@
+module Bluepill
+  module Util
+   class RotationalArray < Array
+     def initialize(size)
+       super(size)
+       
+       @capacity = size
+       @counter = 0
+     end
+     
+     def push(value)
+       idx = rotational_idx(@counter)
+       self[idx] = value
+       
+       @counter += 1
+       self
+     end
+     
+     alias_method :<<, :push
+     
+     def pop
+       raise "Cannot call pop on a rotational array"
+     end
+
+     def shift
+       raise "Cannot call shift on a rotational array"
+     end
+
+     def unshift
+       raise "Cannot call unshift on a rotational array"
+     end
+     
+     def last
+       return if @counter.zero?
+       
+       self[rotational_idx(@counter - 1)]
+     end
+     
+     def first
+       return if @counter.zero?
+       return self[0] if @counter <= @capacity
+       
+      self[rotational_idx(@counter)]
+     end
+     
+     def clear
+      @counter = 0
+      super
+     end
+     
+     def each(&block)
+       times = @counter >= @capacity ? @capacity : @counter
+       start = @counter >= @capacity ? rotational_idx(@counter) : 0
+       times.times do |i|
+         block.call(self[rotational_idx(start + i)])
+       end
+     end
+
+     unless method_defined?(:nitems)
+       def nitems
+         compact.length
+       end
+     end
+     
+     private
+     
+     def rotational_idx(idx)
+       idx % @capacity
+     end
+   end
+ end
+end

data/lib/bluepill/version.rb

@@ -0,0 +1,3 @@
+module Bluepill
+  VERSION = "0.0.44"
+end

data/lib/example.rb

@@ -0,0 +1,81 @@
+require 'rubygems'
+require 'bluepill'
+require 'logger'
+
+ROOT_DIR = "/tmp/bp"
+
+# Watch with 
+# watch -n0.2 'ps axu | egrep "(CPU|forking|bluepill|sleep)" | grep -v grep | sort'
+Bluepill.application(:sample_app) do |app|
+  0.times do |i|
+    app.process("process_#{i}") do |process|
+      process.pid_file = "#{ROOT_DIR}/pids/process_#{i}.pid"
+      
+      # I could not figure out a portable way to
+      # specify the path to the sample forking server across the diff developer laptops.
+      # Since this code is eval'ed we cannot reliably use __FILE__
+      process.start_command = "/Users/rohith/work/bluepill/bin/sample_forking_server #{4242 + i}"
+      process.stop_command = "kill -INT {{PID}}"
+      process.daemonize = true
+      
+      process.start_grace_time = 1.seconds
+      process.restart_grace_time = 7.seconds
+      process.stop_grace_time = 7.seconds
+      
+      process.uid = "rohith"
+      process.gid = "staff"
+      
+      # process.checks :cpu_usage, :every => 10, :below => 0.5, :times => [5, 5]
+      process.checks :flapping, :times => 2, :within => 30.seconds, :retry_in => 7.seconds
+      
+      process.monitor_children do |child_process|
+        # child_process.checks :cpu_usage, 
+        #   :every => 10, 
+        #   :below => 0.5, 
+        #   :times => [5, 5]
+        
+        # child_process.checks :mem_usage, 
+        #   :every => 3, 
+        #   :below => 600.kilobytes, 
+        #   :times => [3, 5], 
+        #   :fires => [:stop]
+        
+        child_process.stop_command = "kill -QUIT {{PID}}"
+        # child_process.checks :flapping, :times => 2, :within => 30.seconds, :retry_in => 7.seconds
+      end
+    end
+  end
+  
+  0.times do |i|
+    app.process("group_process_#{i}") do |process|
+      process.group = "group_1"
+      process.pid_file = "/Users/rohith/ffs/tmp/pids/mongrel_#{i}.pid"
+      process.start_command = "cd ~/ffs && mongrel_rails start -P #{process.pid_file} -p 3000 -d"
+      
+      process.start_grace_time = 10.seconds
+      
+      process.uid = "rohith"
+      process.gid = "staff"
+      
+      # process.checks :always_true, :every => 10
+    end
+  end
+  
+  1.times do |i|
+    app.process("group_process_#{i}") do |process|
+      process.uid = "rohith"
+      process.gid = "wheel"
+
+      process.stderr = "/tmp/err.log"      
+      process.stdout = "/tmp/err.log"
+
+      
+      process.group = "grouped"
+      process.start_command = %Q{cd /tmp && ruby -e '$stderr.puts("hello stderr");$stdout.puts("hello stdout"); $stdout.flush; $stderr.flush; sleep 10'}
+      process.daemonize = true
+      process.pid_file = "/tmp/noperm/p_#{process.group}_#{i}.pid"
+      
+      # process.checks :always_true, :every => 5
+    end
+  end
+end

data/lib/runit_example.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'bluepill'
+require 'logger'
+
+# ATTENTION:
+# You must declare only one application per config when foreground mode specified
+#
+# http://github.com/akzhan/runit-man used as example of monitored application.
+
+Bluepill.application(:runit_man, :foreground => true) do |app|
+  app.process("runit-man") do |process|
+    process.pid_file = "/etc/service/runit-man/supervise/pid"
+      
+    process.start_command   = "/usr/bin/sv start runit-man"
+    process.stop_command    = "/usr/bin/sv stop runit-man"
+    process.restart_command = "/usr/bin/sv restart runit-man"
+      
+    process.start_grace_time   = 1.seconds
+    process.restart_grace_time = 7.seconds
+    process.stop_grace_time    = 7.seconds
+
+    process.checks :http, :within => 30.seconds, :retry_in => 7.seconds, :every => 30.seconds,
+      :url => 'http://localhost:4567/', :kind => :success, :pattern => /html/, :timeout => 3.seconds
+  end
+end

data/ra-bluepill.gemspec

@@ -0,0 +1,82 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ra-bluepill}
+  s.version = "0.0.44"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Arya Asemanfar", "Gary Tsang", "Rohith Ravi"]
+  s.date = %q{2011-02-09}
+  s.default_executable = %q{bluepill}
+  s.description = %q{Bluepill keeps your daemons up while taking up as little resources as possible. After all you probably want the resources of your server to be used by whatever daemons you are running rather than the thing that's supposed to make sure they are brought back up, should they die or misbehave.}
+  s.email = %q{entombedvirus@gmail.com}
+  s.executables = ["bluepill"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.md"
+  ]
+  s.files = [
+    "DESIGN.md",
+    "LICENSE",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "bin/bluepill",
+    "bin/bpsv",
+    "lib/bluepill.rb",
+    "lib/bluepill/application.rb",
+    "lib/bluepill/application/client.rb",
+    "lib/bluepill/application/server.rb",
+    "lib/bluepill/condition_watch.rb",
+    "lib/bluepill/controller.rb",
+    "lib/bluepill/dsl.rb",
+    "lib/bluepill/group.rb",
+    "lib/bluepill/logger.rb",
+    "lib/bluepill/process.rb",
+    "lib/bluepill/process_conditions.rb",
+    "lib/bluepill/process_conditions/always_true.rb",
+    "lib/bluepill/process_conditions/cpu_usage.rb",
+    "lib/bluepill/process_conditions/http.rb",
+    "lib/bluepill/process_conditions/mem_usage.rb",
+    "lib/bluepill/process_conditions/process_condition.rb",
+    "lib/bluepill/process_statistics.rb",
+    "lib/bluepill/socket.rb",
+    "lib/bluepill/system.rb",
+    "lib/bluepill/trigger.rb",
+    "lib/bluepill/triggers/flapping.rb",
+    "lib/bluepill/util/rotational_array.rb",
+    "lib/bluepill/version.rb",
+    "lib/example.rb",
+    "lib/runit_example.rb",
+    "ra-bluepill.gemspec"
+  ]
+  s.homepage = %q{http://github.com/arya/bluepill}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.5.0}
+  s.summary = %q{A process monitor written in Ruby with stability and minimalism in mind.}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<daemons>, [">= 1.0.9"])
+      s.add_runtime_dependency(%q<blankslate>, [">= 2.1.2.2"])
+      s.add_runtime_dependency(%q<state_machine>, [">= 0.8.0"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 2.3.4"])
+    else
+      s.add_dependency(%q<daemons>, [">= 1.0.9"])
+      s.add_dependency(%q<blankslate>, [">= 2.1.2.2"])
+      s.add_dependency(%q<state_machine>, [">= 0.8.0"])
+      s.add_dependency(%q<activesupport>, [">= 2.3.4"])
+    end
+  else
+    s.add_dependency(%q<daemons>, [">= 1.0.9"])
+    s.add_dependency(%q<blankslate>, [">= 2.1.2.2"])
+    s.add_dependency(%q<state_machine>, [">= 0.8.0"])
+    s.add_dependency(%q<activesupport>, [">= 2.3.4"])
+  end
+end
+

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification 
+name: ra-bluepill
+version: !ruby/object:Gem::Version 
+  hash: 71
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 44
+  version: 0.0.44
+platform: ruby
+authors: 
+- Arya Asemanfar
+- Gary Tsang
+- Rohith Ravi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-09 00:00:00 -02:00
+default_executable: bluepill
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: daemons
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 1
+        - 0
+        - 9
+        version: 1.0.9
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: blankslate
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 107
+        segments: 
+        - 2
+        - 1
+        - 2
+        - 2
+        version: 2.1.2.2
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: state_machine
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 63
+        segments: 
+        - 0
+        - 8
+        - 0
+        version: 0.8.0
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 3
+        - 4
+        version: 2.3.4
+  type: :runtime
+  version_requirements: *id004
+description: Bluepill keeps your daemons up while taking up as little resources as possible. After all you probably want the resources of your server to be used by whatever daemons you are running rather than the thing that's supposed to make sure they are brought back up, should they die or misbehave.
+email: entombedvirus@gmail.com
+executables: 
+- bluepill
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- DESIGN.md
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- bin/bluepill
+- bin/bpsv
+- lib/bluepill.rb
+- lib/bluepill/application.rb
+- lib/bluepill/application/client.rb
+- lib/bluepill/application/server.rb
+- lib/bluepill/condition_watch.rb
+- lib/bluepill/controller.rb
+- lib/bluepill/dsl.rb
+- lib/bluepill/group.rb
+- lib/bluepill/logger.rb
+- lib/bluepill/process.rb
+- lib/bluepill/process_conditions.rb
+- lib/bluepill/process_conditions/always_true.rb
+- lib/bluepill/process_conditions/cpu_usage.rb
+- lib/bluepill/process_conditions/http.rb
+- lib/bluepill/process_conditions/mem_usage.rb
+- lib/bluepill/process_conditions/process_condition.rb
+- lib/bluepill/process_statistics.rb
+- lib/bluepill/socket.rb
+- lib/bluepill/system.rb
+- lib/bluepill/trigger.rb
+- lib/bluepill/triggers/flapping.rb
+- lib/bluepill/util/rotational_array.rb
+- lib/bluepill/version.rb
+- lib/example.rb
+- lib/runit_example.rb
+- ra-bluepill.gemspec
+has_rdoc: true
+homepage: http://github.com/arya/bluepill
+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.5.0
+signing_key: 
+specification_version: 3
+summary: A process monitor written in Ruby with stability and minimalism in mind.
+test_files: []
+