rails_pwnerer 0.6.64 → 0.6.65

data/CHANGELOG

@@ -1,3 +1,5 @@
+v0.6.65. Tweaks and tests for package installation code.
+
 v0.6.64. mysql is the default again. mysql2 still fails.
 
 v0.6.63. Bugfix in mysql / mysql2 choosing code bugfix.

data/Manifest

@@ -1,54 +1,56 @@
-bin/rpwn
-bin/rpwnctl
-bin/rpwndev
 CHANGELOG
-ext/rpwn_setup_notice/extconf.rb
-lib/pwnage/app/cluster_config.rb
-lib/pwnage/app/config.rb
-lib/pwnage/app/db/mysql.rb
-lib/pwnage/app/files.rb
-lib/pwnage/app/gems.rb
-lib/pwnage/app/main.rb
-lib/pwnage/app/nginx_config.rb
-lib/pwnage/app/scripts.rb
-lib/pwnage/app/vcs/git.rb
-lib/pwnage/app/vcs/perforce.rb
-lib/pwnage/app/vcs/svn.rb
-lib/pwnage/base/atomics.rb
-lib/pwnage/base/cpus.rb
-lib/pwnage/base/dirs.rb
-lib/pwnage/base/gems.rb
-lib/pwnage/base/hostname.rb
-lib/pwnage/base/input.rb
-lib/pwnage/base/packages.rb
-lib/pwnage/base/process.rb
-lib/pwnage/base/rails.rb
-lib/pwnage/base/startup.rb
-lib/pwnage/base.rb
-lib/pwnage/config/app.rb
-lib/pwnage/config/frontends.rb
-lib/pwnage/config/main.rb
-lib/pwnage/config/paths.rb
-lib/pwnage/config/ports.rb
-lib/pwnage/config/repository.rb
-lib/pwnage/ctl_executor.rb
-lib/pwnage/dev_executor.rb
-lib/pwnage/executor.rb
-lib/pwnage/scaffolds/config.rb
-lib/pwnage/scaffolds/dir_permissions.rb
-lib/pwnage/scaffolds/dirs.rb
-lib/pwnage/scaffolds/gems.rb
-lib/pwnage/scaffolds/hook_daemon.rb
-lib/pwnage/scaffolds/hook_dyndns.rb
-lib/pwnage/scaffolds/mysql_config.rb
-lib/pwnage/scaffolds/packages.rb
-lib/pwnage/scaffolds/rubygems.rb
-lib/pwnage/scaffolds/sshd.rb
-lib/pwnage/util/kill_process_set.rb
-lib/pwnage/util/main.rb
-lib/rails_pwnerer.rb
 LICENSE
 Manifest
-Rakefile
 README
 RUBYFORGE
+Rakefile
+bin/rpwn
+bin/rpwnctl
+bin/rpwndev
+ext/rpwn_setup_notice/extconf.rb
+lib/rails_pwnerer.rb
+lib/rails_pwnerer/app/cluster_config.rb
+lib/rails_pwnerer/app/config.rb
+lib/rails_pwnerer/app/db/mysql.rb
+lib/rails_pwnerer/app/files.rb
+lib/rails_pwnerer/app/gems.rb
+lib/rails_pwnerer/app/main.rb
+lib/rails_pwnerer/app/nginx_config.rb
+lib/rails_pwnerer/app/scripts.rb
+lib/rails_pwnerer/app/vcs/git.rb
+lib/rails_pwnerer/app/vcs/perforce.rb
+lib/rails_pwnerer/app/vcs/svn.rb
+lib/rails_pwnerer/base.rb
+lib/rails_pwnerer/base/atomics.rb
+lib/rails_pwnerer/base/cpus.rb
+lib/rails_pwnerer/base/dirs.rb
+lib/rails_pwnerer/base/gems.rb
+lib/rails_pwnerer/base/hostname.rb
+lib/rails_pwnerer/base/input.rb
+lib/rails_pwnerer/base/packages.rb
+lib/rails_pwnerer/base/process.rb
+lib/rails_pwnerer/base/rails.rb
+lib/rails_pwnerer/base/startup.rb
+lib/rails_pwnerer/config/app.rb
+lib/rails_pwnerer/config/frontends.rb
+lib/rails_pwnerer/config/main.rb
+lib/rails_pwnerer/config/paths.rb
+lib/rails_pwnerer/config/ports.rb
+lib/rails_pwnerer/config/repository.rb
+lib/rails_pwnerer/ctl_executor.rb
+lib/rails_pwnerer/dev_executor.rb
+lib/rails_pwnerer/executor.rb
+lib/rails_pwnerer/scaffolds/config.rb
+lib/rails_pwnerer/scaffolds/dir_permissions.rb
+lib/rails_pwnerer/scaffolds/dirs.rb
+lib/rails_pwnerer/scaffolds/gems.rb
+lib/rails_pwnerer/scaffolds/hook_daemon.rb
+lib/rails_pwnerer/scaffolds/hook_dyndns.rb
+lib/rails_pwnerer/scaffolds/mysql_config.rb
+lib/rails_pwnerer/scaffolds/packages.rb
+lib/rails_pwnerer/scaffolds/rubygems.rb
+lib/rails_pwnerer/scaffolds/sshd.rb
+lib/rails_pwnerer/util/kill_process_set.rb
+lib/rails_pwnerer/util/main.rb
+test/base_package_test.rb
+test/helper.rb

data/Rakefile

@@ -1,5 +1,4 @@
 require 'rubygems'
-gem 'echoe'
 require 'echoe'
 
 Echoe.new('rails_pwnerer') do |p|
@@ -7,22 +6,19 @@ Echoe.new('rails_pwnerer') do |p|
   
   p.author = 'Victor Costan'
   p.email = 'victor@costan.us'
-  p.summary = 'Rails deployment tool/hack.'
+  p.summary = 'Rails deployment hack.'
   p.url = 'http://www.costan.us/rails_pwnage'
-  p.runtime_dependencies = []
   p.dependencies = []
-  # remove echoe, because it becomes a runtime dependency for rubygems < 1.2
-  p.development_dependencies = []
-  # override echoe's default of 1.2
-  p.rubygems_version = '>= 0'
-  p.extensions = ['ext/rpwn_setup_notice/extconf.rb']
+  p.development_dependencies = ['echoe', 'fakefs', 'flexmock']
+  p.extension_pattern = ['ext/**/extconf.rb']
   p.eval = proc do |p|
     p.default_executable = 'bin/rpwn'
   end
   
-  p.need_tar_gz = true
-  p.need_zip = true
-  p.rdoc_pattern = /^(lib|bin|tasks|ext)|^BUILD|^README|^CHANGELOG|^TODO|^LICENSE|^COPYING$/  
+  p.need_tar_gz = !Gem.win_platform?
+  p.need_zip = !Gem.win_platform?
+  p.rdoc_pattern =
+      /^(lib|bin|tasks|ext)|^BUILD|^README|^CHANGELOG|^TODO|^LICENSE|^COPYING$/ 
 end
 
 if $0 == __FILE__

data/ext/rpwn_setup_notice/extconf.rb

@@ -1,19 +1,25 @@
-# invoked when the gem is installed
+# Invoked when the gem is installed. Hack to get a post-install hook.
 
-# cheat to get the gem installed in the right place even on Debians
+require 'rubygems'
+
+
+# Cheat to get the gem binaries installed in the user's path even on Debians.
 ['rpwn', 'rpwnctl', 'rpwndev'].each do |file|
-  binpath = "/usr/bin/#{file}"
-  unless File.exists? binpath
-    Kernel.system "ln -s #{File.expand_path(__FILE__ + "/../../../bin/#{file}")} #{binpath}"
+  bin_path = "/usr/bin/#{file}"
+  unless File.exists? bin_path
+    source_path = File.expand_path "../../../bin/#{file}", __FILE__
+    Kernel.system "ln -s #{source_path} #{bin_path}"
   end
 
-  File.chmod((File.stat(binpath).mode | 0755), binpath)
+  File.chmod((File.stat(binpath).mode | 0755), binpath) rescue nil
 end
 
-# make the gem readable by anyone (workaround systems with messed up permission masks)
+# Make the gem readable and runnable by anyone.
+#
+# This is a work-around for systems with messed up permission masks.
 def openup(path)
   if File.file?(path)
-    File.chmod((File.stat(path).mode | 0755), path)
+    File.chmod((File.stat(path).mode | 0755), path) rescue nil
     return
   end
   
@@ -22,13 +28,15 @@ def openup(path)
     openup File.join(path, entry)
   end  
 end
-base_path = File.expand_path(__FILE__ + "/../../../")
-openup(base_path)
+base_path = File.expand_path "../../..", __FILE__
+openup base_path
 
-# we really shouldn't be abusing rubygems' root; then again, the Debian maintaines shouldn't be
-# abusing the patience of Ruby developers
+# We really shouldn't be abusing rubygems' root. Then again, the Debian
+# maintaines shouldn't be abusing the patience of Ruby developers.
 
-# now trick rubygems into believeing that all is good
-File.open('Makefile', 'w') { |f| f.write "all:\n\ninstall:\n\n" }
-File.open('rpwn_setup_notice.so', 'w') {}
-File.open('rpwn_setup_notice.dll', 'w') {}
+# Now trick rubygems and echoe into believeing that a gem got installed is good.
+ext_binary =  'rpwn_setup_notice' + (Gem.win_platform? ? '.dll' : '.so')
+File.open(ext_binary, 'w') { |f| }
+File.open('Makefile', 'w') do |f|
+  f.write "# target_prefix = #{ext_binary}\nall:\n\ninstall:\n\n"
+end

data/lib/{pwnage → rails_pwnerer}/app/cluster_config.rb

@@ -2,11 +2,11 @@
 
 require 'fileutils'
 
-class RailsPwnage::App::ClusterConfig
-  include RailsPwnage::Base
+class RailsPwnerer::App::ClusterConfig
+  include RailsPwnerer::Base
   
   def fix_permissions(app_name, instance_name)
-    app_config = RailsPwnage::Config[app_name, instance_name]    
+    app_config = RailsPwnerer::Config[app_name, instance_name]    
     pwnerer_user = app_config[:pwnerer_user]
     pwnerer_uid = uid_for_username(pwnerer_user)
     pwnerer_group = group_for_username(pwnerer_user)
@@ -25,27 +25,27 @@ class RailsPwnage::App::ClusterConfig
   end
     
   def manage_ports(app_name, instance_name, action)
-    app_config = RailsPwnage::Config[app_name, instance_name]
-    return unless frontends = RailsPwnage::Config.app_frontends(app_name, instance_name)
+    app_config = RailsPwnerer::Config[app_name, instance_name]
+    return unless frontends = RailsPwnerer::Config.app_frontends(app_name, instance_name)
     
     case action
     when :alloc
-      app_config[:port0] = RailsPwnage::Config.alloc_ports frontends
+      app_config[:port0] = RailsPwnerer::Config.alloc_ports frontends
     when :free
-      RailsPwnage::Config.free_ports app_config[:port0], frontends
+      RailsPwnerer::Config.free_ports app_config[:port0], frontends
       return if app_config[:port0] == 0 # do not release if ports have already been released
       app_config[:port0] = 0
     end
-    RailsPwnage::Config.flush_db RailsPwnage::Config.app_db_name(app_name, instance_name)
+    RailsPwnerer::Config.flush_db RailsPwnerer::Config.app_db_name(app_name, instance_name)
   end
 
   def stop(app_name, instance_name)
-    app_config = RailsPwnage::Config[app_name, instance_name]
+    app_config = RailsPwnerer::Config[app_name, instance_name]
     # silently die if the app was completely busted
     return unless app_config and File.exists? app_config[:app_path]
         
     app_path, first_port = app_config[:app_path], app_config[:port0]
-    frontends = RailsPwnage::Config.app_frontends(app_name, instance_name)
+    frontends = RailsPwnerer::Config.app_frontends(app_name, instance_name)
 
     cmdline_patterns = ['thin', nil]
     
@@ -55,7 +55,7 @@ class RailsPwnage::App::ClusterConfig
         fe_port = first_port + f
         cmdline = "thin stop -a 127.0.0.1 -p #{fe_port} -d -P tmp/pids/fe.#{fe_port}.pid"
         cmdline_patterns[1] = "(127.0.0.1:#{fe_port})"
-        RailsPwnage::Util.kill_process_set(cmdline, "tmp/pids/fe.#{fe_port}.pid",
+        RailsPwnerer::Util.kill_process_set(cmdline, "tmp/pids/fe.#{fe_port}.pid",
                            cmdline_patterns, :verbose => false, :sleep_delay => 0.2)
       end
       
@@ -63,13 +63,13 @@ class RailsPwnage::App::ClusterConfig
   end
   
   def start(app_name, instance_name)
-    app_config = RailsPwnage::Config[app_name, instance_name]
+    app_config = RailsPwnerer::Config[app_name, instance_name]
     # silently die if the app was completely busted
     return unless app_config and File.exists? app_config[:app_path]
 
     app_path, pwnerer_user = app_config[:app_path], app_config[:pwnerer_user]
     pwnerer_group = group_for_username(pwnerer_user)    
-    frontends = RailsPwnage::Config.app_frontends(app_name, instance_name)
+    frontends = RailsPwnerer::Config.app_frontends(app_name, instance_name)
     first_port, environment = app_config[:port0], app_config[:environment]
 
     stop app_name, instance_name
@@ -78,7 +78,7 @@ class RailsPwnage::App::ClusterConfig
     if first_port == 0
       manage_ports app_name, instance_name, :alloc
       first_port = app_config[:port0]
-      RailsPwnage::App::NginxConfig.new.update app_name, instance_name
+      RailsPwnerer::App::NginxConfig.new.update app_name, instance_name
     end
     
     static_cmd = "thin start -a 127.0.0.1 -c #{app_path} -d -u #{pwnerer_user}" +
@@ -128,12 +128,12 @@ class RailsPwnage::App::ClusterConfig
   end
   
   def control_all(action)
-    RailsPwnage::Config.all_applications.each do |ai|
+    RailsPwnerer::Config.all_applications.each do |ai|
       case action
       when :start
-        RailsPwnage::App::ClusterConfig.new.start ai[0], ai[1]
+        RailsPwnerer::App::ClusterConfig.new.start ai[0], ai[1]
       when :stop
-        RailsPwnage::App::ClusterConfig.new.stop ai[0], ai[1]        
+        RailsPwnerer::App::ClusterConfig.new.stop ai[0], ai[1]        
       end
     end 
   end  

data/lib/{pwnage → rails_pwnerer}/app/config.rb

@@ -1,8 +1,8 @@
 # syncs the app's internal configuration with the configuration database
 require 'yaml'
 
-class RailsPwnage::App::Config
-  include RailsPwnage::Base
+class RailsPwnerer::App::Config
+  include RailsPwnerer::Base
   
   def random_db_password
     (0...16).map { |i| "abcdefghijklmnopqrstuvwxyz"[rand(26),1]}.join
@@ -13,12 +13,12 @@ class RailsPwnage::App::Config
   # update: this adds keys that might have been added in new versions of rpwn
   def populate_defaults(app_name, instance_name, app_db)
     # the path to application main files
-    app_db[:app_path] = File.join(RailsPwnage::Config.path_to(:apps), app_name + '.' + instance_name)
+    app_db[:app_path] = File.join(RailsPwnerer::Config.path_to(:apps), app_name + '.' + instance_name)
     # the path to application backups
-    app_db[:backup_path] ||= File.join(RailsPwnage::Config.path_to(:backups), app_name + '.' + instance_name)
+    app_db[:backup_path] ||= File.join(RailsPwnerer::Config.path_to(:backups), app_name + '.' + instance_name)
         
     # the user which will receive the "keys" to the production system 
-    app_db[:pwnerer_user] ||= RailsPwnage::Config[:host][:pwnerer_user]
+    app_db[:pwnerer_user] ||= RailsPwnerer::Config[:host][:pwnerer_user]
     # the number of frontends for the application instance
     app_db[:frontends] ||= 4 # most computers have 2 cores nowadays
     # the number of frontends per core for the application instance
@@ -52,19 +52,19 @@ class RailsPwnage::App::Config
 
   # allocates room for the application and creates the application configuration database
   def alloc(app_name, instance_name)
-    app_db_name = RailsPwnage::Config.app_db_name(app_name, instance_name)
-    app_db = RailsPwnage::Config.create_db app_db_name
+    app_db_name = RailsPwnerer::Config.app_db_name(app_name, instance_name)
+    app_db = RailsPwnerer::Config.create_db app_db_name
     populate_defaults app_name, instance_name, app_db
     
     FileUtils.mkpath app_db[:app_path]
         
-    RailsPwnage::Config.flush_db app_db    
+    RailsPwnerer::Config.flush_db app_db    
     return app_db[:app_path]
   end
       
   # pushes config changes from the application file to the database
   def update(app_name, instance_name)
-    app_config = RailsPwnage::Config[app_name, instance_name]
+    app_config = RailsPwnerer::Config[app_name, instance_name]
     
     db_name, db_user, db_pass = app_config[:db_name], app_config[:db_user], app_config[:db_pass]
     app_config.clear
@@ -95,16 +95,16 @@ class RailsPwnage::App::Config
     # TODO: if database settings changed, the database should be moved (re-created or re-keyed)
     if db_pass != app_config[:db_pass]
       db_pass = random_db_password if !db_pass || db_pass.empty?
-      RailsPwnage::App::Database.new.manage app_name, instance_name, :rekey
+      RailsPwnerer::App::Database.new.manage app_name, instance_name, :rekey
     end
     
-    RailsPwnage::Config.flush_db RailsPwnage::Config.app_db_name(app_name, instance_name)
+    RailsPwnerer::Config.flush_db RailsPwnerer::Config.app_db_name(app_name, instance_name)
   end
   
   def manage(app_name, instance_name, action)    
     case action
     when :rekey
-      app_config = RailsPwnage::Config[app_name, instance_name]
+      app_config = RailsPwnerer::Config[app_name, instance_name]
       app_config[:db_pass] = random_db_password
     end
   end
@@ -114,7 +114,7 @@ class RailsPwnage::App::Config
   end
   
   def remove(app_name, instance_name)
-    app_db_name = RailsPwnage::Config.app_db_name(app_name, instance_name)
-    RailsPwnage::Config.drop_db app_db_name
+    app_db_name = RailsPwnerer::Config.app_db_name(app_name, instance_name)
+    RailsPwnerer::Config.drop_db app_db_name
   end
 end

data/lib/{pwnage → rails_pwnerer}/app/db/mysql.rb

@@ -2,12 +2,12 @@
 
 require 'yaml'
 
-class RailsPwnage::App::Database
-  include RailsPwnage::Base
+class RailsPwnerer::App::Database
+  include RailsPwnerer::Base
 
   # creates/drops the mysql database for the application
   def admin_database(app_name, instance_name, action = :create)
-    app_config = RailsPwnage::Config[app_name, instance_name]
+    app_config = RailsPwnerer::Config[app_name, instance_name]
     # exit and don't complain if the app is busted
     return unless app_config and File.exists? app_config[:app_path]
 
@@ -34,8 +34,8 @@ ENDSQL
       
       # run it
       File.open('admin_db.sql', 'w') { |f| f.write sql_commands }
-      dbroot_name = RailsPwnage::Config[:host][:dbroot_name]
-      dbroot_pass = RailsPwnage::Config[:host][:dbroot_pass]
+      dbroot_name = RailsPwnerer::Config[:host][:dbroot_name]
+      dbroot_pass = RailsPwnerer::Config[:host][:dbroot_pass]
       dbpass_arg = dbroot_pass.empty? ? '' : "-p#{dbroot_pass}"
       system "mysql -u#{dbroot_name} #{dbpass_arg} < admin_db.sql"
       
@@ -67,7 +67,7 @@ ENDSQL
     
   # configures rails to use the database in the production environment
   def configure_rails(app_name, instance_name)
-    app_config = RailsPwnage::Config[app_name, instance_name]
+    app_config = RailsPwnerer::Config[app_name, instance_name]
     db_name, db_user, db_pass = app_config[:db_name], app_config[:db_user], app_config[:db_pass]
     
     config_file = File.join app_config[:app_path], 'config', 'database.yml'
@@ -89,7 +89,7 @@ ENDSQL
   
   # migrates the database to the latest schema version
   def migrate_database(app_name, instance_name)
-    Dir.chdir RailsPwnage::Config[app_name, instance_name][:app_path] do
+    Dir.chdir RailsPwnerer::Config[app_name, instance_name][:app_path] do
       # now migrate the database
       system "rake db:migrate RAILS_ENV=production"
     end
@@ -97,7 +97,7 @@ ENDSQL
   
   # creates a database dump in the backup area
   def dump_database(app_name, instance_name)
-    app_config = RailsPwnage::Config[app_name, instance_name]
+    app_config = RailsPwnerer::Config[app_name, instance_name]
     db_name, db_user, db_pass = app_config[:db_name], app_config[:db_user], app_config[:db_pass]
 
     pwnerer_user = app_config[:pwnerer_user]
@@ -118,7 +118,7 @@ ENDSQL
   
   # loads the latest database dump from the backup area
   def load_database(app_name, instance_name)
-    app_config = RailsPwnage::Config[app_name, instance_name]
+    app_config = RailsPwnerer::Config[app_name, instance_name]
     db_name, db_user, db_pass = app_config[:db_name], app_config[:db_user], app_config[:db_pass]
     
     Dir.chdir app_config[:backup_path] do

data/lib/{pwnage → rails_pwnerer}/app/files.rb

@@ -1,19 +1,19 @@
 # manages an application's file system
 
-class RailsPwnage::App::Files
-  include RailsPwnage::Base
+class RailsPwnerer::App::Files
+  include RailsPwnerer::Base
   
   # dump the application files to the backup area
   def dump_files(app_name, instance_name)
-    pwnerer_user = RailsPwnage::Config[app_name, instance_name][:pwnerer_user]
+    pwnerer_user = RailsPwnerer::Config[app_name, instance_name][:pwnerer_user]
     pwnerer_uid = uid_for_username(pwnerer_user)
     pwnerer_gid = gid_for_username(pwnerer_user)
     
     timestamp = Time.now.strftime '%Y%m%d%H%M%S'
     dump_file = "files/#{app_name}.#{instance_name}_#{timestamp}.tar.gz"
     
-    backup_path = RailsPwnage::Config[app_name, instance_name][:backup_path]
-    app_path = RailsPwnage::Config[app_name, instance_name][:app_path]
+    backup_path = RailsPwnerer::Config[app_name, instance_name][:backup_path]
+    app_path = RailsPwnerer::Config[app_name, instance_name][:app_path]
     Dir.chdir backup_path do
       # create a cold copy of the application files
       cold_copy = File.join('tmp', File.basename(app_path))
@@ -21,7 +21,7 @@ class RailsPwnage::App::Files
       FileUtils.cp_r app_path, 'tmp'
       
       # remove the garbage in the cold copy
-      [RailsPwnage::App::Git, RailsPwnage::App::Svn].each do |mod|
+      [RailsPwnerer::App::Git, RailsPwnerer::App::Svn].each do |mod|
         mod.new.cleanup_app_caches cold_copy, instance_name, true
       end
       
@@ -39,11 +39,11 @@ class RailsPwnage::App::Files
   
   # creates the directory scaffold in the application's backup dir
   def scaffold_backup(app_name, instance_name)
-    pwnerer_user = RailsPwnage::Config[app_name, instance_name][:pwnerer_user]
+    pwnerer_user = RailsPwnerer::Config[app_name, instance_name][:pwnerer_user]
     pwnerer_uid = uid_for_username(pwnerer_user)
     pwnerer_gid = gid_for_username(pwnerer_user)
 
-    backup_path = RailsPwnage::Config[app_name, instance_name][:backup_path]
+    backup_path = RailsPwnerer::Config[app_name, instance_name][:backup_path]
     FileUtils.mkpath backup_path unless File.exists? backup_path
     File.chown(pwnerer_uid, pwnerer_gid, backup_path)
     
@@ -57,8 +57,8 @@ class RailsPwnage::App::Files
   
   # loads the latest file dump from the backup area
   def load_files(app_name, instance_name)
-    backup_path = RailsPwnage::Config[app_name, instance_name][:backup_path]
-    app_path = RailsPwnage::Config[app_name, instance_name][:app_path]
+    backup_path = RailsPwnerer::Config[app_name, instance_name][:backup_path]
+    app_path = RailsPwnerer::Config[app_name, instance_name][:app_path]
     
     dump_file = Dir.glob(File.join(backup_path, "files/#{app_name}.#{instance_name}_*")).max
     unless dump_file
@@ -73,7 +73,7 @@ class RailsPwnage::App::Files
   
   # remove the application files
   def drop_files(app_name, instance_name)
-    app_config = RailsPwnage::Config[app_name, instance_name]
+    app_config = RailsPwnerer::Config[app_name, instance_name]
     # exit and don't complain if the app is busted
     return unless app_config and File.exists? app_config[:app_path]
 
@@ -89,7 +89,7 @@ class RailsPwnage::App::Files
       drop_files app_name, instance_name
       load_files app_name, instance_name      
     when :console
-      Dir.chdir(RailsPwnage::Config[app_name, instance_name][:app_path]) do
+      Dir.chdir(RailsPwnerer::Config[app_name, instance_name][:app_path]) do
         if File.exist? 'script/rails'
           Kernel.system 'rails console production'
         else
@@ -97,7 +97,7 @@ class RailsPwnage::App::Files
         end
       end
     when :db_console
-      Dir.chdir(RailsPwnage::Config[app_name, instance_name][:app_path]) do
+      Dir.chdir(RailsPwnerer::Config[app_name, instance_name][:app_path]) do
         if File.exist? 'script/rails'
           Kernel.system 'rails dbconsole production --include-password'
         else

data/lib/{pwnage → rails_pwnerer}/app/gems.rb

@@ -1,10 +1,10 @@
 # sets up the application gems
 
-class RailsPwnage::App::Gems
-  include RailsPwnage::Base
+class RailsPwnerer::App::Gems
+  include RailsPwnerer::Base
   
   def update(app_name, instance_name)
-    app_config = RailsPwnage::Config[app_name, instance_name]
+    app_config = RailsPwnerer::Config[app_name, instance_name]
     
     Dir.chdir app_config[:app_path] do
       # Phase 1: app-directed install

data/lib/{pwnage → rails_pwnerer}/app/main.rb

@@ -1,11 +1,11 @@
-module RailsPwnage::App
+module RailsPwnerer::App
   # internal method implementing magic instance names
   def self.instance_magic(app_name, instance_name)
     case instance_name
     when '*'
-      RailsPwnage::Config.all_instances app_name { |i| yield app_name, i }
+      RailsPwnerer::Config.all_instances app_name { |i| yield app_name, i }
     when '.'
-      yield app_name, RailsPwnage::Config[:host][:instance]
+      yield app_name, RailsPwnerer::Config[:host][:instance]
     else
       yield app_name, instance_name
     end
@@ -119,7 +119,7 @@ module RailsPwnage::App
         when :db_console
           Files.new.manage app, instance, action
         when :db_reset
-          app_config = RailsPwnage::Config[app, instance]
+          app_config = RailsPwnerer::Config[app, instance]
           unless app_config[:enable_db_reset]
             print "Database resets are disabled for this instance.\n"
             print "If you truly want to reset, add the :enable_db_reset configuration key.\n"

data/lib/{pwnage → rails_pwnerer}/app/nginx_config.rb

@@ -1,11 +1,11 @@
 # builds the nginx configuration
 
-class RailsPwnage::App::NginxConfig
-  include RailsPwnage::Base
+class RailsPwnerer::App::NginxConfig
+  include RailsPwnerer::Base
     
   # writes the nginx configuration for this server
   def config_nginx(app_name, instance_name)
-    app_config = RailsPwnage::Config[app_name, instance_name]
+    app_config = RailsPwnerer::Config[app_name, instance_name]
     first_port = app_config[:port0]
     
     # Can be specified as comma-separated string or array.
@@ -18,12 +18,12 @@ class RailsPwnage::App::NginxConfig
     default_app_port = app_config[:ssl_key] ? 443 : 80
     app_port = app_config[:port] || default_app_port
     
-    nginx_config = File.join(RailsPwnage::Config.path_to(:nginx_configs),
+    nginx_config = File.join(RailsPwnerer::Config.path_to(:nginx_configs),
                              app_name + '.' + instance_name) 
     File.open(nginx_config, 'w') do |f|
       # link to the frontends
       f << "  upstream #{app_name}_#{instance_name} {\n"
-      RailsPwnage::Config.app_frontends(app_name, instance_name).times do |instance|
+      RailsPwnerer::Config.app_frontends(app_name, instance_name).times do |instance|
         f << "    server 127.0.0.1:#{first_port + instance};\n"
       end
       f << "  }\n\n"
@@ -68,13 +68,13 @@ NGINX_CONFIG
   end
   
   def remove_nginx_config(app_name, instance_name)
-    nginx_config = File.join(RailsPwnage::Config.path_to(:nginx_configs), app_name + '.' + instance_name) 
+    nginx_config = File.join(RailsPwnerer::Config.path_to(:nginx_configs), app_name + '.' + instance_name) 
     File.delete nginx_config if File.exists? nginx_config    
   end
   
   # removes the default configuration stub (so nginx doesn't stumble upon it)
   def remove_nginx_stub
-    stub_file = File.join(RailsPwnage::Config.path_to(:nginx_configs), 'default')
+    stub_file = File.join(RailsPwnerer::Config.path_to(:nginx_configs), 'default')
     File.delete stub_file  if File.exists?(stub_file)
   end
   

data/lib/{pwnage → rails_pwnerer}/app/scripts.rb

@@ -1,10 +1,10 @@
 # runs custom scripts on app events
 
-class RailsPwnage::App::Scripts
-  include RailsPwnage::Base
+class RailsPwnerer::App::Scripts
+  include RailsPwnerer::Base
   
   def run_script(app_name, instance_name, script_name)
-    app_config = RailsPwnage::Config[app_name, instance_name]    
+    app_config = RailsPwnerer::Config[app_name, instance_name]    
     pwnerer_user = app_config[:pwnerer_user]
     pwnerer_uid = uid_for_username(pwnerer_user)
     pwnerer_gid = gid_for_username(pwnerer_user)
@@ -70,7 +70,7 @@ class RailsPwnage::App::Scripts
   end
 
   def control_all(action)
-    RailsPwnage::Config.all_applications.each do |ai|
+    RailsPwnerer::Config.all_applications.each do |ai|
       run_script ai[0], ai[1], (case action
       when :pre_start then 'pre_start'
       when :post_start then 'post_start'