bluepill 0.0.68 → 0.0.69

data/examples/new_runit_example.rb

@@ -1,29 +0,0 @@
-#! /usr/bin/env ruby
-require 'rubygems'
-require 'bluepill'
-require 'logger'
-
-# ATTENTION:
-# You must declare only one application per config when foreground mode specified
-#
-# http://github.com/Undev/runit-man used as example of monitored application.
-
-# Note that this syntax supported from bluepill 0.0.50
-
-Bluepill.application(:runit_man, :foreground => true) do
-  process("runit-man") do
-    pid_file        "/etc/service/runit-man/supervise/pid"
-
-    start_command   "/usr/bin/sv start runit-man"
-    stop_command    "/usr/bin/sv stop runit-man"
-    restart_command "/usr/bin/sv restart runit-man"
-
-    start_grace_time   1.seconds
-    restart_grace_time 7.seconds
-    stop_grace_time    7.seconds
-
-    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/examples/runit_example.rb

@@ -1,26 +0,0 @@
-#! /usr/bin/env ruby
-require 'rubygems'
-require 'bluepill'
-require 'logger'
-
-# ATTENTION:
-# You must declare only one application per config when foreground mode specified
-#
-# http://github.com/Undev/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/local-bluepill

@@ -1,130 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'rubygems'
-require 'bundler/setup'
-$LOAD_PATH.unshift(File.expand_path('lib', File.dirname(__FILE__)))
-
-require 'optparse'
-require 'bluepill'
-
-begin
-  require 'rbconfig'
-rescue LoadError
-end
-
-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"),
-  :privileged => true,
-  :timeout    => 10,
-  :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|
-    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|
-    options[:base_dir] = base_dir
-  end
-
-  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|
-    options[:privileged] = v
-  end
-
-  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|
-    options[:attempts] = attempts
-  end
-
-  help = proc do
-    puts opts
-    puts
-    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"
-    puts "    stop [TARGET]\t\tIssues the stop command for the target process or group, defaults to all processes"
-    puts "    restart [TARGET]\t\tIssues the restart command for the target process or group, defaults to all processes"
-    puts "    unmonitor [TARGET]\t\tStop monitoring target process or group, defaults to all processes"
-    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"
-    exit
-  end
-
-  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."
-  exit(3)
-end
-
-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)
-  # bluepill was called as a symlink with the name of the target application
-  options[:application] = File.basename($0)
-elsif controller.running_applications.include?(ARGV.first)
-  # the first arg is the application name
-  options[:application] = ARGV.shift
-elsif APPLICATION_COMMANDS.include?(ARGV.first)
-  if controller.running_applications.length == 1
-    # there is only one, let's just use that
-    options[:application] = controller.running_applications.first
-  elsif controller.running_applications.length > 1
-    # There is more than one, tell them the list and exit
-    $stderr.puts "You must specify an application name to run that command. Here's the list of running applications:"
-    controller.running_applications.each_with_index do |app, index|
-      $stderr.puts "  #{index + 1}. #{app}"
-    end
-    $stderr.puts "Usage: bluepill [app] cmd [options]"
-    exit(1)
-  else
-    # There are none running AND they aren't trying to start one
-    $stderr.puts "Error: There are no running bluepill daemons.\nTo start a bluepill daemon, use: bluepill load <config file>"
-    exit(2)
-  end
-end
-
-options[:command] = ARGV.shift
-
-if options[:command] == "load"
-  file = ARGV.shift
-  if File.exists?(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'])
-    load_path = File.expand_path("#{File.dirname(__FILE__)}/lib")
-    file_path = File.expand_path(file)
-    ENV['BLUEPILL_BASE_DIR'] = options[:base_dir]
-
-    exec(ruby, "-I#{load_path}", '-rbluepill', file_path)
-
-  else
-    $stderr.puts "Can't find file: #{file}"
-  end
-else
-  target = ARGV.shift
-  controller.handle_command(options[:application], options[:command], target)
-end
-

data/spec/lib/bluepill/application_spec.rb

@@ -1,51 +0,0 @@
-describe Bluepill::Application do
-  describe "#initialize" do
-    let(:options){ {} }
-    subject {described_class.new('test', options)}
-    before(:each) {expect_any_instance_of(described_class).to receive(:setup_pids_dir)}
-
-    context "when euid is not root" do
-      before(:each) {allow(::Process).to receive(:euid).and_return(1)}
-
-      describe '#base_dir' do
-        subject { super().base_dir }
-        it{ should eq(File.join(ENV['HOME'], '.bluepill')) }
-      end
-    end
-    context "when euid is root" do
-      before(:each) {allow(::Process).to receive(:euid).and_return(0)}
-
-      describe '#base_dir' do
-        subject { super().base_dir }
-        it { should eq('/var/run/bluepill') }
-      end
-    end
-
-    context "when option base_dir is specified" do
-      let(:options) { {:base_dir=>'/var/bluepill'} }
-
-      describe '#base_dir' do
-        subject { super().base_dir }
-        it { should eq(options[:base_dir]) }
-      end
-    end
-
-    context "when environment BLUEPILL_BASE_DIR is specified" do
-      before(:each) {ENV['BLUEPILL_BASE_DIR'] = '/bluepill'}
-
-      describe '#base_dir' do
-        subject { super().base_dir }
-        it { should eq(ENV['BLUEPILL_BASE_DIR']) }
-      end
-
-      context "and option base_dir is specified" do
-        let(:options) { {:base_dir=>'/var/bluepill'} }
-
-        describe '#base_dir' do
-          subject { super().base_dir }
-          it { should eq(options[:base_dir]) }
-        end
-      end
-    end
-  end
-end

data/spec/lib/bluepill/logger_spec.rb

@@ -1,3 +0,0 @@
-describe Bluepill::Logger do
-
-end

data/spec/lib/bluepill/process_spec.rb

@@ -1,135 +0,0 @@
-describe Bluepill::Process do
-  before(:all) do
-    Bluepill::ProcessJournal.base_dir = './.bluepill'
-    Bluepill::ProcessJournal.logger = Bluepill::Logger.new(:log_file => 'bluepill.log', :stdout => false).prefix_with('rspec')
-  end
-
-  subject do
-    Bluepill::Process.new(:proc_name, [], :logger => Bluepill::Logger.new)
-  end
-
-  describe "#initialize" do
-    context "defaults" do
-      [
-        :start_command, :stop_command, :restart_command, :stdout, :stderr, :stdin,
-        :daemonize, :pid_file, :working_dir, :uid, :gid, :child_process_factory,
-        :pid_command, :auto_start, :supplementary_groups, :stop_signals
-      ].each do |attr|
-        describe attr do
-          subject { super().send(attr) }
-          it { should be_nil }
-        end
-      end
-
-      describe '#monitor_children' do
-        subject { super().monitor_children }
-        it { should be false }
-      end
-
-      describe '#cache_actual_pid' do
-        subject { super().cache_actual_pid }
-        it { should be true }
-      end
-
-      describe '#start_grace_time' do
-        subject { super().start_grace_time }
-        it { should eq 3 }
-      end
-
-      describe '#stop_grace_time' do
-        subject { super().stop_grace_time }
-        it { should eq 3 }
-      end
-
-      describe '#restart_grace_time' do
-        subject { super().restart_grace_time }
-        it { should eq 3 }
-      end
-
-      describe '#on_start_timeout' do
-        subject { super().on_start_timeout }
-        it { should eq "start" }
-      end
-
-      describe '#environment' do
-        subject { super().environment }
-        it { should eq Hash[] }
-      end
-    end
-
-    context "overrides" do
-      subject { Bluepill::Process.new(:proc_name, [], :start_grace_time => 17) }
-
-      describe '#start_grace_time' do
-        subject { super().start_grace_time }
-        it { should eq 17 }
-      end
-    end
-  end
-
-  describe "#start_process" do
-    it "functions" do
-      allow(subject).to receive(:start_command) { "/etc/init.d/script start" }
-      allow(subject).to receive(:on_start_timeout) { "freakout" }
-      allow(subject.logger).to receive(:warning)
-      allow(subject).to receive(:daemonize?) { false }
-
-      expect(subject).to receive(:with_timeout).
-        with(3, "freakout").
-        and_yield
-
-      expect(Bluepill::System).to receive(:execute_blocking).
-        with("/etc/init.d/script start", subject.system_command_options).
-        and_return(:exit_code => 0)
-
-      subject.start_process
-    end
-
-    describe "#stop_process" do
-      it "functions" do
-        allow(subject).to receive(:stop_command) { "/etc/init.d/script stop" }
-        allow(subject.logger).to receive(:warning)
-        expect(subject).to receive(:with_timeout).
-          with(3, "stop").
-          and_yield
-
-        expect(Bluepill::System).to receive(:execute_blocking).
-          with("/etc/init.d/script stop", subject.system_command_options).
-          and_return(:exit_code => 0)
-
-        subject.stop_process
-      end
-    end
-
-    describe "#restart_process" do
-      it "functions" do
-        allow(subject).to receive(:restart_command) { "/etc/init.d/script restart" }
-        allow(subject.logger).to receive(:warning)
-        expect(subject).to receive(:with_timeout).
-          with(3, "restart").
-          and_yield
-
-        expect(Bluepill::System).to receive(:execute_blocking).
-          with("/etc/init.d/script restart", subject.system_command_options).
-          and_return(:exit_code => 0)
-
-        subject.restart_process
-      end
-    end
-  end
-
-  describe "#with_timeout" do
-    let(:block) { proc { nil } }
-
-    before(:each) do
-      allow(subject.logger).to receive(:err)
-      expect(Timeout).to receive(:timeout).with(3.to_f, &block).and_raise(Timeout::Error)
-    end
-
-    it "proceeds to next_state on timeout." do
-      expect(subject).to receive(:dispatch!).with("state_override")
-      subject.with_timeout(3, "state_override", &block)
-    end
-  end
-
-end

data/spec/lib/bluepill/process_statistics_spec.rb

@@ -1,24 +0,0 @@
-describe Bluepill::ProcessStatistics do
-  before(:each) do
-    @stats = Bluepill::ProcessStatistics.new
-  end
-
-  it "should record events" do
-    @stats.record_event('some event', 'some reason')
-    @stats.record_event('another event', 'another reason')
-    expect(@stats.events.size).to eq(2)
-  end
-
-  it "should record #EVENTS_TO_PERSIST events" do
-    (2 * Bluepill::ProcessStatistics::EVENTS_TO_PERSIST).times do
-      @stats.record_event('some event', 'some reason')
-    end
-    expect(@stats.events.size).to eq(Bluepill::ProcessStatistics::EVENTS_TO_PERSIST)
-  end
-
-  it "should return event history" do
-    @stats.record_event('some event', 'some reason')
-    expect(@stats.to_s).to match(/some reason/)
-    expect(@stats.to_s).to match(/event history/)
-  end
-end

data/spec/lib/bluepill/system_spec.rb

@@ -1,45 +0,0 @@
-describe Bluepill::System do
-  describe :pid_alive? do
-    it "should be true if process responds to zero signal" do
-      expect(Process).to receive(:kill).with(0, 555).and_return(0)
-      expect(Bluepill::System).to be_pid_alive(555)
-    end
-
-    it "should be false if process throws exception on zero signal" do
-      expect(Process).to receive(:kill).with(0, 555).and_raise(Errno::ESRCH)
-      expect(Bluepill::System).not_to be_pid_alive(555)
-    end
-  end
-
-  describe :store do
-    it "should be Hash" do
-      expect(Bluepill::System.store).to be_kind_of(Hash)
-    end
-
-    it "should return same Hash or every call" do
-      expect(Bluepill::System.store).to be_equal(Bluepill::System.store)
-    end
-
-    it "should store assigned pairs" do
-      Bluepill::System.store[:somekey] = 10
-      expect(Bluepill::System.store[:somekey]).to be_eql(10)
-    end
-  end
-
-  describe :reset_data do
-    it 'should clear the #store' do
-      Bluepill::System.store[:anotherkey] = Faker::Lorem.sentence
-      Bluepill::System.reset_data
-      expect(Bluepill::System.store).to be_empty
-    end
-  end
-
-  describe :parse_etime do
-    it "should parse etime format" do
-      expect(Bluepill::System.parse_elapsed_time("400-00:04:01")).to be_equal(34560241)
-      expect(Bluepill::System.parse_elapsed_time("02:04:02")).to be_equal(7442)
-      expect(Bluepill::System.parse_elapsed_time("20:03")).to be_equal(1203)
-      expect(Bluepill::System.parse_elapsed_time("invalid")).to be_equal(0)
-    end
-  end
-end