rails_pwnerer 0.5.0 → 0.5.1

data/CHANGELOG

@@ -1,3 +1,5 @@
+v0.5.1. Application instances with per-instance configuration.
+
 v0.5.0. Implemented configuration repository.
 
 v0.4.19. Fixed bug in cleaning up application directory on SVN update.

data/lib/pwnage/app/cluster_config.rb

@@ -5,47 +5,64 @@ require 'fileutils'
 class RailsPwnage::App::ClusterConfig
   include RailsPwnage::Base
   
-  def fix_permissions(app_name)
-    pwnerer_user = RailsPwnage::Config.pwnerer_user
+  def fix_permissions(app_name, instance_name)
+    app_config = RailsPwnage::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)
     
-    Dir.chdir(RailsPwnage::Config.path_to(app_name)) do
+    Dir.chdir app_config[:app_path] do
       %w(log tmp public).each do |writable_dir|
         FileUtils.chown_R(pwnerer_uid, pwnerer_group, writable_dir)
       end
     end
   end
+  
+  def manage_ports(app_name, instance_name, action)
+    app_config = RailsPwnage::Config[app_name, instance_name]
+    return unless app_config and app_config[:port0] and app_config[:mongrels]
+    
+    case action
+    when :alloc
+      app_config[:port0] = RailsPwnage::Config.alloc_ports app_config[:mongrels]
+    when :free
+      RailsPwnage::Config.free_ports app_config[:port0], app_config[:mongrels]
+      app_config[:port0] = 0
+    end
+    RailsPwnage::Config.flush_db RailsPwnage::Config.app_db_name(app_name, instance_name)
+  end
 
-  def configure_mongrels(app_name)
-    app_path = RailsPwnage::Config.path_to app_name
-    pwnerer_user = RailsPwnage::Config.pwnerer_user
+
+  def configure_mongrels(app_name, instance_name)
+    app_config = RailsPwnage::Config[app_name, instance_name]
+
+    app_path, pwnerer_user = app_config[:app_path], app_config[:pwnerer_user]
     pwnerer_group = group_for_username(pwnerer_user)
     
-    instances = RailsPwnage::Config.app_instances(app_name)
-    first_port = RailsPwnage::Config.app_port0(app_name)
+    mongrels, first_port = app_config[:mongrels], app_config[:port0]
     
     Dir.chdir(app_path) do
       # create the mongrel_cluster configuration
-      system "mongrel_rails cluster::configure -e production -N #{instances} -p #{first_port} -a 127.0.0.1 -c #{app_path} --user #{pwnerer_user} --group #{pwnerer_group}"
+      system "mongrel_rails cluster::configure -e production -N #{mongrels} -p #{first_port} -a 127.0.0.1 -c #{app_path} --user #{pwnerer_user} --group #{pwnerer_group}"
       
       # copy the configuration to the launch directory
-      launch_config = File.join RailsPwnage::Config.path_to(:mongrel_configs), "#{app_name}.yml"
+      launch_config = File.join RailsPwnage::Config.path_to(:mongrel_configs), "#{app_name}.#{instance_name}.yml"
       FileUtils.cp 'config/mongrel_cluster.yml', launch_config
     end
   end
   
-  def remove_mongrels(app_name)
+  def remove_mongrels(app_name, instance_name)
     # bomb the configuration from the launch directory
-    launch_config = File.join RailsPwnage::Config.path_to(:mongrel_configs), "#{app_name}.yml"
+    launch_config = File.join RailsPwnage::Config.path_to(:mongrel_configs), "#{app_name}.#{instance_name}.yml"
     File.delete launch_config if File.exists? launch_config   
   end
   
-  def stop_mongrels(app_name)
+  def stop_mongrels(app_name, instance_name)
+    app_config = RailsPwnage::Config[app_name, instance_name]
     # silently die if the app was completely busted
-    return unless File.exists? RailsPwnage::Config.path_to(app_name)
+    return unless app_config and File.exists? app_config[:app_path]
     
-    Dir.chdir(RailsPwnage::Config.path_to(app_name)) do
+    Dir.chdir app_config[:app_path] do
       system 'mongrel_rails cluster::stop'
       
       # clean up PID files in case the mongrels died and left them behind
@@ -53,40 +70,45 @@ class RailsPwnage::App::ClusterConfig
     end
   end
   
-  def start_mongrels(app_name)
+  def start_mongrels(app_name, instance_name)
+    app_config = RailsPwnage::Config[app_name, instance_name]
     # silently die if the app was completely busted
-    return unless File.exists? RailsPwnage::Config.path_to(app_name)
+    return unless app_config and File.exists? app_config[:app_path]
     
-    Dir.chdir(RailsPwnage::Config.path_to(app_name)) do
+    Dir.chdir app_config[:app_path] do
       system 'mongrel_rails cluster::start'
     end    
   end
 
-  def setup(app_name)
-    configure_mongrels app_name
-    fix_permissions app_name
+  def setup(app_name, instance_name)
+    manage_ports app_name, instance_name, :alloc
+    configure_mongrels app_name, instance_name
+    fix_permissions app_name, instance_name
   end
   
-  def update(app_name, &update_proc)
-    stop_mongrels(app_name)
+  def update(app_name, instance_name, &update_proc)
+    stop_mongrels app_name, instance_name
+    manage_ports app_name, instance_name, :free
     yield
   ensure
-    configure_mongrels app_name
-    fix_permissions app_name
-    start_mongrels(app_name)    
+    manage_ports app_name, instance_name, :alloc
+    configure_mongrels app_name, instance_name
+    fix_permissions app_name, instance_name
+    start_mongrels app_name, instance_name
   end
   
-  def remove(app_name)
-    remove_mongrels app_name
+  def remove(app_name, instance_name)
+    remove_mongrels app_name, instance_name
+    manage_ports app_name, instance_name, :free
   end
   
-  def manage(app_name, action)
+  def manage(app_name, instance_name, action)
     case action
     when :checkpoint
       # nothing to do here
     when :rollback
-      configure_mongrels app_name
-      fix_permissions app_name      
+      configure_mongrels app_name, instance_name
+      fix_permissions app_name, instance_name
     end
   end
   
@@ -97,25 +119,5 @@ class RailsPwnage::App::ClusterConfig
     when :stop
       control_boot_script('mongrel_cluster', :stop)
     end
-  end
-  
-  def self.setup(app_name)
-    self.new.setup(app_name)
-  end
-  
-  def self.remove(app_name)
-    self.new.remove(app_name)
-  end
-
-  def self.update(app_name, &update_proc)
-    self.new.update(app_name, &update_proc)
-  end
-  
-  def self.manage(app_name, action)
-    self.new.manage(app_name, action)
-  end  
-  
-  def self.control_all(action = :start)
-    self.new.control_all(action) 
   end  
 end

data/lib/pwnage/app/database.rb

@@ -6,12 +6,14 @@ class RailsPwnage::App::Database
   include RailsPwnage::Base
 
   # creates/drops the mysql database for the application
-  def admin_database(app_name, action = :create)
-    db_name = RailsPwnage::Config.app_dbname(app_name)
-    db_user = RailsPwnage::Config.app_db_user(app_name)
-    db_pass = RailsPwnage::Config.app_db_password(app_name)
+  def admin_database(app_name, instance_name, action = :create)
+    app_config = RailsPwnage::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]
+
+    db_name, db_user, db_pass = app_config[:db_name], app_config[:db_user], app_config[:db_pass]
     
-    Dir.chdir(RailsPwnage::Config.path_to(app_name)) do
+    with_temp_dir do
       # put together the admin script
       case action
       when :create
@@ -26,53 +28,55 @@ ENDSQL
       end
       
       # run it
-      File.open('tmp/admin_db.sql', 'w') { |f| f.write sql_commands }
-      system "mysql -uroot < tmp/admin_db.sql"
+      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]
+      dbpass_arg = dbroot_pass.empty? ? '' : "-p#{dbroot_pass}"
+      system "mysql -u#{dbroot_name} #{dbpass_arg} < admin_db.sql"
       
       # cleanup
-      File.delete('tmp/admin_db.sql')
+      File.delete('admin_db.sql')
     end    
   end
     
   # configures rails to use the database in the production environment
-  def configure_rails(app_name)
-    db_name = RailsPwnage::Config.app_dbname(app_name)
-    db_user = RailsPwnage::Config.app_db_user(app_name)
-    db_pass = RailsPwnage::Config.app_db_password(app_name)
+  def configure_rails(app_name, instance_name)
+    app_config = RailsPwnage::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 = RailsPwnage::Config.path_to(app_name) + File::SEPARATOR + 'config' + File::SEPARATOR + 'database.yml'
+    config_file = File.join app_config[:app_path], 'config', 'database.yml'
     configuration = File.open(config_file, 'r') { |f| YAML.load f }    
     configuration['production'].merge! 'adapter' => 'mysql', 'database' => db_name, 'username' => db_user, 'password' => db_pass
     File.open(config_file, 'w') { |f| YAML.dump(configuration, f) }
     
     # bonus: lock down the database so only the right user can access it
-    pwnerer_user = RailsPwnage::Config.pwnerer_user
+    pwnerer_user = app_config[:pwnerer_user]
     File.chmod(0600, config_file)
     File.chown(uid_for_username(pwnerer_user), gid_for_username(pwnerer_user), config_file)
   end
   
   # migrates the database to the latest schema version
-  def migrate_database(app_name)
-    Dir.chdir(RailsPwnage::Config.path_to(app_name)) do
+  def migrate_database(app_name, instance_name)
+    Dir.chdir RailsPwnage::Config[app_name, instance_name][:app_path] do
       # now migrate the database
       system "rake db:migrate RAILS_ENV=production"
     end
   end
   
   # creates a database dump in the backup area
-  def dump_database(app_name)
-    db_name = RailsPwnage::Config.app_dbname(app_name)
-    db_user = RailsPwnage::Config.app_db_user(app_name)
-    db_pass = RailsPwnage::Config.app_db_password(app_name)    
+  def dump_database(app_name, instance_name)
+    app_config = RailsPwnage::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 = RailsPwnage::Config.pwnerer_user
+    pwnerer_user = app_config[: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 = "db/#{app_name}_#{timestamp}.sql"
-    Dir.chdir(RailsPwnage::Config.path_to(:backup, app_name)) do
-      system "mysqldump --add-drop-database --add-drop-table --extended-insert --single-transaction -u#{db_user} -p#{db_pass} #{db_name} > #{dump_file}"
+    dump_file = "db/#{app_name}.#{instance_name}_#{timestamp}.sql"
+    Dir.chdir app_config[:backup_path] do
+      system("mysqldump --add-drop-database --add-drop-table --extended-insert" +
+             " --single-transaction -u#{db_user} -p#{db_pass} #{db_name} > #{dump_file}")
       # lockdown the file
       File.chmod(0400, dump_file)
       File.chown(pwnerer_uid, pwnerer_gid, dump_file)
@@ -80,48 +84,46 @@ ENDSQL
   end
   
   # loads the latest database dump from the backup area
-  def load_database(app_name)
-    db_name = RailsPwnage::Config.app_dbname(app_name)
-    db_user = RailsPwnage::Config.app_db_user(app_name)
-    db_pass = RailsPwnage::Config.app_db_password(app_name)    
+  def load_database(app_name, instance_name)
+    app_config = RailsPwnage::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(RailsPwnage::Config.path_to(:backup, app_name)) do
+    Dir.chdir app_config[:backup_path] do
       # find the latest dump and load it in
-      dump_file = Dir.glob("db/#{app_name}_*").max
+      dump_file = Dir.glob("db/#{app_name}.#{instance_name}_*").max
       system "mysql -u#{db_user} -p#{db_pass} #{db_name} < #{dump_file}"
     end
   end
 
-  def setup(app_name)
+  def setup(app_name, instance_name)
     control_boot_script('mysql', :start)
-    admin_database app_name, :create
-    configure_rails app_name
-    migrate_database app_name
+    admin_database app_name, instance_name, :create
+    configure_rails app_name, instance_name
+    migrate_database app_name, instance_name
   end
   
-  def update(app_name)
+  def update(app_name, instance_name)
     control_boot_script('mysql', :start)
-    configure_rails app_name
-    migrate_database app_name
+    configure_rails app_name, instance_name
+    migrate_database app_name, instance_name
   end
   
-  def remove(app_name)
+  def remove(app_name, instance_name)
     control_boot_script('mysql', :start)
-    admin_database app_name, :drop    
+    admin_database app_name, instance_name, :drop    
   end
   
   # backs up or restores the database
-  def manage(app_name, action)
-    
+  def manage(app_name, instance_name, action)
     case action
     when :checkpoint
-      dump_database app_name
+      dump_database app_name, instance_name
     when :rollback
-      admin_database app_name, :drop
-      admin_database app_name, :create
-      load_database app_name
-      configure_rails app_name      
-      migrate_database app_name
+      admin_database app_name, instance_name, :drop
+      admin_database app_name, instance_name, :create
+      load_database app_name, instance_name
+      configure_rails app_name, instance_name
+      migrate_database app_name, instance_name
     end
   end
   
@@ -133,24 +135,4 @@ ENDSQL
       control_boot_script('mysql', :stop)
     end
   end  
-  
-  def self.setup(app_name)
-    self.new.setup(app_name)
-  end
-  
-  def self.update(app_name)
-    self.new.update(app_name)
-  end
-  
-  def self.remove(app_name)
-    self.new.remove(app_name)
-  end
-  
-  def self.manage(app_name, action)
-    self.new.manage(app_name, action)
-  end  
-  
-  def self.control_all(action = :start)
-    self.new.control_all(action) 
-  end  
 end

data/lib/pwnage/app/gems.rb

@@ -2,26 +2,16 @@
 
 class RailsPwnage::App::Gems
   include RailsPwnage::Base
-
-  def setup(app_name)
-    Dir.chdir(RailsPwnage::Config.path_to(app_name)) do
-      # install the gems needed by the app
-      system "rake gems:install RAILS_ENV=production"
-    end    
-  end
   
-  def update(app_name)
-    Dir.chdir(RailsPwnage::Config.path_to(app_name)) do
+  def update(app_name, instance_name)
+    app_path = RailsPwnage::Config[app_name, instance_name][:app_path]
+    Dir.chdir app_path do
       # install the gems needed by the app
       system "rake gems:install RAILS_ENV=production"
     end    
   end
 
-  def self.setup(app_name)
-    self.new.setup(app_name)    
-  end
-
-  def self.update(app_name)
-    self.new.update(app_name)
+  def setup(app_name, instance_name)
+    update(app_name, instance_name)
   end
 end

data/lib/pwnage/app/main.rb

@@ -1,51 +1,72 @@
 module RailsPwnage::App
-  # installs an application given its SVN path
-  def self.install(svn_path)
-    app_name = Svn.setup(svn_path)
-    Gems.setup(app_name)
-    Database.setup(app_name)
-    ClusterConfig.setup(app_name)
-    NginxConfig.setup(app_name)
+  # 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 }
+    when '.'
+      yield app_name, RailsPwnage::Config[:host][:instance]
+    else
+      yield app_name, instance_name
+    end
   end
   
+  # installs an application given its SVN path
+  def self.install(svn_path, instance_name)
+    app_name = File.basename svn_path
+    instance_magic(app_name, instance_name) do |app, instance|
+      Config.new.alloc app, instance
+      Svn.new.checkout svn_path, app, instance
+      [Config, Svn, Gems, Database, ClusterConfig, NginxConfig].each do |mod|
+        mod.new.setup app, instance
+      end    
+    end
+  end
+    
   # updates an application (restart servers if necessary)
-  def self.update(app_name)
-    ClusterConfig.update app_name do    
-      Svn.update app_name
-      Gems.update app_name
-      Database.update app_name
-    end    
-    NginxConfig.update app_name
+  def self.update(app_name, instance_name)    
+    instance_magic(app_name, instance_name) do |app, instance|
+      ClusterConfig.new.update app, instance do
+        [Svn, Config, Gems, Database].each do |mod|
+          mod.new.update app, instance  
+        end
+      end    
+      NginxConfig.new.update app, instance
+    end
   end
   
   # removes an application (and stops its servers)
-  def self.remove(app_name)
-    ClusterConfig.remove app_name
-    NginxConfig.remove app_name
-    Database.remove app_name
-    Svn.remove app_name
+  def self.remove(app_name, instance_name)
+    instance_magic(app_name, instance_name) do |app, instance|    
+      [ClusterConfig, NginxConfig, Database, Svn, Config].each do |mod|
+        mod.new.remove app, instance
+      end
+    end    
   end
 
   # performs application management (checkpoint / rollback / console)
-  def self.manage(app_name, action = :checkpoint)
-    case action
-      when :checkpoint
-        ClusterConfig.manage app_name, action
-        Svn.manage app_name, action
-        ClusterConfig.update app_name do          
-          Database.manage app_name, action
-        end
-      when :rollback
-        ClusterConfig.update app_name do
-          Svn.manage app_name, action
-          Database.manage app_name, action
-          ClusterConfig.manage app_name, action
-        end
-      when :console
-        Svn.manage app_name, action
-      when :db_console
-        Svn.manage app_name, action
-    end    
+  def self.manage(app_name, instance_name, action = :checkpoint)
+    instance_magic(app_name, instance_name) do |app, instance|
+      # TODO: add backup / restore for the configuration db (easy)
+      case action
+        when :checkpoint
+          ClusterConfig.new.manage app, instance, action
+          Svn.new.manage app, instance, action
+          ClusterConfig.new.update app, instance do          
+            Database.new.manage app, instance, action
+          end
+        when :rollback
+          ClusterConfig.new.update app, instance do
+            [Svn, Database, ClusterConfig].each do |mod|
+              mod.new.manage app, instance, action
+            end
+          end
+        when :console
+          Svn.new.manage app, instance, action
+        when :db_console
+          Svn.new.manage app, instance, action
+      end    
+    end        
   end
   
   # start or stop all apps
@@ -53,13 +74,13 @@ module RailsPwnage::App
     case action
     when :start
       control_all :stop
-      Database.control_all :start
-      ClusterConfig.control_all :start
-      NginxConfig.control_all :start
+      Database.new.control_all :start
+      ClusterConfig.new.control_all :start
+      NginxConfig.new.control_all :start
     when :stop
-      NginxConfig.control_all :stop
-      ClusterConfig.control_all :stop
-      Database.control_all :stop
+      NginxConfig.new.control_all :stop
+      ClusterConfig.new.control_all :stop
+      Database.new.control_all :stop
     end
   end
 end

data/lib/pwnage/app/nginx_config.rb

@@ -4,15 +4,16 @@ class RailsPwnage::App::NginxConfig
   include RailsPwnage::Base
   
   # writes the nginx configuration for this server
-  def config_nginx(app_name)
-    first_port = RailsPwnage::Config.app_port0(app_name)
-    hostname_filter = RailsPwnage::Config.app_servername(app_name)
+  def config_nginx(app_name, instance_name)
+    app_config = RailsPwnage::Config[app_name, instance_name]
+    first_port = app_config[:port0]
+    hostname_filter = app_config[:dns_name]
     
-    nginx_config = File.join(RailsPwnage::Config.path_to(:nginx_configs), app_name) 
+    nginx_config = File.join(RailsPwnage::Config.path_to(:nginx_configs), app_name + '.' + instance_name) 
     File.open(nginx_config, 'w') do |f|
       # link to the mongrels
-      f << "  upstream #{app_name} {\n"
-      RailsPwnage::Config.app_instances(app_name).times do |instance|
+      f << "  upstream #{app_name}_#{instance_name} {\n"
+      app_config[:mongrels].times do |instance|
         f << "    server 127.0.0.1:#{first_port + instance};\n"
       end
       f << "  }\n\n"
@@ -21,9 +22,9 @@ class RailsPwnage::App::NginxConfig
       f << <<NGINX_CONFIG
   server {
     listen 80;
-    #{(hostname_filter.nil? ? '' : "server_name " + hostname_filter + ";")}
-    root #{RailsPwnage::Config.path_to(app_name)};
-    client_max_body_size #{RailsPwnage::Config.app_max_request_mb(app_name)}M;
+    #{(hostname_filter.empty? ? '' : "server_name " + hostname_filter + ";")}
+    root #{app_config[:app_path]};
+    client_max_body_size #{app_config[:max_request_mb]}M;
     location / {
       proxy_set_header X-Real-IP $remote_addr;
       proxy_set_header Host $host;
@@ -38,7 +39,7 @@ class RailsPwnage::App::NginxConfig
         rewrite (.*) $1.html break;
       }
       if (!-f $request_filename) {
-        proxy_pass http://#{app_name};
+        proxy_pass http://#{app_name}_#{instance_name};
         break;
       }
     }
@@ -47,8 +48,8 @@ NGINX_CONFIG
     end    
   end
   
-  def remove_nginx_config(app_name)
-    nginx_config = File.join(RailsPwnage::Config.path_to(:nginx_configs), app_name) 
+  def remove_nginx_config(app_name, instance_name)
+    nginx_config = File.join(RailsPwnage::Config.path_to(:nginx_configs), app_name + '.' + instance_name) 
     File.delete nginx_config if File.exists? nginx_config    
   end
   
@@ -58,13 +59,13 @@ NGINX_CONFIG
     File.delete stub_file  if File.exists?(stub_file)
   end
   
-  def setup(app_name)
-    config_nginx app_name
+  def setup(app_name, instance_name)
+    config_nginx app_name, instance_name
     remove_nginx_stub
   end
   
-  def remove(app_name)
-    remove_nginx_config app_name
+  def remove(app_name, instance_name)
+    remove_nginx_config app_name, instance_name
   end
   
   def control_all(action)
@@ -78,19 +79,7 @@ NGINX_CONFIG
     end
   end  
 
-  def self.setup(app_name)
-    self.new.setup(app_name)
-  end
-  
-  def self.update(app_name)
+  def update(app_name, instance_name)
     # nothing to do here, unless we enable config rewriting    
   end
-  
-  def self.remove(app_name)
-    self.new.remove(app_name)
-  end
-  
-  def self.control_all(action = :start)
-    self.new.control_all(action) 
-  end    
 end

data/lib/pwnage/app/svn.rb

@@ -1,39 +1,22 @@
 # checks out the application
 
 require 'fileutils'
+require 'pathname'
 require 'rexml/document'
 
 class RailsPwnage::App::Svn
   include RailsPwnage::Base
-  
-  def svn_checkout(svn_path)
-    app_name = File.basename(svn_path)
-
-    prod_apps = RailsPwnage::Config.path_to :apps
-    Dir.chdir(prod_apps) do
-      # checkout application
-      system "svn co #{svn_path} #{app_name}"
-    end
     
-    return app_name
-  end
-  
-  def svn_update(app_name)
-    Dir.chdir(RailsPwnage::Config.path_to(app_name)) do
-      system "svn update"
-    end
-  end
-  
-  def scaffold_backup(app_name)
-    pwnerer_user = RailsPwnage::Config.pwnerer_user
+  def scaffold_backup(app_name, instance_name)
+    pwnerer_user = RailsPwnage::Config[app_name, instance_name][:pwnerer_user]
     pwnerer_uid = uid_for_username(pwnerer_user)
     pwnerer_gid = gid_for_username(pwnerer_user)
 
-    backup_dir = RailsPwnage::Config.path_to :backup, app_name
-    FileUtils.mkpath backup_dir unless File.exists? backup_dir
-    File.chown(pwnerer_uid, pwnerer_gid, backup_dir)
+    backup_path = RailsPwnage::Config[app_name, instance_name][:backup_path]
+    FileUtils.mkpath backup_path unless File.exists? backup_path
+    File.chown(pwnerer_uid, pwnerer_gid, backup_path)
     
-    Dir.chdir(RailsPwnage::Config.path_to(:backup, app_name)) do
+    Dir.chdir(backup_path) do
       ['db', 'files', 'tmp'].each do |subdir|
         Dir.mkdir subdir unless File.exists? subdir
         File.chown pwnerer_uid, pwnerer_gid, subdir
@@ -42,26 +25,28 @@ class RailsPwnage::App::Svn
   end
   
   # dump the application files to the backup area
-  def dump_files(app_name)
-    pwnerer_user = RailsPwnage::Config.pwnerer_user
+  def dump_files(app_name, instance_name)
+    pwnerer_user = RailsPwnage::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}_#{timestamp}.tar.gz"
+    dump_file = "files/#{app_name}.#{instance_name}_#{timestamp}.tar.gz"
     
-    Dir.chdir(RailsPwnage::Config.path_to(:backup, app_name)) do
+    backup_path = RailsPwnage::Config[app_name, instance_name][:backup_path]
+    app_path = RailsPwnage::Config[app_name, instance_name][:app_path]
+    Dir.chdir backup_path do
       # create a cold copy of the application files
-      cold_copy = "tmp#{File::SEPARATOR}#{app_name}"
+      cold_copy = File.join('tmp', File.basename(app_path))
       FileUtils.rm_r cold_copy if File.exists? cold_copy
-      FileUtils.cp_r RailsPwnage::Config.path_to(app_name), 'tmp'
+      FileUtils.cp_r app_path, 'tmp'
       
       # remove the garbage in the cold copy
-      cleanup_app_caches File.join('tmp', app_name), true
+      cleanup_app_caches cold_copy, instance_name, true
       
       # pack and protect the cold copy
       Dir.chdir 'tmp' do
-        system "tar -czf ../#{dump_file} #{app_name}"
+        system "tar -czf ../#{dump_file} #{File.basename(app_path)}"
       end
       File.chmod(400, dump_file)
       File.chown(pwnerer_uid, pwnerer_gid, dump_file)
@@ -72,22 +57,31 @@ class RailsPwnage::App::Svn
   end
   
   # loads the latest file dump from the backup area
-  def load_files(app_name)
-    dump_file = Dir.glob(RailsPwnage::Config.path_to(:backup, app_name) + File::SEPARATOR + "files/#{app_name}_*").max
-    Dir.chdir(RailsPwnage::Config.path_to(:apps)) do
-      # find the latest dump and load it in            
+  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]
+    
+    dump_file = Dir.glob(File.join(backup_path, "files/#{app_name}.#{instance_name}_*")).max
+    restore_path = Pathname.new(File.join(app_path, '..')).cleanpath.to_s
+    Dir.chdir restore_path do
+      # find the latest dump and load it in
       system "tar -xzf #{dump_file}"
-    end    
+    end
   end
-  
+
   # remove the application files
-  def drop_files(app_name)    
-    FileUtils.rm_r RailsPwnage::Config.path_to(app_name) if File.exists? RailsPwnage::Config.path_to(app_name)
+  def drop_files(app_name, instance_name)
+    app_config = RailsPwnage::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]
+
+    app_path = app_config[:app_path]
+    FileUtils.rm_r app_path if File.exists? app_path
   end
   
   # remove any files not in SVN in the application dir
-  def cleanup_app_dir(app_name, target_dir, app_name_is_dir = false)
-    Dir.chdir(app_name_is_dir ? app_name : RailsPwnage::Config.path_to(app_name)) do
+  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
       # get a listing of what happened in that directory
       xml_status = `svn status --xml #{target_dir}`
       xsdoc = REXML::Document.new xml_status
@@ -102,70 +96,57 @@ class RailsPwnage::App::Svn
   end
   
   # clean up the application directory by removing caches 
-  def cleanup_app_caches(app_name, app_name_is_dir = false)
+  def cleanup_app_caches(app_name, instance_name, app_name_is_dir = false)
     # TODO: learn how Rails caches work and kill those too
     ['app', 'lib', 'public/images',
     'public/javascripts', 'public/stylesheets', 'script',
     'test', 'tmp', 'vendor'
-    ].each { |dir| cleanup_app_dir app_name, dir, app_name_is_dir }
+    ].each { |dir| cleanup_app_dir app_name, instance_name, dir, app_name_is_dir }
   end
   
-  def manage(app_name, action)
+  def manage(app_name, instance_name, action)
     case action
     when :checkpoint
-      dump_files app_name
+      dump_files app_name, instance_name
     when :rollback
-      drop_files app_name
-      load_files app_name
+      drop_files app_name, instance_name
+      load_files app_name, instance_name
     when :console
-      Dir.chdir(RailsPwnage::Config.path_to(app_name)) do
+      Dir.chdir(RailsPwnage::Config[app_name, instance_name][:app_path]) do
         Kernel.system 'ruby script/console production'
       end
     when :db_console
-      Dir.chdir(RailsPwnage::Config.path_to(app_name)) do
+      Dir.chdir(RailsPwnage::Config[app_name, instance_name][:app_path]) do
         Kernel.system 'ruby script/dbconsole --include-password production'
       end      
     end
   end
-  
-  def setup(svn_path)
-    app_name = svn_checkout(svn_path)
-
-    # TODO: fetch configuration, feed to system 
-
-    scaffold_backup(app_name)
-
-    return app_name
-  end
-  
-  def update(app_name)
-    scaffold_backup(app_name)
     
-    # TODO: maybe backup old version before issuing the svn update?
-    
-    cleanup_app_caches(app_name)
-    svn_update(app_name)
-  end
-  
-  def remove(app_name)
-    drop_files(app_name)
-  end
-  
-  def self.setup(svn_path)
-    self.new.setup(svn_path)
+  def svn_update(app_name, instance_name)
+    Dir.chdir RailsPwnage::Config[app_name, instance_name][:app_path] do
+      system "svn update"
+    end
   end
 
-  def self.update(app_name)
-    self.new.update(app_name)
+  def checkout(svn_path, app_name, instance_name)
+    app_path = RailsPwnage::Config[app_name, instance_name][:app_path]
+    system "svn co #{svn_path} #{app_path}"
   end
-
-  def self.remove(app_name)
-    self.new.remove(app_name)
+      
+  def setup(app_name, instance_name)
+    scaffold_backup(app_name, instance_name)
   end
   
-  def self.manage(app_name, action)
-    self.new.manage(app_name, action)
+  def update(app_name, instance_name)
+    scaffold_backup(app_name, instance_name)
+    
+    # TODO: maybe backup old version before issuing the svn update?
+    
+    cleanup_app_caches(app_name, instance_name)
+    svn_update(app_name, instance_name)
   end
   
-  # TODO: uninstallation
+  def remove(app_name, instance_name)
+    drop_files(app_name, instance_name)
+  end  
 end

data/lib/pwnage/config/main.rb

@@ -1,44 +1,3 @@
 module RailsPwnage::Config
-  # the user which will receive the keys to the production system 
-  def self.pwnerer_user
-    'victor'
-  end
-  
-  # the number of instances for the given application
-  def self.app_instances(app_name)
-    4
-  end
-  
-  # the first internal port for the given application
-  def self.app_port0(app_name)
-    8000
-  end
-  
-  # the name of the database for the given application
-  def self.app_dbname(app_name)
-    # NOTE: convention, this doesn't have to change
-    app_name + '_prod' 
-  end
- 
-  # the datbase user for the given application
-  def self.app_db_user(app_name)
-    # NOTE: convention, this doesn't have to change
-    app_name
-  end
-  
-  # the password of the database user for the given application
-  def self.app_db_password(app_name)
-    'superpass'
-  end
-  
-  # a DNS name for server-based filtering (multiple apps on the same box)
-  def self.app_servername(app_name)
-    # "#{app_name}.zergling.net"
-    nil
-  end
-  
-  # the maximum request size (megabytes) to be accepted by an application
-  def self.app_max_request_mb(app_name)
-    48
-  end
+
 end

data/lib/pwnage/executor.rb

@@ -40,15 +40,18 @@ class RailsPwnage::Executor
       
     when 'install', 'micro'
       svn_path = args[1]
-      RailsPwnage::App.install svn_path
+      instance_name = args[2] || '.'
+      RailsPwnage::App.install svn_path, instance_name
       
     when 'update', 'ubermicro'
       app_name = args[1]
-      RailsPwnage::App.update app_name
+      instance_name = args[2] || '.'
+      RailsPwnage::App.update app_name, instance_name
       
     when 'uninstall', 'remove'
       app_name = args[1]
-      RailsPwnage::App.remove app_name
+      instance_name = args[2] || '.'
+      RailsPwnage::App.remove app_name, instance_name
       
     when 'go'
       case args[1]
@@ -61,19 +64,27 @@ class RailsPwnage::Executor
       end
       
     when 'backup', 'checkpoint', 'save'
-      RailsPwnage::App.manage args[1], :checkpoint
+      app_name = args[1]
+      instance_name = args[2] || '.'
+      RailsPwnage::App.manage app_name, instance_name, :checkpoint
     when 'restore', 'reload', 'recover', 'rollback'
-      RailsPwnage::App.manage args[1], :rollback
+      app_name = args[1]
+      instance_name = args[2] || '.'
+      RailsPwnage::App.manage app_name, instance_name, :rollback
     when 'console'
-      RailsPwnage::App.manage args[1], :console
-    when 'db_console'
-      RailsPwnage::App.manage args[1], :db_console
+      app_name = args[1]
+      instance_name = args[2] || '.'
+      RailsPwnage::App.manage app_name, instance_name, :console
+    when 'dbconsole', 'db_console'
+      app_name = args[1]
+      instance_name = args[2] || '.'
+      RailsPwnage::App.manage app_name, instance_name, :db_console
      
-    when 'config_show'
+    when 'showconfig', 'configshow', 'show_config', 'config_show'
       if args.length < 2
         # dump all databases
         RailsPwnage::Config.databases.each do |db|
-          print "Database: #{db}"          
+          print "Database: #{db}\n"          
           pp RailsPwnage::Config[db] 
         end
       else

data/lib/rails_pwnage.rb

@@ -1,9 +1,16 @@
 module RailsPwnage  
 end
 
+module RailsPwnage::App  
+end
+
+module RailsPwnage::Config  
+end
+
 module RailsPwnage::Scaffolds
 end
 
+
 require 'pwnage/base.rb'
 require 'pwnage/base/atomics.rb'
 require 'pwnage/base/dirs.rb'
@@ -12,6 +19,7 @@ require 'pwnage/base/hostname.rb'
 require 'pwnage/base/packages.rb'
 require 'pwnage/base/startup.rb'
 
+require 'pwnage/config/app.rb'
 require 'pwnage/config/main.rb'
 require 'pwnage/config/paths.rb'
 require 'pwnage/config/ports.rb'
@@ -29,8 +37,9 @@ require 'pwnage/scaffolds/packages.rb'
 require 'pwnage/scaffolds/rubygems.rb'
 
 require 'pwnage/app/main.rb'
-require 'pwnage/app/svn.rb'
-require 'pwnage/app/gems.rb'
-require 'pwnage/app/database.rb'
+require 'pwnage/app/config.rb'
 require 'pwnage/app/cluster_config.rb'
+require 'pwnage/app/database.rb'
+require 'pwnage/app/gems.rb'
 require 'pwnage/app/nginx_config.rb'
+require 'pwnage/app/svn.rb'

data/rails_pwnerer.gemspec

@@ -1,18 +1,18 @@
 
-# Gem::Specification for Rails_pwnerer-0.5.0
+# Gem::Specification for Rails_pwnerer-0.5.1
 # Originally generated by Echoe
 
 --- !ruby/object:Gem::Specification 
 name: rails_pwnerer
 version: !ruby/object:Gem::Version 
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors: 
 - Victor Costan
 autorequire: 
 bindir: bin
 
-date: 2008-08-15 00:00:00 -04:00
+date: 2008-08-16 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rails_pwnerer
 version: !ruby/object:Gem::Version 
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors: 
 - Victor Costan
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-15 00:00:00 -04:00
+date: 2008-08-16 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency