evented_bluepill 0.0.47 → 0.0.50

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+## 0.0.50 (March 5, 2011)
+
+  * deprecate the use of bluepill, use evented\_bluepill instead
+  * internal refactoring
+  * updated dependencies
+
+## 0.0.47 (January 10, 2011)
+
+  * actually use the new evented code
+  * switched from jeweler to bundler for gem creation and dependency tracking
+
+## 0.0.46 (January 10, 2011)
+
+  * initial evented release

data/DESIGN.md

@@ -1,7 +1,7 @@
-## Bluepill Design
+## EventedBluepill Design
 Here are just some bullet points of the design. We'll add details later.
 
- * Each process monitors a single _application_, so you can have multiple bluepill processes on a system
+ * Each process monitors a single _application_, so you can have multiple evented\_bluepill processes on a system
  * Use rotational arrays for storing historical data for monitoring process conditions
  * Memo-ize output of _ps_ per tick as an optimization for applications with many processes
  * Use socket files to communicate between CLI and daemon

data/README.md

@@ -1,35 +1,35 @@
-# Bluepill
-Bluepill is a simple process monitoring tool written in Ruby. 
+# EventedBluepill
+EventedBluepill is a simple process monitoring tool written in Ruby. 
 
 ## Installation
 It's hosted on [gemcutter.org][gemcutter].
 
-    sudo gem install bluepill
+    sudo gem install evented_bluepill
     
 In order to take advantage of logging with syslog, you also need to setup your syslog to log the local6 facility. Edit the appropriate config file for your syslogger (/etc/syslog.conf for syslog) and add a line for local6:
 
-    local6.*          /var/log/bluepill.log
+    local6.*          /var/log/evented_bluepill.log
     
-You'll also want to add _/var/log/bluepill.log_ to _/etc/logrotate.d/syslog_ so that it gets rotated.
+You'll also want to add _/var/log/evented\_bluepill.log_ to _/etc/logrotate.d/syslog_ so that it gets rotated.
 
-Lastly, create the _/var/bluepill_ directory for bluepill to store its pid and sock files.
+Lastly, create the _/var/evented\_bluepill_ directory for evented\_bluepill to store its pid and sock files.
 
 ## Usage
 ### Config
-Bluepill organizes processes into 3 levels: application -> group -> process. Each process has a few attributes that tell bluepill how to start, stop, and restart it, where to look or put the pid file, what process conditions to monitor and the options for each of those.
+EventedBluepill organizes processes into 3 levels: application -> group -> process. Each process has a few attributes that tell evented\_bluepill how to start, stop, and restart it, where to look or put the pid file, what process conditions to monitor and the options for each of those.
 
 The minimum config file looks something like this:
 
-    Bluepill.application("app_name") do |app|
+    EventedBluepill.application("app_name") do |app|
       app.process("process_name") do |process|
         process.start_command = "/usr/bin/some_start_command"
         process.pid_file = "/tmp/some_pid_file.pid"
       end
     end
     
-Note that since we specified a PID file and start command, bluepill assumes the process will daemonize itself. If we wanted bluepill to daemonize it for us, we can do (note we still need to specify a PID file):
+Note that since we specified a PID file and start command, evented\_bluepill assumes the process will daemonize itself. If we wanted evented\_bluepill to daemonize it for us, we can do (note we still need to specify a PID file):
 
-    Bluepill.application("app_name") do |app|
+    EventedBluepill.application("app_name") do |app|
       app.process("process_name") do |process|
         process.start_command = "/usr/bin/some_start_command"
         process.pid_file = "/tmp/some_pid_file.pid"
@@ -41,7 +41,7 @@ If you don't specify a stop command, a TERM signal will be sent by default. Simi
 
 Now if we want to do something more meaningful, like actually monitor the process, we do:
 
-    Bluepill.application("app_name") do |app|
+    EventedBluepill.application("app_name") do |app|
       app.process("process_name") do |process|
         process.start_command = "/usr/bin/some_start_command"
         process.pid_file = "/tmp/some_pid_file.pid"
@@ -54,7 +54,7 @@ We added a line that checks every 10 seconds to make sure the cpu usage of this
 
 To watch memory usage, we just add one more line:
 
-    Bluepill.application("app_name") do |app|
+    EventedBluepill.application("app_name") do |app|
       app.process("process_name") do |process|
         process.start_command = "/usr/bin/some_start_command"
         process.pid_file = "/tmp/some_pid_file.pid"
@@ -64,9 +64,9 @@ To watch memory usage, we just add one more line:
       end
     end
     
-We can tell bluepill to give a process some grace time to start/stop/restart before resuming monitoring:
+We can tell evented\_bluepill to give a process some grace time to start/stop/restart before resuming monitoring:
 
-    Bluepill.application("app_name") do |app|
+    EventedBluepill.application("app_name") do |app|
       app.process("process_name") do |process|
         process.start_command = "/usr/bin/some_start_command"
         process.pid_file = "/tmp/some_pid_file.pid"
@@ -81,7 +81,7 @@ We can tell bluepill to give a process some grace time to start/stop/restart bef
 
 We can group processes by name:
 
-    Bluepill.application("app_name") do |app|
+    EventedBluepill.application("app_name") do |app|
       5.times do |i|
         app.process("process_name_#{i}") do |process|
           process.group = "mongrels"
@@ -93,7 +93,7 @@ We can group processes by name:
 
 If you want to run the process as someone other than root:
 
-    Bluepill.application("app_name") do |app|
+    EventedBluepill.application("app_name") do |app|
       app.process("process_name") do |process|
         process.start_command = "/usr/bin/some_start_command"
         process.pid_file = "/tmp/some_pid_file.pid"
@@ -107,7 +107,7 @@ If you want to run the process as someone other than root:
     
 You can also set an app-wide uid/gid:
 
-    Bluepill.application("app_name") do |app|
+    EventedBluepill.application("app_name") do |app|
       app.uid = "deploy"
       app.gid = "deploy"
       app.process("process_name") do |process|
@@ -122,7 +122,7 @@ To check for flapping:
     
 To set the working directory to _cd_ into when starting the command:
 
-    Bluepill.application("app_name") do |app|
+    EventedBluepill.application("app_name") do |app|
       app.process("process_name") do |process|
         process.start_command = "/usr/bin/some_start_command"
         process.pid_file = "/tmp/some_pid_file.pid"
@@ -133,7 +133,7 @@ To set the working directory to _cd_ into when starting the command:
 You can also have an app-wide working directory:
 
 
-    Bluepill.application("app_name") do |app|
+    EventedBluepill.application("app_name") do |app|
       app.working_dir = "/path/to/some_directory"
       app.process("process_name") do |process|
         process.start_command = "/usr/bin/some_start_command"
@@ -159,7 +159,7 @@ Note {{PID}} will be substituted for the pid of process in both the stop and res
 
 While you can specify shell tricks like the following in the start_command of a process:
     
-    Bluepill.application("app_name") do |app|
+    EventedBluepill.application("app_name") do |app|
       app.process("process_name") do |process|
         process.start_command = "cd /tmp/some_dir && SOME_VAR=1 /usr/bin/some_start_command > /tmp/server.log 2>&1"
         process.pid_file = "/tmp/some_pid_file.pid"
@@ -168,7 +168,7 @@ While you can specify shell tricks like the following in the start_command of a
     
 We recommend that you _not_ do that and instead use the config options to capture output from your daemons. Like so:
 
-    Bluepill.application("app_name") do |app|
+    EventedBluepill.application("app_name") do |app|
       app.process("process_name") do |process|
         process.start_command = "/usr/bin/env SOME_VAR=1 /usr/bin/some_start_command"
         
@@ -179,50 +179,48 @@ We recommend that you _not_ do that and instead use the config options to captur
       end
     end
     
-The main benefit of using the config options is that Bluepill will be able to monitor the correct process instead of just watching the shell that spawned your actual server.
+The main benefit of using the config options is that EventedBluepill will be able to monitor the correct process instead of just watching the shell that spawned your actual server.
 
 ### CLI
-To start a bluepill process and load a config:
+To start a evented_bluepill process and load a config:
 
-    sudo bluepill load /path/to/production.pill
+    sudo evented_bluepill load /path/to/production.pill
     
 To act on a process or group:
 
-    sudo bluepill <start|stop|restart|unmonitor> <process_or_group_name>
+    sudo evented_bluepill <start|stop|restart|unmonitor> <process_or_group_name>
     
 To view process statuses:
 
-    sudo bluepill status
+    sudo evented_bluepill status
 
 To view the log for a process or group:
 
-    sudo bluepill log <process_or_group_name>
+    sudo evented_bluepill log <process_or_group_name>
 
-To quit bluepill:
+To quit evented_bluepill:
 
-    sudo bluepill quit
+    sudo evented_bluepill quit
 
 ### Logging  
-By default, bluepill uses syslog local6 facility as described in the installation section. But if for any reason you don't want to use syslog, you can use a log file. You can do this by setting the :log\_file option in the config:
+By default, evented\_bluepill uses syslog local6 facility as described in the installation section. But if for any reason you don't want to use syslog, you can use a log file. You can do this by setting the :log\_file option in the config:
 
-    Bluepill.application("app_name", :log_file => "/path/to/bluepill.log") do |app|
+    EventedBluepill.application("app_name", :log_file => "/path/to/evented_bluepill.log") do |app|
       # ...
     end
 
 Keep in mind that you still need to set up log rotation (described in the installation section) to keep the log file from growing huge.
     
 ### Extra options
-You can run bluepill in the foreground:
+You can run evented\_bluepill in the foreground:
 
-    Bluepill.application("app_name", :foreground => true) do |app|
+    EventedBluepill.application("app_name", :foreground => true) do |app|
       # ...
     end
 
 ## Links
-Code: [http://github.com/arya/bluepill](http://github.com/arya/bluepill)  
-Bugs/Features: [http://github.com/arya/bluepill/issues](http://github.com/arya/bluepill/issues)  
-Mailing List: [http://groups.google.com/group/bluepill-rb](http://groups.google.com/group/bluepill-rb)
-
+Code: [http://github.com/msnexploder/evented_bluepill](http://github.com/msnexploder/evented_bluepill)
+Bugs/Features: [http://github.com/msnexploder/evented_bluepill/issues](http://github.com/msnexploder/evented_bluepill/issues)
 
 [gemcutter]: http://gemcutter.org
     

data/Rakefile

@@ -1,2 +1,11 @@
 require 'bundler'
+require 'rake/testtask'
+
 Bundler::GemHelper.install_tasks
+
+task :default => [:test]
+
+Rake::TestTask.new do |t|
+  t.libs << 'spec'
+  t.pattern = "spec/*_spec.rb"
+end

data/bin/bluepill

@@ -1,108 +1,15 @@
 #! /usr/bin/env ruby
 # -*- encoding: utf-8 -*-
-require 'optparse'
-require 'bluepill'
+require 'evented_bluepill/options'
+require 'evented_bluepill/controller'
 
-# Default options
-options = {
-  :log_file   => "/var/log/bluepill.log",
-  :base_dir   => "/var/bluepill",
-  :privileged => true
-}
+STDERR.puts "*** DEPRECATION WARNING: using 'bluepill' is deprecated. Please use 'evented_bluepill' instead ***"
 
-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
+EventedBluepill::Options.parse!
 
-  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
+command = ARGV.shift
+target = ARGV.shift
+application = EventedBluepill::Options[:application]
 
-  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
-
-  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/arya/bluepill for 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
-    require 'rbconfig'
-    ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
-    load_path = File.expand_path("#{File.dirname(__FILE__)}/../lib")
-    file_path = File.expand_path(file)
-
-    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
+controller = EventedBluepill::Controller.new
+controller.handle_command(application, command, target)

data/bin/evented_bluepill

@@ -0,0 +1,13 @@
+#! /usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+require 'evented_bluepill/options'
+require 'evented_bluepill/controller'
+
+EventedBluepill::Options.parse!
+
+command = ARGV.shift
+target = ARGV.shift
+application = EventedBluepill::Options[:application]
+
+controller = EventedBluepill::Controller.new
+controller.handle_command(application, command, target)

data/evented_bluepill.gemspec

@@ -1,23 +1,27 @@
 # -*- encoding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
-require "bluepill/version"
+require "evented_bluepill/version"
 
 Gem::Specification.new do |s|
   s.name        = "evented_bluepill"
-  s.version     = Bluepill::VERSION
+  s.version     = EventedBluepill::VERSION::STRING
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Stefan Huber", "Arya Asemanfar", "Gary Tsang", "Rohith Ravi"]
   s.email       = ["MSNexploder@gmail.com"]
   s.homepage    = "http://github.com/msnexploder/evented_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.description = %q{EventedBluepill 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.add_dependency 'daemons', '~> 1.0.10'
+  s.add_dependency 'daemons', '~> 1.1.0'
   s.add_dependency 'blankslate', '~> 2.1.2.3'
-  s.add_dependency 'state_machine', '~> 0.8.1'
-  s.add_dependency 'activesupport', '~> 2.3.10'
+  s.add_dependency 'state_machine', '~> 0.9.4'
+  s.add_dependency 'activesupport', '~> 3.0.0'
+  s.add_dependency 'i18n', '~> 0.5.0'
   s.add_dependency 'cool.io', '~> 1.0.0'
 
+  s.add_development_dependency 'minitest', '~> 2.0.2'
+  s.add_development_dependency 'mocha', '~> 0.9.12'
+
   s.rubyforge_project = "evented_bluepill"
 
   s.files            = `git ls-files`.split("\n")

data/{lib → example}/example.rb

@@ -1,16 +1,13 @@
 #! /usr/bin/env ruby
 # -*- encoding: utf-8 -*-
 
-require 'rubygems'
-require 'bluepill'
-require 'active_support'
-require 'logger'
+require 'evented_bluepill'
 
 ROOT_DIR = "/tmp/bp"
 
 # Watch with
-# watch -n0.2 'ps axu | egrep "(CPU|forking|bluepill|sleep)" | grep -v grep | sort'
-Bluepill.application(:sample_app, :foreground => true, :log_file => '/tmp/bp/sample_app.log') do |app|
+# watch -n0.2 'ps axu | egrep "(CPU|forking|evented_bluepill|sleep)" | grep -v grep | sort'
+EventedBluepill.application(:sample_app, :foreground => true, :log_file => '/tmp/bp/sample_app.log') do |app|
   1.times do |i|
     app.process("process_#{i}") do |process|
       process.pid_file = "#{ROOT_DIR}/pids/process_#{i}.pid"
@@ -18,7 +15,7 @@ Bluepill.application(:sample_app, :foreground => true, :log_file => '/tmp/bp/sam
       # 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/stefan/Documents/projects/bluepill/bin/sample_forking_server #{4242 + i}"
+      process.start_command = "/Users/stefan/Documents/projects/evented_bluepill/example/sample_forking_server #{4242 + i}"
       process.stop_command = "kill -INT {{PID}}"
       process.daemonize = true
 

data/{lib → example}/runit_example.rb

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'rubygems'
-require 'bluepill'
+require 'evented_bluepill'
 require 'logger'
 
 # ATTENTION:
@@ -9,7 +9,7 @@ require 'logger'
 #
 # http://github.com/akzhan/runit-man used as example of monitored application.
 
-Bluepill.application(:runit_man, :foreground => true) do |app|
+EventedBluepill.application(:runit_man, :foreground => true) do |app|
   app.process("runit-man") do |process|
     process.pid_file = "/etc/service/runit-man/supervise/pid"
       

data/{bin → example}/sample_forking_server

@@ -8,8 +8,8 @@
 # Instructions for running the test
 # 
 # (1) Edit the example config and fix the path to this file. Around line 16.
-# (2) Load up the config and run the bluepill daemon
-# (3) Run watch -n0.2 'sudo ruby bin/bluepill status 2>/dev/null; echo; ps ajxu | egrep "(CPU|forking|bluepill|sleep|ruby)" | grep -v grep | sort'
+# (2) Load up the config and run the evented_bluepill daemon
+# (3) Run watch -n0.2 'sudo ruby bin/evented_bluepill status 2>/dev/null; echo; ps ajxu | egrep "(CPU|forking|evented_bluepill|sleep|ruby)" | grep -v grep | sort'
 # (4) After verifying that the "sleep" workers are properly being restarted, telnet to localhost 4242 and say something. You should get it echoed back and the worker which answered your request should now be over the allowed memory limit
 # (5) Observe the worker being killed in the watch you started in step 3.
 

data/lib/bluepill.rb

@@ -1,34 +1,6 @@
 # -*- encoding: utf-8 -*-
 
-require 'rubygems'
+STDERR.puts "*** DEPRECATION WARNING: require 'bluepill' and the Bluepill constant are deprecated. Please use require 'evented_bluepill' and the EventedBluepill constant instead ***"
 
-require 'monitor'
-require 'syslog'
-require 'timeout'
-require 'logger'
-
-require 'active_support/core_ext/numeric'
-require 'active_support/core_ext/hash'
-
-require 'bluepill/event'
-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/trigger'
-require 'bluepill/triggers/flapping'
-require 'bluepill/dsl/process_factory'
-require 'bluepill/dsl/process_proxy'
-require 'bluepill/dsl/app_proxy'
-require "bluepill/dsl"
-require "bluepill/system"
-
-require "bluepill/process_conditions"
-
-require "bluepill/util/rotational_array"
-
-require "bluepill/version"
+require 'evented_bluepill'
+Bluepill = EventedBluepill

data/lib/{bluepill → evented_bluepill}/application/client.rb

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 
-module Bluepill
+module EventedBluepill
   module Application
     module Client
 

data/lib/evented_bluepill/application/server.rb

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+
+module EventedBluepill
+  module Application
+    module ServerMethods
+
+      def status
+        self.processes.collect do |process|
+          "#{process.name} #{process.state}"
+        end.join("\n")
+      end
+
+      def restart
+        self.socket = EventedBluepill::Socket.new(name, base_dir).client
+        socket.send("restart\n", 0)
+      end
+
+      def stop
+        self.socket = EventedBluepill::Socket.new(name, base_dir).client
+        socket.send("stop\n", 0)
+      end
+    end
+  end
+end

data/lib/{bluepill → evented_bluepill}/application.rb

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 
-module Bluepill
+module EventedBluepill
   class Application
     PROCESS_COMMANDS = [:start, :stop, :restart, :unmonitor, :status]
 
@@ -13,13 +13,13 @@ module Bluepill
 
       @foreground   = options[:foreground]
       self.log_file = options[:log_file]
-      self.base_dir = options[:base_dir] || '/var/bluepill'
+      self.base_dir = options[:base_dir] || '/var/evented_bluepill'
       self.pid_file = File.join(self.base_dir, 'pids', self.name + ".pid")
       self.pids_dir = File.join(self.base_dir, 'pids', self.name)
 
       self.groups = {}
 
-      self.logger = Bluepill::Logger.new(:log_file => self.log_file, :stdout => foreground?).prefix_with(self.name)
+      self.logger = EventedBluepill::Logger.new(:log_file => self.log_file, :stdout => foreground?).prefix_with(self.name)
 
       self.setup_signal_traps
       self.setup_pids_dir
@@ -33,7 +33,7 @@ module Bluepill
       begin
         self.start_server
       rescue StandardError => e
-        $stderr.puts "Failed to start bluepill:"
+        $stderr.puts "Failed to start evented_bluepill:"
         $stderr.puts "%s `%s`" % [e.class.name, e.message]
         $stderr.puts e.backtrace
         exit(5)
@@ -56,7 +56,7 @@ module Bluepill
     end
 
     def version
-      Bluepill::VERSION
+      EventedBluepill::VERSION::STRING
     end
 
     protected
@@ -91,23 +91,23 @@ module Bluepill
       self.groups.each {|_, group| group.determine_initial_state }
 
       self.write_pid_file
-      self.cmd_listener = Bluepill::Socket.server(self.base_dir, self.name, self)
-      Bluepill::Event.attach(self.cmd_listener)
-      Bluepill::Event.run
+      self.cmd_listener = EventedBluepill::Socket.server(self.base_dir, self.name, self)
+      EventedBluepill::Event.attach(self.cmd_listener)
+      EventedBluepill::Event.run
 
       cleanup
     end
 
     def cleanup
       # TODO ugly
-      File.unlink(Bluepill::Socket.socket_path(self.base_dir, self.name)) if self.cmd_listener
+      File.unlink(EventedBluepill::Socket.socket_path(self.base_dir, self.name)) if self.cmd_listener
       File.unlink(self.pid_file) if File.exists?(self.pid_file)
     end
 
     def setup_signal_traps
       terminator = Proc.new do
         puts "Terminating..."
-        Bluepill::Event.stop
+        EventedBluepill::Event.stop
       end
 
       Signal.trap("TERM", &terminator)
@@ -121,7 +121,7 @@ module Bluepill
     def setup_pids_dir
       FileUtils.mkdir_p(self.pids_dir) unless File.exists?(self.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
+      # evented_bluepill will be writing to this dir after they've dropped privileges
       FileUtils.chmod(0777, self.pids_dir)
     end
 
@@ -131,10 +131,10 @@ module Bluepill
         if System.pid_alive?(previous_pid)
           begin
             ::Process.kill(0, previous_pid)
-            puts "Killing previous bluepilld[#{previous_pid}]"
+            puts "Killing previous evented_bluepilld[#{previous_pid}]"
             ::Process.kill(2, previous_pid)
           rescue Exception => e
-            $stderr.puts "Encountered error trying to kill previous bluepill:"
+            $stderr.puts "Encountered error trying to kill previous evented_bluepill:"
             $stderr.puts "#{e.class}: #{e.message}"
             exit(4) unless e.is_a?(Errno::ESRCH)
           else
@@ -144,7 +144,7 @@ module Bluepill
             end
 
             if System.pid_alive?(previous_pid)
-              $stderr.puts "Previous bluepilld[#{previous_pid}] didn't die"
+              $stderr.puts "Previous evented_bluepilld[#{previous_pid}] didn't die"
               exit(4)
             end
           end