rails_pwnerer 0.6.64 → 0.6.65

data/lib/{pwnage → rails_pwnerer}/app/vcs/git.rb

@@ -1,11 +1,11 @@
 # checks out and updates the application from a Git repository
 
-class RailsPwnage::App::Git
-  include RailsPwnage::Base
+class RailsPwnerer::App::Git
+  include RailsPwnerer::Base
   
   # remove any files not in Git in the application dir
   def cleanup_app_dir(app_name, instance_name, target_dir, app_name_is_dir = false)
-    Dir.chdir(app_name_is_dir ? app_name : RailsPwnage::Config[app_name, instance_name][:app_path]) do
+    Dir.chdir(app_name_is_dir ? app_name : RailsPwnerer::Config[app_name, instance_name][:app_path]) do
       Kernel.system "git clean -d -f -x -- #{target_dir}"
       Kernel.system "git checkout -- #{target_dir}"
     end
@@ -14,7 +14,7 @@ class RailsPwnage::App::Git
   # clean up the application directory by removing caches 
   def cleanup_app_caches(app_name, instance_name, app_name_is_dir = false)
     # TODO: this is almost-duplicated in git.rb -- pull up somewhere    
-    app_path = app_name_is_dir ? app_name : RailsPwnage::Config[app_name, instance_name][:app_path]
+    app_path = app_name_is_dir ? app_name : RailsPwnerer::Config[app_name, instance_name][:app_path]
     return unless File.exists?(File.join(app_path, '.git'))
     
     # TODO: learn how Rails caches work and kill those too
@@ -26,7 +26,7 @@ class RailsPwnage::App::Git
 
   # reverts the config changes made by rpwn, so git fetch doesn't get confused
   def revert_config_changes(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
       ['config', 'Gemfile'].each do |dir|
         Kernel.system "git clean -d -f -x -- #{dir}"
         Kernel.system "git checkout -- #{dir}"
@@ -35,14 +35,14 @@ class RailsPwnage::App::Git
   end
   
   def git_update(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
       print "Doing Git pull, please enter your password if prompted...\n"
       Kernel.system 'git pull'
     end
   end
   
   def update(app_name, instance_name)
-    app_path = RailsPwnage::Config[app_name, instance_name][:app_path]
+    app_path = RailsPwnerer::Config[app_name, instance_name][:app_path]
     return unless File.exists?(File.join(app_path, '.git'))
     # TODO: maybe backup old version before issuing the git update?
     
@@ -52,7 +52,7 @@ class RailsPwnage::App::Git
   end
   
   def update_prefetch(app_name, instance_name)
-    app_path = RailsPwnage::Config[app_name, instance_name][:app_path]
+    app_path = RailsPwnerer::Config[app_name, instance_name][:app_path]
     return unless File.exists?(File.join(app_path, '.git'))
     
     Dir.chdir app_path do
@@ -75,7 +75,7 @@ class RailsPwnage::App::Git
     end
     
     return :next unless git_repository =~ /\.git(\/.*)?$/
-    app_path = RailsPwnage::Config[app_name, instance_name][:app_path]
+    app_path = RailsPwnerer::Config[app_name, instance_name][:app_path]
     
     FileUtils.rm_rf app_path
     print "Doing Git clone, please enter your password if prompted...\n"

data/lib/{pwnage → rails_pwnerer}/app/vcs/perforce.rb

@@ -5,14 +5,14 @@ require 'fileutils'
 require 'pathname'
 require 'set'
 
-class RailsPwnage::App::Perforce
-  include RailsPwnage::Base
+class RailsPwnerer::App::Perforce
+  include RailsPwnerer::Base
   
   # TODO(costan): figure out how to remove unused files in perforce and do it
     
   # remove any files not in client workspace
   def cleanup_app_dir(app_name, instance_name, target_dir, app_name_is_dir = false)
-    path_base = app_name_is_dir ? app_name : RailsPwnage::Config[app_name, instance_name][:app_path]
+    path_base = app_name_is_dir ? app_name : RailsPwnerer::Config[app_name, instance_name][:app_path]
     path_base = File.join path_base, target_dir
     path_base = path_base[0...-1] if path_base[-1] == '/'
     Dir.chdir path_base do
@@ -41,7 +41,7 @@ class RailsPwnage::App::Perforce
   # clean up the application directory by removing caches 
   def cleanup_app_caches(app_name, instance_name, app_name_is_dir = false)
     # TODO: this is almost-duplicated in git.rb -- pull up somewhere
-    app_path = app_name_is_dir ? app_name : RailsPwnage::Config[app_name, instance_name][:app_path]
+    app_path = app_name_is_dir ? app_name : RailsPwnerer::Config[app_name, instance_name][:app_path]
     return unless File.exists?(File.join(app_path, '.p4clientspec'))
     
     # TODO: learn how Rails caches work and kill those too
@@ -73,7 +73,7 @@ class RailsPwnage::App::Perforce
   end
     
   def perforce_update(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
       perforce_config_file
       
       print "Doing Perforce sync...\n"
@@ -85,7 +85,7 @@ class RailsPwnage::App::Perforce
   end
 
   def checkout(remote_path, app_name, instance_name)
-    app_path = RailsPwnage::Config[app_name, instance_name][:app_path]
+    app_path = RailsPwnerer::Config[app_name, instance_name][:app_path]
     
     # paths look like p4://user@depot:port/path/to/application
     path_regexp = /^p4\:\/\/([^\@\/]*\@)?([^\:\/]*)(:[1-9]+)?\/(.*)$/
@@ -127,7 +127,7 @@ END_SETTINGS
     end
 
     print "Creating Perforce client...\n"
-    Dir.chdir RailsPwnage::Config[app_name, instance_name][:app_path] do    
+    Dir.chdir RailsPwnerer::Config[app_name, instance_name][:app_path] do    
       success = Kernel.system "p4 client -i < .p4clientspec"
       if !success
         Kernel.system "p4 client -i < .p4clientspec" if try_prompting_for_perforce_password
@@ -142,7 +142,7 @@ END_SETTINGS
   end
   
   def update(app_name, instance_name)
-    app_path = RailsPwnage::Config[app_name, instance_name][:app_path]
+    app_path = RailsPwnerer::Config[app_name, instance_name][:app_path]
     return unless File.exists?(File.join(app_path, '.p4clientspec'))
     
     # TODO: maybe backup old version before issuing the p4 sync?
@@ -152,19 +152,19 @@ END_SETTINGS
   end
   
   def update_prefetch(app_name, instance_name)
-    app_path = RailsPwnage::Config[app_name, instance_name][:app_path]
+    app_path = RailsPwnerer::Config[app_name, instance_name][:app_path]
     return unless File.exists?(File.join(app_path, '.p4clientspec'))
     
     # TODO: maybe figure out a way to prefetch Perforce, if it's ever worth it
   end
   
   def remove(app_name, instance_name)
-    app_path = RailsPwnage::Config[app_name, instance_name][:app_path]
+    app_path = RailsPwnerer::Config[app_name, instance_name][:app_path]
     return unless File.exists?(File.join(app_path, '.p4clientspec'))
     
     
     print "Deleting Perforce client...\n"
-    Dir.chdir RailsPwnage::Config[app_name, instance_name][:app_path] do    
+    Dir.chdir RailsPwnerer::Config[app_name, instance_name][:app_path] do    
       p4_config = File.read perforce_config_file
       client_match = /^P4CLIENT=(.*)$/.match p4_config
       p4_client = client_match[1]

data/lib/{pwnage → rails_pwnerer}/app/vcs/svn.rb

@@ -5,12 +5,12 @@ require 'fileutils'
 require 'pathname'
 require 'rexml/document'
 
-class RailsPwnage::App::Svn
-  include RailsPwnage::Base
+class RailsPwnerer::App::Svn
+  include RailsPwnerer::Base
     
   # remove any files not in SVN in the application dir
   def cleanup_app_dir(app_name, instance_name, target_dir, app_name_is_dir = false)
-    Dir.chdir(app_name_is_dir ? app_name : RailsPwnage::Config[app_name, instance_name][:app_path]) do
+    Dir.chdir(app_name_is_dir ? app_name : RailsPwnerer::Config[app_name, instance_name][:app_path]) do
       # get a listing of what happened in that directory
       xml_status = `svn status --xml #{target_dir}`
       xsdoc = REXML::Document.new xml_status
@@ -27,7 +27,7 @@ class RailsPwnage::App::Svn
   # clean up the application directory by removing caches 
   def cleanup_app_caches(app_name, instance_name, app_name_is_dir = false)
     # TODO: this is almost-duplicated in git.rb -- pull up somewhere
-    app_path = app_name_is_dir ? app_name : RailsPwnage::Config[app_name, instance_name][:app_path]
+    app_path = app_name_is_dir ? app_name : RailsPwnerer::Config[app_name, instance_name][:app_path]
     return unless File.exists?(File.join(app_path, '.svn'))
     
     # TODO: learn how Rails caches work and kill those too
@@ -39,7 +39,7 @@ class RailsPwnage::App::Svn
   
   # reverts the config changes made by rpwn, so svn update doesn't get confused
   def revert_config_changes(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
       ['config', 'Gemfile'].each do |dir|
         Kernel.system "svn revert --recursive #{dir}"
       end
@@ -47,7 +47,7 @@ class RailsPwnage::App::Svn
   end
     
   def svn_update(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
       print "Doing SVN update, please enter your password if prompted...\n"
       success = Kernel.system 'svn update'
       unless success
@@ -60,7 +60,7 @@ class RailsPwnage::App::Svn
   end
 
   def checkout(remote_path, app_name, instance_name)
-    app_path = RailsPwnage::Config[app_name, instance_name][:app_path]
+    app_path = RailsPwnerer::Config[app_name, instance_name][:app_path]
     return :next unless remote_path =~ /svn.*\:\/\// or remote_path =~ /http.*\:\/\/.*svn/
     
     print "Doing SVN checkout, please enter your password if prompted...\n"
@@ -71,7 +71,7 @@ class RailsPwnage::App::Svn
   end
   
   def update(app_name, instance_name)
-    app_path = RailsPwnage::Config[app_name, instance_name][:app_path]
+    app_path = RailsPwnerer::Config[app_name, instance_name][:app_path]
     return unless File.exists?(File.join(app_path, '.svn'))
     
     # TODO: maybe backup old version before issuing the svn update?
@@ -82,7 +82,7 @@ class RailsPwnage::App::Svn
   end  
   
   def update_prefetch(app_name, instance_name)
-    app_path = RailsPwnage::Config[app_name, instance_name][:app_path]
+    app_path = RailsPwnerer::Config[app_name, instance_name][:app_path]
     return unless File.exists?(File.join(app_path, '.svn'))
     
     # TODO: figure out a way to prefetch using SVN (hidden local repo mirror?)

data/lib/{pwnage → rails_pwnerer}/base/atomics.rb

@@ -4,7 +4,7 @@ require 'digest/md5'
 require 'fileutils'
 require 'yaml'
 
-module RailsPwnage::Base
+module RailsPwnerer::Base
   # reads the content of one file
   # returns nil if the file is corrupted, otherwise returns [file data, timestamp]
   def atomic_read_internal(file_name)

data/lib/{pwnage → rails_pwnerer}/base/cpus.rb

@@ -44,7 +44,7 @@ else
   
 end
 
-module RailsPwnage::Base
+module RailsPwnerer::Base
   # returns information for each core in the system
   def cpu_cores
     cpus = []

data/lib/{pwnage → rails_pwnerer}/base/dirs.rb

@@ -3,7 +3,7 @@
 require 'etc'
 require 'fileutils'
 
-module RailsPwnage::Base  
+module RailsPwnerer::Base  
   # gets the UID associated with the username
   def uid_for_username(name)
     passwd_entry = Etc.getpwnam(name)

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

@@ -1,6 +1,6 @@
 # extends Base with gem-related functions
 
-module RailsPwnage::Base
+module RailsPwnerer::Base
   # TODO: use the Gem API instead of the command line
 
   def install_gem(gem_name)
@@ -50,7 +50,7 @@ module RailsPwnage::Base
   end
 end
 
-module RailsPwnage::Base  
+module RailsPwnerer::Base  
   def install_gems(gem_names)
     unroll_collection(gem_names) { |n| install_gem(n) }
   end

data/lib/{pwnage → rails_pwnerer}/base/hostname.rb

@@ -3,6 +3,6 @@
 require 'digest/md5'
 require 'yaml'
 
-module RailsPwnage::Base
+module RailsPwnerer::Base
   
 end

data/lib/{pwnage → rails_pwnerer}/base/input.rb

@@ -7,7 +7,7 @@ rescue Exception
   # no highline... tough luck
 end
 
-module RailsPwnage::Base
+module RailsPwnerer::Base
   def prompt_user_for_password(prompt, fail_prompt)
     unless defined?(HighLine)
       print "#{fail_prompt}\n"

data/lib/rails_pwnerer/base/packages.rb

@@ -0,0 +1,272 @@
+# extends Base with OS package-related functions
+
+require 'English'
+require 'fileutils'
+require 'shellwords'
+
+module RailsPwnerer::Base
+  # TODO: this works for debian-only
+
+  # Installs a package matching a pattern or list of patterns.
+  #
+  # Args:
+  #   patterns:: same as for best_package_matching
+  #   options:: same as for install_package
+  #
+  # Returns true for success, false if something went wrong. 
+  def install_package_matching(patterns, options = {})
+    package_name = best_package_matching patterns
+    install_package package_name, options
+  end
+
+  # Installs a package.
+  #
+  # Args:
+  #   package_name:: the exact name of the package to be installed
+  #   options:: accepts the following:
+  #     :source:: if true, a source package is installed and built
+  #     :skip_proxy:: if true, apt is instructed to bypass any proxy that might
+  #                   be 
+  #
+  # Returns true for success, false if something went wrong. 
+  def install_package(package_name, options = {})
+    return true if install_package_impl(package_name, options)
+    if options[:source]
+      if options[:no_proxy]
+        install_package package_name, options.merge(:source => false)
+      else
+        install_package package_name, options.merge(:no_proxy => true)
+      end
+    else
+      return false unless options[:no_proxy]
+      install_package package_name, options.merge(:no_proxy => true)
+    end
+  end
+  
+  # Removes a package.
+  #
+  # Args:
+  #   package_name:: the exact name of the package to be installed
+  #
+  # Returns true for success, false if something went wrong. 
+  def remove_package(package_name, options = {})
+    prefix, params = apt_params_for options
+    del_cmd = "#{prefix } apt-get remove #{params} #{package_name}"
+    Kernel.system(del_cmd) ? true : false
+  end  
+
+  # Internals for install_package.
+  def install_package_impl(package_name, options)
+    prefix, params = apt_params_for options
+    if options[:source]
+      with_temp_dir(:root => true) do
+        dep_cmd = "#{prefix} apt-get build-dep #{params} #{package_name}"
+        return false unless Kernel.system(dep_cmd)
+        fetch_cmd = "#{prefix} apt-get source -b #{params} #{package_name}"
+        return false unless Kernel.system(fetch_cmd)
+        deb_files = Dir.glob '*.deb', File::FNM_DOTMATCH
+        build_cmd = "#{prefix} dpkg -i #{deb_files.join(' ')}"
+        return false unless Kernel.system(build_cmd)
+      end
+    else
+      install_cmd = "#{prefix} apt-get install #{params} #{package_name}"
+      return false unless Kernel.system(install_cmd)
+    end
+    return true
+  end
+  
+  # Executes the given block in the context of having new package sources.
+  #
+  # Args:
+  #   source_url:: the source URL, e.g. http://security.ubuntu.com/ubuntu
+  #   repositories:: the package repositories to use, e.g. ['main', 'universe']
+  #   options:: supports the following keys:
+  #             :source:: if true, will use source-form packages from the new
+  #                       sources; by default, binary packages will be used
+  #
+  # Returns the block's return value.
+  #
+  # After adding the new package source, the package metadata is refreshed, so
+  # the block can focus on installing new packages.
+  #
+  # If the package source already exists, the given block is yielded without
+  # making any changes to the package configuration. 
+  def with_package_source(source_url, source_repos = [], options = {})
+    source_prefix = options[:source] ? 'deb-src' : 'deb'
+    source_patterns = [source_prefix, source_url] + source_repos    
+    
+    source_contents = File.read '/etc/apt/sources.list'
+    sources = source_contents.split(/(\r|\n)+/)
+    source_exists = sources.any? do |source_line|
+      source_frags = source_line.split(' ')
+      source_patterns.all? { |pattern| source_frags.any? { |frag| frag == pattern } }
+    end
+
+    unless source_exists
+      File.open('/etc/apt/sources.list', 'a') do |f|
+        f.write "#{source_prefix} #{source_url} #{source_repos.join(' ')}\n"
+      end
+      update_package_metadata
+    end
+    
+    begin
+      yield
+    ensure
+      unless source_exists
+        File.open('/etc/apt/sources.list', 'w') { |f| f.write source_contents }
+        update_package_metadata        
+      end
+    end
+  end  
+    
+  # Updates the metadata for all the packages.
+  #
+  # Options:
+  #   :skip_proxy:: if true, apt is instructed to bypass the proxy
+  #
+  # Returns true for success, false if something went wrong. 
+  def update_package_metadata(options = {})
+    if update_package_metadata_impl(options)
+      # Reset the metadata cache.
+      RailsPwnerer::Base.instance_variable_set :@packages, nil
+      return true
+    end
+    
+    return false if options[:skip_proxy]
+    update_package_metadata options.merge(:skip_proxy => true)
+  end
+  
+  # Internals for update_package_metadata.
+  def update_package_metadata_impl(options)
+    prefix, params = apt_params_for options
+    Kernel.system("#{prefix} apt-get update #{params}") ?
+        true : false
+  end
+  private :update_package_metadata_impl
+  
+  # Builds apt-get parameters for an option hash.
+  #
+  # Args:
+  #   options:: an option hash, as passed to install_package, update_package,
+  #             or update_package_metadata
+  #
+  # Returns prefix, args, where prefix is a prefix for the apt- command, and
+  # args is one or more command-line arguments.
+  def apt_params_for(options = {})
+    prefix = 'env DEBIAN_FRONTEND=noninteractive '
+    prefix += 'DEBIAN_PRIORITY=critical '
+    prefix += 'DEBCONF_TERSE=yes '
+    
+    params = "-qq -y"
+    params += " -o Acquire::http::Proxy=false" if options[:skip_proxy]
+    return prefix, params
+  end
+  private :apt_params_for  
+  
+  # Package info for the best package matching a pattern or set of patterns.
+  #
+  # Args:
+  #   patterns:: a String or Regexp, or an array of such Strings or Regexps
+  #
+  # Returns a hash with the following keys:
+  #   :name:: the package name
+  #   :version:: the package version
+  #
+  # Each pattern is searched for in turn. Once there are packages matching a
+  # pattern, the 
+  def best_package_matching(patterns)
+    patterns = [patterns] unless patterns.kind_of?(Enumerable)
+    patterns.each do |pattern|
+      packages = search_packages(pattern)
+      next if packages.empty?      
+      best = packages.sort_by { |key, value|
+        [
+          pattern.kind_of?(Regexp) ? ((key.index(pattern) == 0) ? 1 : 0) :
+              ((key == pattern) ? 1 : 0),
+          value.split(/[.-]/)
+        ]
+      }.last      
+      return { :name => best.first, :version => best.last }
+    end
+    nil
+  end
+
+  # Searches for packages matching a name.
+  #
+  # Args:
+  #   pattern:: a String or Regexp containing a pattern that should be matched
+  #             by the package names
+  #
+  # Returns a hash where the keys are matching package names, and the values
+  # are version numbers.
+  def search_packages(pattern)
+    Hash[*(RailsPwnerer::Base.all_packages.select { |key, value|
+      pattern.kind_of?(Regexp) ? (pattern =~ key) : key.index(pattern)
+    }.flatten)]
+  end
+
+  # A hash of all the packages in the system, associated with their versions.
+  @packages = nil
+  def self.all_packages
+    @packages ||= all_packages_without_caching
+  end
+  
+  # A hash of all the packages in the system, associated with their versions.
+  #
+  # This method is slow as hell, so it's memoized in all_packages.
+  def self.all_packages_without_caching
+    output = Kernel.` "apt-cache search --full ."
+    versions = output.split("\n\n").map(&:strip).reject(&:empty?).map { |info|
+      info_hash = Hash[*(info.split(/\n(?=\w)/).
+                              map { |s| s.split(': ', 2) }.flatten)]
+      [info_hash['Package'], info_hash['Version']]
+    }
+    Hash[*(versions.flatten)]    
+  end
+  
+  # Upgrades a package to the latest version.
+  def upgrade_package(package_name, options = {})
+    return install_package(package_name, options) if options[:source]
+    
+    return true if upgrade_package_impl(package_name, options)
+      
+    return false if options[:no_proxy]
+    upgrade_package package_name, options.merge(:no_proxy => true)
+  end
+
+  # Internals for upgrade_package.
+  def upgrade_package_impl(package_name, options)
+    prefix, params = apt_params_for options
+    update_cmd = "#{prefix} apt-get upgrade #{params} #{package_name}"
+    Kernel.system(update_cmd) ? true : false
+  end
+  
+  # Upgrades all the packages on the system to the latest version.
+  def update_all_packages(options = {})
+    return true if update_all_packages_impl(options)
+    
+    return false if options[:no_proxy]
+    update_all_packages options.merge(:no_proxy => true)
+  end  
+  
+  # Internals for upgrade_all_packages.
+  def update_all_packages_impl(options)
+    prefix, params = apt_params_for options    
+    success = Kernel.system "#{prefix} apt-get upgrade #{params}"
+    success ? true : false
+  end
+end
+
+module RailsPwnerer::Base  
+  def install_packages(package_names, options = {})
+    unroll_collection(package_names) { |n| install_package(n, options) }
+  end
+  
+  def upgrade_packages(package_names, options = {})
+    unroll_collection(package_names) { |n| upgrade_package(n, options) }
+  end
+
+  def remove_packages(package_names)
+    unroll_collection(package_names) { |n| remove_package(n) }
+  end
+end

data/lib/{pwnage → rails_pwnerer}/base/process.rb

@@ -31,7 +31,7 @@ rescue Exception
   end
 end
 
-module RailsPwnage::Base  
+module RailsPwnerer::Base  
   # returns information about a process
   def process_info(pid = nil)
     info = Hash.new

data/lib/{pwnage → rails_pwnerer}/base/rails.rb

@@ -1,6 +1,6 @@
 # extends Base with Rails-related functions
 
-module RailsPwnage::Base
+module RailsPwnerer::Base
   # check if the given path is the root of a Rails application
   def check_rails_root(path = '.')
     ['app', 'config', 'db', 'public', 'script', 'vendor',

data/lib/{pwnage → rails_pwnerer}/base/startup.rb

@@ -2,7 +2,7 @@
 
 require 'fileutils'
 
-module RailsPwnage::Base
+module RailsPwnerer::Base
   # TODO: make this work w/o initd (OSX, Windows)
 
    # returns the filesystem path to a boot script

data/lib/{pwnage → rails_pwnerer}/base.rb

@@ -1,4 +1,4 @@
-module RailsPwnage::Base   
+module RailsPwnerer::Base   
   # initializes the module in UNIX mode
   def self._setup_unix
     #SUDO_PREFIX = 'sudo '

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

@@ -1,6 +1,6 @@
 # application-specific configuration functions
 
-module RailsPwnage::Config
+module RailsPwnerer::Config
   # the name of the database storing an app's configuration
   def self.app_db_name(app_name, instance_name)
     return "#{app_name}.#{instance_name}"

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

@@ -1,6 +1,6 @@
 # computes the number of frontends to be used in an application
 
-module RailsPwnage::Config
+module RailsPwnerer::Config
   # the number of frontends for an application
   def self.app_frontends(app_name, instance_name)
     # TODO: this is duplicated in cluster_config.rb -- pull up somewhere

data/lib/rails_pwnerer/config/main.rb

@@ -0,0 +1,3 @@
+module RailsPwnerer::Config
+
+end

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

@@ -1,6 +1,6 @@
 # important paths in the filesystem
 
-module RailsPwnage::Config
+module RailsPwnerer::Config
   # the path to something important (e.g. :apps --> path to all production applications)
   def self.path_to(what = :prod, app_name = nil)
     # need to hardcode path to config to avoid endless recursion

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

@@ -1,6 +1,6 @@
 # keeps track of the available ports on the machine
 
-module RailsPwnage::Config
+module RailsPwnerer::Config
   def self.init_ports(free_ports = [[8000, 16000]])
     self.create_db :free_ports
     self[:free_ports][:list] = free_ports