bluepill 0.0.68 → 0.0.69

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 35f98731b6e37b345dc0abd6c97ef152004b7c1e
-  data.tar.gz: e2a074334d09655a98797944a70d582fd712b295
+  metadata.gz: a28c6400321b02c8c806845c00a44e1a03502fc7
+  data.tar.gz: ae9f9810c4ace92872bed2f54c8e76a7597e480a
 SHA512:
-  metadata.gz: a6f3a92d2d04bb5ecc994882039cfdf56039315dbd0a869b7a2756a137367f7feaa62e7b396fcd03f5d1d5f78b3b033862da0338e60a33722287e0fa19296fc8
-  data.tar.gz: a9642dd51a9fa311b03e2b8b175e18e2a792c1d360886590330c6c36f8fa11b568e7662fe9929f429c1e7edc2602ab68ba0c418fde838f68a37529ccefda31c2
+  metadata.gz: dbffdf158f85bf0d606472a3bddd9045453b4aac4c57c0b46104b37f15b78a929885a58a51d90ab72ccf4ad39908407343abced61c4a19b0c64679d945ab641c
+  data.tar.gz: b421ac8a82226cb41c02f50ed528fdcb18e5e425835863c47721bd9c6c65520242221608aa6dedd67939218c112d2ef54e13e32d48376cfefe8a9e2199d42c4b

data/README.md

@@ -371,10 +371,9 @@ This library aims to support and is [tested against][travis] the following Ruby
 implementations:
 
 * Ruby 1.8.7
-* Ruby 1.9.2
 * Ruby 1.9.3
 * Ruby 2.0.0
-* Ruby 2.1.0
+* Ruby 2.1
 * [JRuby][]
 * [Rubinius][]
 

data/bin/bluepill

@@ -11,44 +11,44 @@ RbConfig = Config unless Object.const_defined?(:RbConfig)
 
 # Default options
 options = {
-  :log_file   => "/var/log/bluepill.log",
-  :base_dir   => ENV['BLUEPILL_BASE_DIR'] || (::Process.euid != 0 ? File.join(ENV['HOME'], '.bluepill') : "/var/run/bluepill"),
+  :log_file   => '/var/log/bluepill.log',
+  :base_dir   => ENV['BLUEPILL_BASE_DIR'] || (::Process.euid != 0 ? File.join(ENV['HOME'], '.bluepill') : '/var/run/bluepill'),
   :privileged => true,
   :timeout    => 10,
-  :attempts   => 1
+  :attempts   => 1,
 }
 
 OptionParser.new do |opts|
-  opts.banner = "Usage: bluepill [app] cmd [options]"
-  opts.on('-l', "--logfile LOGFILE", "Path to logfile, defaults to #{options[:log_file]}") do |file|
+  opts.banner = 'Usage: bluepill [app] cmd [options]'
+  opts.on('-l', '--logfile LOGFILE', "Path to logfile, defaults to #{options[:log_file]}") do |file|
     options[:log_file] = file
   end
 
-  opts.on('-c', "--base-dir DIR", "Directory to store bluepill socket and pid files, defaults to #{options[:base_dir]}") do |base_dir|
+  opts.on('-c', '--base-dir DIR', "Directory to store bluepill socket and pid files, defaults to #{options[:base_dir]}") do |base_dir|
     options[:base_dir] = base_dir
   end
 
-  opts.on("-v", "--version") do
+  opts.on('-v', '--version') do
     puts "bluepill, version #{Bluepill::VERSION}"
     exit
   end
 
-  opts.on("--[no-]privileged", "Allow/disallow to run #{$0} as non-privileged process. disallowed by default") do |v|
+  opts.on('--[no-]privileged', "Allow/disallow to run #{$PROGRAM_NAME} as non-privileged process. disallowed by default") do |v|
     options[:privileged] = v
   end
 
-  opts.on('-t', '--timeout Seconds', Integer, "Timeout for commands sent to the daemon, in seconds. Defaults to 10.") do |timeout|
+  opts.on('-t', '--timeout Seconds', Integer, 'Timeout for commands sent to the daemon, in seconds. Defaults to 10.') do |timeout|
     options[:timeout] = timeout
   end
 
-  opts.on('--attempts Count', Integer, "Attempts for commands sent to the daemon, in seconds. Defaults to 1.") do |attempts|
+  opts.on('--attempts Count', Integer, 'Attempts for commands sent to the daemon, in seconds. Defaults to 1.') do |attempts|
     options[:attempts] = attempts
   end
 
   help = proc do
     puts opts
     puts
-    puts "Commands:"
+    puts 'Commands:'
     puts "    load CONFIG_FILE\t\tLoads new instance of bluepill using the specified config file"
     puts "    status\t\t\tLists the status of the proceses for the specified app"
     puts "    start [TARGET]\t\tIssues the start command for the target process or group, defaults to all processes"
@@ -58,17 +58,17 @@ OptionParser.new do |opts|
     puts "    log [TARGET]\t\tShow the log for the specified process or group, defaults to all for app"
     puts "    quit\t\t\tStop bluepill"
     puts
-    puts "See http://github.com/bluepill-rb/bluepill#readme"
+    puts 'See http://github.com/bluepill-rb/bluepill#readme'
     exit
   end
 
-  opts.on_tail('-h','--help', 'Show this message', &help)
+  opts.on_tail('-h', '--help', 'Show this message', &help)
   help.call if ARGV.empty?
 end.parse!
 
 # Check for root
 if options[:privileged] && ::Process.euid != 0
-  $stderr.puts "You must run bluepill as root or use --no-privileged option."
+  $stderr.puts 'You must run bluepill as root or use --no-privileged option.'
   exit(3)
 end
 
@@ -76,9 +76,9 @@ APPLICATION_COMMANDS = %w(status start stop restart unmonitor quit log)
 
 controller = Bluepill::Controller.new(options.slice(:base_dir, :log_file))
 
-if controller.running_applications.include?(File.basename($0)) && File.symlink?($0)
+if controller.running_applications.include?(File.basename($PROGRAM_NAME)) && File.symlink?($PROGRAM_NAME)
   # bluepill was called as a symlink with the name of the target application
-  options[:application] = File.basename($0)
+  options[:application] = File.basename($PROGRAM_NAME)
 elsif controller.running_applications.include?(ARGV.first)
   # the first arg is the application name
   options[:application] = ARGV.shift
@@ -92,7 +92,7 @@ elsif APPLICATION_COMMANDS.include?(ARGV.first)
     controller.running_applications.each_with_index do |app, index|
       $stderr.puts "  #{index + 1}. #{app}"
     end
-    $stderr.puts "Usage: bluepill [app] cmd [options]"
+    $stderr.puts 'Usage: bluepill [app] cmd [options]'
     exit(1)
   else
     # There are none running AND they aren't trying to start one
@@ -103,9 +103,9 @@ end
 
 options[:command] = ARGV.shift
 
-if options[:command] == "load"
+if options[:command] == 'load'
   file = ARGV.shift
-  if File.exists?(file)
+  if File.exist?(file)
     # Restart the ruby interpreter for the config file so that anything loaded here
     # does not stay in memory for the daemon
     ruby = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
@@ -122,4 +122,3 @@ else
   target = ARGV.shift
   controller.handle_command(options[:application], options[:command], target)
 end
-

data/bin/sample_forking_server

@@ -15,7 +15,7 @@
 require 'socket'
 
 port = ARGV[0].to_i
-port = 4242 if port == 0
+port = 4242 if port.zero?
 
 acceptor = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
 address = Socket.pack_sockaddr_in(port, '127.0.0.1')
@@ -23,31 +23,44 @@ acceptor.bind(address)
 acceptor.listen(10)
 
 children = []
-trap('EXIT') { acceptor.close; children.each {|c| Process.kill('QUIT', c)} }
-
+trap('EXIT') do
+  acceptor.close
+  children.each { |c| Process.kill('QUIT', c) }
+end
 
 3.times do
   children << fork do
-    trap('QUIT') {$0 = "forking_server| QUIT received shutting down gracefully..."; sleep 5; exit}
-    trap('INT') {$0 = "forking_server| INT received shutting down UN-gracefully..."; sleep 3; exit}
+    trap('QUIT') do
+      $0 = 'forking_server| QUIT received shutting down gracefully...'
+      sleep 5
+      exit
+    end
+    trap('INT') do
+      $0 = 'forking_server| INT received shutting down UN-gracefully...'
+      sleep 3
+      exit
+    end
 
-    puts "child #$$ accepting on shared socket (localhost:#{port})"
-    loop {
-      socket, addr = acceptor.accept
-      socket.write "child #$$ echo> "
+    puts "child #{$PROCESS_ID} accepting on shared socket (localhost:#{port})"
+    loop do
+      socket, _ = acceptor.accept
+      socket.write "child #{$PROCESS_ID} echo> "
       socket.flush
       message = socket.gets
       socket.write message
       socket.close
-      puts "child #$$ echo'd: '#{message.strip}'"
+      puts "child #{$PROCESS_ID} echo'd: '#{message.strip}'"
 
       # cause a spike in mem usage
-      temp = "*" * (100 * 1024)
-    }
+      '*' * 2**20
+    end
     exit
   end
 end
 
-trap('INT') { puts "\nbailing" ; exit }
+trap('INT') do
+  puts "\nbailing"
+  exit
+end
 
 Process.waitall

data/bluepill.gemspec

@@ -1,31 +1,25 @@
-# -*- encoding: utf-8 -*-
-
-$LOAD_PATH.push File.expand_path("../lib", __FILE__)
-
-require "bluepill/version"
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bluepill/version'
 
 Gem::Specification.new do |s|
-  s.name        = "bluepill"
+  s.name        = 'bluepill'
   s.version     = Bluepill::VERSION.dup
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Arya Asemanfar", "Gary Tsang", "Rohith Ravi"]
-  s.email       = ["entombedvirus@gmail.com"]
-  s.homepage    = "http://github.com/bluepill-rb/bluepill"
-  s.summary     = %q{A process monitor written in Ruby with stability and minimalism in mind.}
-  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.authors     = ['Arya Asemanfar', 'Gary Tsang', 'Rohith Ravi']
+  s.email       = ['entombedvirus@gmail.com']
+  s.homepage    = 'http://github.com/bluepill-rb/bluepill'
+  s.summary     = 'A process monitor written in Ruby with stability and minimalism in mind.'
+  s.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."
   s.license     = 'MIT'
 
   s.add_dependency 'activesupport', ['>= 3', '< 5']
   s.add_dependency 'blue-daemons', '~> 1.1.11'
   s.add_dependency 'i18n', '~> 0.5'
   s.add_dependency 'state_machine', '~> 1.1'
-
   s.add_development_dependency 'bundler', '~> 1.3'
 
-  s.files            = `git ls-files`.split("\n")
-  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths    = ["lib"]
-  s.extra_rdoc_files = ["LICENSE", "README.md"]
+  s.files            = %w(CONTRIBUTING.md DESIGN.md LICENSE README.md bluepill.gemspec) + Dir['bin/*'] + Dir['lib/**/*.rb']
+  s.executables      = Dir['bin/*'].map { |f| File.basename(f) }
+  s.require_paths    = ['lib']
 end
-

data/lib/bluepill.rb

@@ -1,7 +1,6 @@
-# -*- encoding: utf-8 -*-
 require 'rubygems'
 
-require 'bundler/setup' if ENV['BUNDLE_GEMFILE'] && File.exists?(ENV['BUNDLE_GEMFILE'])
+require 'bundler/setup' if ENV['BUNDLE_GEMFILE'] && File.exist?(ENV['BUNDLE_GEMFILE'])
 
 require 'thread'
 require 'monitor'
@@ -9,6 +8,7 @@ require 'syslog'
 require 'timeout'
 require 'logger'
 
+require 'active_support'
 require 'active_support/inflector'
 require 'active_support/core_ext/hash'
 require 'active_support/core_ext/numeric'
@@ -21,18 +21,18 @@ require 'bluepill/dsl/app_proxy'
 require 'bluepill/application'
 require 'bluepill/controller'
 require 'bluepill/socket'
-require "bluepill/process"
-require "bluepill/process_statistics"
-require "bluepill/group"
-require "bluepill/logger"
-require "bluepill/condition_watch"
+require 'bluepill/process'
+require 'bluepill/process_statistics'
+require 'bluepill/group'
+require 'bluepill/logger'
+require 'bluepill/condition_watch'
 require 'bluepill/trigger'
 require 'bluepill/triggers/flapping'
-require "bluepill/dsl"
-require "bluepill/system"
+require 'bluepill/dsl'
+require 'bluepill/system'
 
-require "bluepill/process_conditions"
+require 'bluepill/process_conditions'
 
-require "bluepill/util/rotational_array"
+require 'bluepill/util/rotational_array'
 
-require "bluepill/version"
+require 'bluepill/version'

data/lib/bluepill/application.rb

@@ -1,4 +1,3 @@
-# -*- encoding: utf-8 -*-
 require 'thread'
 require 'bluepill/system'
 require 'bluepill/process_journal'
@@ -18,17 +17,17 @@ module Bluepill
       self.log_file = options[:log_file]
       self.base_dir = ProcessJournal.base_dir = options[:base_dir] ||
         ENV['BLUEPILL_BASE_DIR'] ||
-        (::Process.euid != 0 ? File.join(ENV['HOME'], '.bluepill') : "/var/run/bluepill")
-      self.pid_file = File.join(self.base_dir, 'pids', self.name + ".pid")
-      self.pids_dir = File.join(self.base_dir, 'pids', self.name)
+        (::Process.euid != 0 ? File.join(ENV['HOME'], '.bluepill') : '/var/run/bluepill')
+      self.pid_file = File.join(base_dir, 'pids', self.name + '.pid')
+      self.pids_dir = File.join(base_dir, 'pids', self.name)
       self.kill_timeout = options[:kill_timeout] || 10
 
       self.groups = {}
 
-      self.logger = ProcessJournal.logger = Bluepill::Logger.new(:log_file => self.log_file, :stdout => foreground?).prefix_with(self.name)
+      self.logger = ProcessJournal.logger = Bluepill::Logger.new(:log_file => log_file, :stdout => foreground?).prefix_with(self.name)
 
-      self.setup_signal_traps
-      self.setup_pids_dir
+      setup_signal_traps
+      setup_pids_dir
 
       @mutex = Mutex.new
     end
@@ -42,14 +41,12 @@ module Bluepill
     end
 
     def load
-      begin
-        self.start_server
-      rescue StandardError => e
-        $stderr.puts "Failed to start bluepill:"
-        $stderr.puts "%s `%s`" % [e.class.name, e.message]
-        $stderr.puts e.backtrace
-        exit(5)
-      end
+      start_server
+    rescue StandardError => e
+      $stderr.puts('Failed to start bluepill:')
+      $stderr.puts(format('%s `%s`', e.class.name, e.message))
+      $stderr.puts(e.backtrace)
+      exit(5)
     end
 
     PROCESS_COMMANDS.each do |command|
@@ -63,26 +60,27 @@ module Bluepill
     def add_process(process, group_name = nil)
       group_name = group_name.to_s if group_name
 
-      self.groups[group_name] ||= Group.new(group_name, :logger => self.logger.prefix_with(group_name))
-      self.groups[group_name].add_process(process)
+      groups[group_name] ||= Group.new(group_name, :logger => logger.prefix_with(group_name))
+      groups[group_name].add_process(process)
     end
 
     def version
       Bluepill::VERSION
     end
 
-    protected
+  protected
+
     def send_to_process_or_group(method, group_name, process_name)
       if group_name.nil? && process_name.nil?
-        self.groups.values.collect do |group|
+        groups.values.collect do |group|
           group.send(method)
         end.flatten
-      elsif self.groups.key?(group_name)
-        self.groups[group_name].send(method, process_name)
+      elsif groups.key?(group_name)
+        groups[group_name].send(method, process_name)
       elsif process_name.nil?
         # they must be targeting just by process name
         process_name = group_name
-        self.groups.values.collect do |group|
+        groups.values.collect do |group|
           group.send(method, process_name)
         end.flatten
       else
@@ -95,18 +93,18 @@ module Bluepill
       @listener_thread = Thread.new do
         loop do
           begin
-            client = self.socket.accept
+            client = socket.accept
             client.close_on_exec = true  if client.respond_to?(:close_on_exec=)
-            command, *args = client.readline.strip.split(":")
+            command, *args = client.readline.strip.split(':')
             response = begin
-              mutex { self.send(command, *args) }
-            rescue Exception => e
+              mutex { send(command, *args) }
+            rescue => e
               e
             end
             client.write(Marshal.dump(response))
           rescue StandardError => e
-            logger.err("Got exception in cmd listener: %s `%s`" % [e.class.name, e.message])
-            e.backtrace.each {|l| logger.err(l)}
+            logger.err(format('Got exception in cmd listener: %s `%s`', e.class.name, e.message))
+            e.backtrace.each { |l| logger.err(l) }
           ensure
             begin
               client.close
@@ -119,7 +117,7 @@ module Bluepill
     end
 
     def start_server
-      self.kill_previous_bluepill
+      kill_previous_bluepill
       ProcessJournal.kill_all_from_all_journals
       ProcessJournal.clear_all_atomic_fs_locks
 
@@ -130,18 +128,17 @@ module Bluepill
 
       Daemonize.daemonize unless foreground?
 
-      self.logger.reopen
+      logger.reopen
 
-      $0 = "bluepilld: #{self.name}"
+      $0 = "bluepilld: #{name}"
 
-      self.groups.each {|_, group| group.determine_initial_state }
+      groups.each { |_, group| group.determine_initial_state }
 
+      write_pid_file
+      self.socket = Bluepill::Socket.server(base_dir, name)
+      start_listener
 
-      self.write_pid_file
-      self.socket = Bluepill::Socket.server(self.base_dir, self.name)
-      self.start_listener
-
-      self.run
+      run
     end
 
     def run
@@ -149,7 +146,7 @@ module Bluepill
       while @running
         mutex do
           System.reset_data
-          self.groups.each { |_, group| group.tick }
+          groups.each { |_, group| group.tick }
         end
         sleep 1
       end
@@ -159,63 +156,59 @@ module Bluepill
       ProcessJournal.kill_all_from_all_journals
       ProcessJournal.clear_all_atomic_fs_locks
       begin
-        System.delete_if_exists(self.socket.path) if self.socket
+        System.delete_if_exists(socket.path) if socket
       rescue IOError
       end
-      System.delete_if_exists(self.pid_file)
+      System.delete_if_exists(pid_file)
     end
 
     def setup_signal_traps
-      terminator = Proc.new do
-        puts "Terminating..."
+      terminator = proc do
+        puts 'Terminating...'
         cleanup
         @running = false
       end
 
-      Signal.trap("TERM", &terminator)
-      Signal.trap("INT", &terminator)
+      Signal.trap('TERM', &terminator)
+      Signal.trap('INT', &terminator)
 
-      Signal.trap("HUP") do
-        self.logger.reopen if self.logger
+      Signal.trap('HUP') do
+        logger.reopen if logger
       end
     end
 
     def setup_pids_dir
-      FileUtils.mkdir_p(self.pids_dir) unless File.exists?(self.pids_dir)
+      FileUtils.mkdir_p(pids_dir) unless File.exist?(pids_dir)
       # we need everybody to be able to write to the pids_dir as processes managed by
       # bluepill will be writing to this dir after they've dropped privileges
-      FileUtils.chmod(0777, self.pids_dir)
+      FileUtils.chmod(0777, pids_dir)
     end
 
     def kill_previous_bluepill
-      if File.exists?(self.pid_file)
-        previous_pid = File.read(self.pid_file).to_i
-        if System.pid_alive?(previous_pid)
-          begin
-            ::Process.kill(0, previous_pid)
-            puts "Killing previous bluepilld[#{previous_pid}]"
-            ::Process.kill(2, previous_pid)
-          rescue Exception => e
-            $stderr.puts "Encountered error trying to kill previous bluepill:"
-            $stderr.puts "#{e.class}: #{e.message}"
-            exit(4) unless e.is_a?(Errno::ESRCH)
-          else
-            kill_timeout.times do |i|
-              sleep 0.5
-              break unless System.pid_alive?(previous_pid)
-            end
+      return unless File.exist?(pid_file)
+      previous_pid = File.read(pid_file).to_i
+      return unless System.pid_alive?(previous_pid)
+      ::Process.kill(0, previous_pid)
+      puts "Killing previous bluepilld[#{previous_pid}]"
+      ::Process.kill(2, previous_pid)
+    rescue => e
+      $stderr.puts 'Encountered error trying to kill previous bluepill:'
+      $stderr.puts "#{e.class}: #{e.message}"
+      exit(4) unless e.is_a?(Errno::ESRCH)
+    else
+      kill_timeout.times do |_i|
+        sleep 0.5
+        break unless System.pid_alive?(previous_pid)
+      end
 
-            if System.pid_alive?(previous_pid)
-              $stderr.puts "Previous bluepilld[#{previous_pid}] didn't die"
-              exit(4)
-            end
-          end
-        end
+      if System.pid_alive?(previous_pid)
+        $stderr.puts "Previous bluepilld[#{previous_pid}] didn't die"
+        exit(4)
       end
     end
 
     def write_pid_file
-      File.open(self.pid_file, 'w') { |x| x.write(::Process.pid) }
+      File.open(pid_file, 'w') { |x| x.write(::Process.pid) }
     end
   end
 end