axtro-rubber 1.2.3 → 1.5.7

data/generators/vulcanize/templates/postgresql/config/rubber/rubber-postgresql.yml

@@ -0,0 +1,45 @@
+
+# REQUIRED: The credentials for creating/accessong your app's database
+#
+db_user: "#{app_name[0,16]}"
+db_pass:
+db_name: "#{app_name}_#{RUBBER_ENV}"
+
+db_slave_user: "#{('slave_' + db_user)[0,16]}"
+db_replicator_user: "#{('replicator_' + db_user)[0,16]}"
+
+# REQUIRED: The command to use to do a full backup of your database using
+#           "rake rubber:backup_db"
+db_backup_cmd: "nice sudo -u postgres pg_dumpall -U postgres | gzip -c > %backup_file%"
+
+# REQUIRED: The command to use to restore the database using
+#           "rake rubber:restore_db_s3"
+#           This command will receive the data generated by db_backup_cmd via
+#           its standard input
+db_restore_cmd: "zcat - | psql -Uroot -h %host% %name%"
+
+postgresql_ver: 8.4
+postgresql_conf_dir: "/etc/postgresql/#{postgresql_ver}/main"
+postgresql_data_dir: /mnt/postgresql/data
+postgresql_archive_dir: /mnt/postgresql/archive
+postgresql_pid_file: "/var/run/postgresql/#{postgresql_ver}-main.pid"
+postgresql_ctl: "/usr/bin/env service postgresql-#{postgresql_ver}"
+
+# Capistrano needs db:primary role for migrate to work,
+# so we might as well just make consistent across the board
+role_dependencies:
+  postgresql_master: [db:primary=true]
+  postgresql_slave: [db]
+  db:primary=true: [postgresql_master]
+  db: [postgresql_slave]
+
+packages: [postgresql-client, libpq-dev]
+gems: [pg]
+
+roles:
+  postgresql_master:
+    db_server_id: 1
+  postgresql_slave:
+    db_server_id: 2
+  db:
+    packages: [postgresql]

data/generators/vulcanize/templates/postgresql/templates.yml

@@ -0,0 +1 @@
+description: The PostgreSQL database system

data/generators/vulcanize/templates/redis/config/rubber/deploy-redis.rb

@@ -1,4 +1,3 @@
-
 namespace :rubber do
 
   namespace :redis do
@@ -8,27 +7,29 @@ namespace :rubber do
     after "rubber:install_packages", "rubber:redis:custom_install"
 
     task :custom_install, :roles => :redis do
-      custom_package('http://ftp.us.debian.org/debian/pool/main/r/redis/', 'redis-server', '1.2.0-1', '! -x /usr/bin/redis-server')
+      custom_package('http://ftp.us.debian.org/debian/pool/main/r/redis/', 'redis-server', '1.2.6-1', '! -x /usr/bin/redis-server')
+      # force redis config regen so db dir gets recreated when creating staging from a bundle
+      rsudo "rm -f /etc/redis/redis.conf"
     end
 
     desc "Stops the redis server"
-    task :stop, :roles => :redis, :on_error => :continue do
-      run "/etc/init.d/redis-server stop"
+    task :stop, :roles => :redis do
+      rsudo "/etc/init.d/redis-server stop; exit 0"
     end
 
     desc "Starts the redis server"
     task :start, :roles => :redis do
-      run "/etc/init.d/redis-server start"
+      rsudo "/etc/init.d/redis-server start"
     end
 
     desc "Restarts the redis server"
     task :restart, :roles => :redis do
-      run "/etc/init.d/redis-server restart"
+      rsudo "/etc/init.d/redis-server restart"
     end
 
     desc "Reloads the redis server"
     task :reload, :roles => :redis do
-      run "/etc/init.d/redis-server restart"
+      rsudo "/etc/init.d/redis-server restart"
     end
 
   end

data/generators/vulcanize/templates/resque/config/initializers/resque.rb

@@ -0,0 +1,15 @@
+require 'yaml'
+require 'resque'
+
+rails_root = ENV['RAILS_ROOT'] || File.dirname(__FILE__) + '/../..'
+rails_env = ENV['RAILS_ENV'] || 'development'
+
+redis_host = 'localhost:6379'
+
+resque_yml = rails_root + '/config/resque.yml'
+if File.exist? resque_yml
+  resque_config = YAML.load_file(resque_yml)
+  redis_host = resque_config[rails_env]
+end
+
+Resque.redis = redis_host

data/generators/vulcanize/templates/resque/config/rubber/common/resque.yml

@@ -0,0 +1,5 @@
+<%
+  @path = "#{RUBBER_ROOT}/config/resque.yml"
+%>
+
+<%= RUBBER_ENV %>: <%= rubber_instances.for_role('redis').first.full_name rescue 'localhost' %>:6379

data/generators/vulcanize/templates/resque/config/rubber/deploy-resque.rb

@@ -4,36 +4,55 @@ namespace :rubber do
   namespace :resque do
   
     rubber.allow_optional_tasks(self)
-  
-    after "rubber:install_packages", "rubber:resque:custom_install"
-    
-    task :custom_install, :roles => :resque do
-      rubber.sudo_script 'install_resque', <<-ENDSCRIPT
-        if [ -d resque ]; then
-          rm -r resque
-        fi
-
-        git clone git://github.com/defunkt/resque.git
-
-        if [ -d #{rubber_env.resque_web_dir} ]; then
-          rm -r #{rubber_env.resque_web_dir}
-        fi
-
-        mkdir -p #{rubber_env.resque_web_dir}
-        mkdir #{rubber_env.resque_web_dir}/tmp
-        mv resque/config.ru #{rubber_env.resque_web_dir}
-        mv resque/lib/resque/server/* #{rubber_env.resque_web_dir}/
-
-        rm -f /var/www/resque
-        ln -s #{rubber_env.resque_web_dir}/public /var/www/resque
-      ENDSCRIPT
+
+    namespace :worker do
+
+      rubber.allow_optional_tasks(self)
+
+      before "deploy:stop", "rubber:resque:worker:stop"
+      after "deploy:start", "rubber:resque:worker:start"
+      after "deploy:restart", "rubber:resque:worker:restart"
+
+      desc "Starts resque workers"
+      task :start, :roles => :resque_worker do
+        rsudo "cd #{current_path} && RUBBER_ENV=#{rails_env} ./script/resque_worker_management.rb start", :as => rubber_env.app_user
+      end
+
+      desc "Stops resque workers"
+      task :stop, :roles => :resque_worker do
+        rsudo "cd #{current_path} && RUBBER_ENV=#{rails_env} ./script/resque_worker_management.rb stop", :as => rubber_env.app_user
+      end
+
+      desc "Restarts resque workers"
+      task :restart, :roles => :resque_worker do
+        rsudo "cd #{current_path} && RUBBER_ENV=#{rails_env} ./script/resque_worker_management.rb restart", :as => rubber_env.app_user
+      end
     end
 
-    after "rubber:setup_app_permissions", "rubber:resque:setup_resque_permissions"
+    namespace :web do
+      rubber.allow_optional_tasks(self)
+
+      before "deploy:stop", "rubber:resque:web:stop"
+      after "deploy:start", "rubber:resque:web:start"
+      after "deploy:restart", "rubber:resque:web:restart"
+
+      desc "Starts resque web tools"
+      task :start, :roles => :resque_web do
+        rsudo "RAILS_ENV=#{RUBBER_ENV} resque-web --pid-file /var/run/resque_web.pid --port #{rubber_env.resque_web_port} --no-launch #{current_path}/config/initializers/resque.rb"
+      end
+
+      desc "Stops resque web tools"
+      task :stop, :roles => :resque_web do
+        rsudo "RAILS_ENV=#{RUBBER_ENV} resque-web --pid-file /var/run/resque_web.pid --kill"
+      end
+
+      desc "Restarts resque web tools"
+      task :restart, :roles => :resque_web do
+        rubber.resque.web.stop
+        rubber.resque.web.start
+      end
 
-    task :setup_resque_permissions, :roles => :resque do
-      run "chown -R #{rubber_env.app_user}:#{rubber_env.app_user} #{rubber_env.resque_web_dir}/config.ru"
     end
-    
+
   end
 end

data/generators/vulcanize/templates/resque/config/rubber/role/resque_web/monit-resque_web.conf

@@ -0,0 +1,14 @@
+<%
+  @path = '/etc/monit/monit.d/monit-resque_web.conf'
+
+  PIDFILE = "/var/run/resque_web.pid"
+  start_program = "HOME=/root resque-web --pid-file #{PIDFILE} --port #{rubber_env.resque_web_port} --no-launch #{RUBBER_ROOT}/config/initializers/resque.rb"
+  stop_program  = "HOME=/root resque-web --pid-file #{PIDFILE} --kill"
+%>
+
+check process resque_web with pidfile <%= PIDFILE %>
+  group resque_web
+  start program = "/bin/bash -l -c '<%= start_program %>'"
+  stop program = "/bin/bash -l -c '<%= stop_program %>'"
+
+  if totalmem > 350.0 MB for 15 cycles then restart

data/generators/vulcanize/templates/resque/config/rubber/role/resque_worker/monit-resque_worker.conf

@@ -0,0 +1,19 @@
+<%
+  @path = '/etc/monit/monit.d/monit-resque_worker.conf'
+%>
+
+<% rubber_env.resque_workers.each_with_index do |worker, i| %>
+  <%
+    PIDFILE = "#{RUBBER_ROOT}/tmp/pids/resque_worker_#{i}.pid"
+
+    start_program = "cd #{RUBBER_ROOT} && ./script/resque_worker_management.rb start #{i}"
+    stop_program  = "cd #{RUBBER_ROOT} && ./script/resque_worker_management.rb stop #{i}"
+  %>
+
+  check process resque_worker_<%= i %> with pidfile <%= PIDFILE %>
+    group resque_worker
+    start program = "/usr/bin/sudo -H -u <%= rubber_env.app_user %> bash -l -c '<%= start_program %>'"
+    stop program = "/usr/bin/sudo -H -u <%= rubber_env.app_user %> bash -l -c '<%= stop_program %>'"
+
+    if totalmem > 350.0 MB for 15 cycles then restart
+<% end %>

data/generators/vulcanize/templates/resque/config/rubber/rubber-resque.yml

@@ -1,10 +1,18 @@
-resque_web_dir: /opt/resque
+resque_web_port: 5678
 
-resque_worker_default_count: 5
+# list of workers with the queues to be run on each - on each worker instance,
+# a worker is run for each item in this list to handle the queues specified
+#
+resque_workers:
+  -
+    queues: *
+    poll_interval: 1
+  -
+    queues: *
+    poll_interval: 1
+
+gems: [yajl-ruby resque]
 
 role_dependencies:
-  css_validator: [redis]
+  web_tools: [resque_web]
 
-roles:
-  resque:
-    gems: [redis redis-namespace yajl-ruby sinatra resque]

data/generators/vulcanize/templates/resque/script/resque_worker_management.rb

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+
+env = ENV["RUBBER_ENV"] ||= "development"
+root = File.join(File.dirname(__FILE__), '..')
+rails_env_file = File.join(root, 'config', 'environment.rb')
+
+if File.exists? rails_env_file
+  require(rails_env_file)
+else
+  require "rubber"
+  Rubber::initialize(root, env)
+  require 'resque'
+  require "#{root}/config/initializers/resque.rb"
+end
+
+def start_all(workers)
+  puts "Starting all workers"
+  workers.each_with_index do |worker, i|
+    start(worker, i)
+  end
+end
+
+def start(worker, index)
+  puts "Starting worker #{index}/#{worker.queues}"
+
+  log_file = log_file(index)
+  pid_file = pid_file(index)
+
+  queues = worker.queues.to_s.split(',')
+
+  daemonize(log_file, pid_file) do
+    resque_worker = Resque::Worker.new(*queues)
+    resque_worker.verbose = ENV['LOGGING'] || ENV['VERBOSE']
+    resque_worker.very_verbose = ENV['VVERBOSE']
+
+    puts "*** Starting worker #{resque_worker}"
+    resque_worker.work(worker.poll_interval.to_i || 5) # interval, will block
+  end
+end
+
+def stop_all(workers)
+  puts "Stopping all workers"
+  workers.size.times do |i|
+    stop(i)
+  end
+end
+
+def stop(index)
+  puts "Stopping worker #{index}"
+  
+  pid_file = pid_file(index)
+  pid = File.read(pid_file).to_i rescue nil
+  if pid
+    puts "Killing worker #{index}: pid #{pid}"
+    begin
+      Process.kill("QUIT", pid)
+    rescue Exception => e
+      puts e
+    end
+    File.delete(pid_file) if File.exist?(pid_file)
+  else
+    puts "No pid file for worker #{index}: #{pid_file}"
+  end
+end
+
+def daemonize(log_file, pid_file)
+  return if fork
+  Process::setsid
+  exit!(0) if fork
+  Dir::chdir("/")
+  File.umask 0000
+  FileUtils.touch log_file
+  STDIN.reopen    log_file
+  STDOUT.reopen   log_file, "a"
+  STDERR.reopen   log_file, "a"
+
+  File.open(pid_file, 'w') {|f| f.write("#{Process.pid}") }
+  
+  yield if block_given?
+  exit(0)
+end
+
+def pid_file(index)
+  File.expand_path "#{Rubber.root}/tmp/pids/resque_worker_#{index}.pid"
+end
+
+def log_file(index)
+  File.expand_path "#{Rubber.root}/log/resque_worker_#{index}.log"
+end
+
+action = ARGV[0]
+worker_index = ARGV[1] ? ARGV[1].to_i : nil
+if action.nil? || ! %w[start stop restart].include?(action)
+  puts "Usage: script/resque_worker_management.rb [start|stop|restart]"
+end
+
+workers = Rubber.config.resque_workers
+
+case action
+  when 'start'
+    worker_index ? start(workers[worker_index], worker_index) : start_all(workers)
+  when 'stop'
+    worker_index ? stop(worker_index) : stop_all(workers)
+  when 'restart'
+    if worker_index
+      stop(worker_index)
+      start(workers[worker_index], worker_index)
+    else
+      stop_all(workers)
+      start_all(workers)
+    end
+end

data/generators/vulcanize/templates/resque/templates.rb

@@ -0,0 +1 @@
+gem "resque" if Rubber::Util::is_bundler?

data/generators/vulcanize/templates/sphinx/config/rubber/deploy-sphinx.rb

@@ -18,7 +18,7 @@ namespace :rubber do
     task :custom_install, :roles => :sphinx do
       # install sphinx from source
       ver = "0.9.8.1"
-      rubber.run_script 'install_sphinx', <<-ENDSCRIPT
+      rubber.sudo_script 'install_sphinx', <<-ENDSCRIPT
         # check if already installed
         if [ -x /usr/local/bin/searchd ]
           then echo 'Found sphinx searchd on system'
@@ -60,25 +60,25 @@ namespace :rubber do
     desc "Do sphinx setup tasks"
     task :setup, :roles => :sphinx do
       # Setup links to sphinx config/index as they need to persist between deploys
-      run "mkdir -p #{sphinx_root} #{sphinx_root}/config #{sphinx_root}/db"
-      run "chown -R #{runner}:#{runner} #{sphinx_root}"
+      rsudo "mkdir -p #{sphinx_root} #{sphinx_root}/config #{sphinx_root}/db"
+      rsudo "chown -R #{runner}:#{runner} #{sphinx_root}"
     end
 
     desc "Setup paths for sphinx runtime"
     task :config_dir, :roles => :sphinx do
-      run "rm -rf #{current_path}/sphinx && ln -sf #{sphinx_root} #{current_path}/sphinx"
+      rsudo "rm -rf #{current_path}/sphinx"
+      rsudo "ln -sf #{sphinx_root} #{current_path}/sphinx"
     end
 
     # runs the given ultrasphinx rake tasks
     def run_sphinx task
-      cmd = "cd #{current_path} && sudo -u #{runner} RAILS_ENV=#{RUBBER_ENV} rake #{task}"
-      run cmd
+      rsudo "cd #{current_path} && RAILS_ENV=#{RUBBER_ENV} rake #{task}", :as => runner
     end
 
 
     desc "Stops sphinx searchd"
-    task :stop, :roles => :sphinx, :on_error => :continue do
-      run_sphinx 'ts:stop'
+    task :stop, :roles => :sphinx do
+      run_sphinx 'ts:stop; exit 0'
     end
 
     desc "Starts sphinx searchd"

data/generators/vulcanize/templates/sphinx/config/rubber/role/sphinx/monit-sphinx.conf

@@ -1,10 +1,13 @@
 <%
   @path = '/etc/monit/monit.d/monit-sphinx.conf'
+
+  PIDFILE = "#{RUBBER_ROOT}/log/searchd.#{RUBBER_ENV}.pid"
+  start_program = "cd #{RUBBER_ROOT} && rake ts:start"
+  stop_program = "cd #{RUBBER_ROOT} && rake ts:stop"
 %>
 
-check process sphinx with pidfile <%= RUBBER_ROOT %>/log/searchd.<%= RUBBER_ENV %>.pid
+check process sphinx with pidfile <%= PIDFILE %>
   group sphinx-<%= RUBBER_ENV %>
-  start program = "/usr/bin/sudo -u rails sh -c 'cd <%= RUBBER_ROOT %> && PATH=<%= rubber_env.ruby_prefix %>/bin:/usr/local/bin:$PATH RAILS_ENV=<%= RUBBER_ENV %> rake ts:start'"
-  stop program  = "/usr/bin/sudo -u rails sh -c 'cd <%= RUBBER_ROOT %> && PATH=<%= rubber_env.ruby_prefix %>/bin:/usr/local/bin:$PATH RAILS_ENV=<%= RUBBER_ENV %> rake ts:stop'"
+  start program = "/usr/bin/sudo -H -u <%= rubber_env.app_user %> bash -l -c '<%= start_program %>'"
+  stop program = "/usr/bin/sudo -H -u <%= rubber_env.app_user %> bash -l -c '<%= stop_program %>'"
   if failed host <%= rubber_env.host %> port 3312 with timeout 5 seconds for 5 cycles then restart
-

data/generators/vulcanize/vulcanize_generator.rb

@@ -1,67 +1,184 @@
-require 'fileutils'
 require 'find'
+require 'yaml'
 
-class VulcanizeGenerator < Rails::Generator::NamedBase
-  
-  TEMPLATE_ROOT = File.dirname(__FILE__) + "/templates"
-  TEMPLATE_FILE = "templates.yml"
-    
-  def manifest
-    record do |m|
-      templates = [file_name] + actions
-      templates.each do |t|
-        apply_template(m, t)
+# Load and initialize rubber if it hasn't been already.
+# This happens using the generator with Rails 2 and Rubber is not set up as a plugin.
+unless defined?(Rubber)
+  env = ENV['RUBBER_ENV'] ||= 'development'
+  root = '.'
+
+  require 'rubber'
+  Rubber::initialize(root, env)
+end
+
+if Rubber::Util::is_rails2?
+  require 'fileutils'
+  require 'commands/generate'
+
+  class VulcanizeGenerator < Rails::Generator::NamedBase
+    include Rails::Generator::Commands
+
+    TEMPLATE_ROOT = File.dirname(__FILE__) + "/templates" unless defined?(TEMPLATE_ROOT)
+    TEMPLATE_FILE = "templates.yml" unless defined?(TEMPLATE_FILE)
+
+    def manifest
+      record do |m|
+        templates = [file_name] + actions
+        templates.each do |t|
+          apply_template(m, t)
+        end
       end
     end
+
+    def apply_template(m, name)
+      sp = source_path("#{name}/")
+      unless File.directory?(sp)
+        raise Rails::Generator::UsageError.new("Invalid template #{name}, use one of #{valid_templates.join(', ')}")
+      end
+
+      @template_dependencies ||= []
+
+      templ_conf = load_template_config(sp)
+      deps = templ_conf['dependent_templates'] || []
+      @template_dependencies.concat(deps)
+      deps.each do |dep|
+        apply_template(m, dep)
+      end
+
+      extra_generator_steps_file = File.join(TEMPLATE_ROOT, name, 'templates.rb')
+
+      Find.find(sp) do |f|
+        Find.prune if File.basename(f) =~ /^(CVS|\.svn)$/
+        Find.prune if f == "#{sp}#{TEMPLATE_FILE}"
+        Find.prune if f == extra_generator_steps_file # don't copy over templates.rb
+
+        rel = f.gsub(/#{source_root}\//, '')
+        dest_rel = rel.gsub(/^#{name}\//, '')
+
+        # Only include optional files when their conditions eval to true
+        template_conf = YAML.load(File.read(TEMPLATE_FILE)) rescue {}
+        optional = template_conf['optional'][dest_rel] rescue nil
+        Find.prune if optional && ! eval(optional)
+
+        m.directory(dest_rel) if File.directory?(f)
+        if File.file?(f)
+          # force scripts to be executable
+          opts = (File.read(f) =~ /^#!/) ? {:chmod => 0755} : {}
+          m.file(rel, dest_rel, opts)
+        end
+      end
+
+      if File.exist? extra_generator_steps_file
+        eval File.read(extra_generator_steps_file), binding, extra_generator_steps_file
+      end
+    end
+
+    protected
+      def valid_templates
+        valid = Dir.entries(TEMPLATE_ROOT).delete_if {|e| e =~ /(^\.)|svn|CVS/ }
+      end
+
+      def load_template_config(template_dir)
+        templ_file = "#{template_dir}/templates.yml"
+        templ_conf = YAML.load(File.read(templ_file)) rescue {}
+        return templ_conf
+      end
+
+      def banner
+        usage = "Usage: #{$0} vulcanize template_name ...\n"
+        usage << "where template_name is one of:\n\n"
+        valid_templates.each do |t|
+          templ_conf = load_template_config("#{TEMPLATE_ROOT}/#{t}")
+          desc = templ_conf['description']
+          usage << "    #{t}: #{desc}\n"
+        end
+        return usage
+      end
   end
 
-  def apply_template(m, name)
-    sp = source_path("#{name}/")
-    unless File.directory?(sp)
-      raise Rails::Generator::UsageError.new("Invalid template #{name}, use one of #{valid_templates.join(', ')}")
+else
+  require 'rails/generators'
+
+  class VulcanizeGenerator < Rails::Generators::NamedBase
+
+    def self.source_root
+      File.join(File.dirname(__FILE__), 'templates')
     end
-    
-    templ_conf = load_template_config(sp)
-    deps = templ_conf['dependent_templates'] || []
-    deps.each do |dep|
-      apply_template(m, dep)
+
+    def copy_template_files
+      @template_dependencies = find_dependencies(file_name)
+      ([file_name] + @template_dependencies).each do |template|
+        apply_template(template)
+      end
     end
-    
-    Find.find(sp) do |f|
-      Find.prune if File.basename(f) =~ /^(CVS|\.svn)$/
-      Find.prune if f == "#{sp}#{TEMPLATE_FILE}"
-      
-      rel = f.gsub(/#{source_root}\//, '')
-      dest_rel = rel.gsub(/^#{name}\//, '')
-      m.directory(dest_rel) if File.directory?(f)
-      if File.file?(f)
-        # force scripts to be executable
-        opts = (File.read(f) =~ /^#!/) ? {:chmod => 0755} : {}
-        m.file(rel, dest_rel, opts)
+
+    protected
+
+    # helper to test for rails for optional templates
+    def rails?
+      Rubber::Util::is_rails?
+    end
+
+    def find_dependencies(name)
+      template_dir = File.join(self.class.source_root, name, '')
+      unless File.directory?(template_dir)
+        raise Rails::Generators::Error.new("Invalid template #{name}, use one of #{valid_templates.join(', ')}")
       end
 
+      template_conf = load_template_config(template_dir)
+      template_dependencies = template_conf['dependent_templates'] || []
+
+      template_dependencies.clone.each do |dep|
+        template_dependencies.concat(find_dependencies(dep))
+      end
+
+      return template_dependencies.uniq
+    end
+
+    def apply_template(name)
+      template_dir = File.join(self.class.source_root, name, '')
+      unless File.directory?(template_dir)
+        raise Rails::Generators::Error.new("Invalid template #{name}, use one of #{valid_templates.join(', ')}")
+      end
+
+      template_conf = load_template_config(template_dir)
+
+      extra_generator_steps_file = File.join(template_dir, 'templates.rb')
+
+      Find.find(template_dir) do |f|
+        Find.prune if f == File.join(template_dir, 'templates.yml')  # don't copy over templates.yml
+        Find.prune if f == extra_generator_steps_file # don't copy over templates.rb
+
+        template_rel = f.gsub(/#{template_dir}/, '')
+        source_rel = f.gsub(/#{self.class.source_root}\//, '')
+        dest_rel   = source_rel.gsub(/^#{name}\//, '')
+
+        # Only include optional files when their conditions eval to true
+        optional = template_conf['optional'][template_rel] rescue nil
+        Find.prune if optional && ! eval(optional)
+
+        if File.directory?(f)
+          empty_directory(dest_rel)
+        else
+          copy_file(source_rel, dest_rel)
+          src_mode = File.stat(f).mode
+          dest_mode = File.stat(File.join(destination_root, dest_rel)).mode
+          chmod(dest_rel, src_mode) if src_mode != dest_mode
+        end
+      end
+
+      if File.exist? extra_generator_steps_file
+        eval File.read(extra_generator_steps_file), binding, extra_generator_steps_file
+      end
     end
-  end
 
-  protected
     def valid_templates
-      valid = Dir.entries(TEMPLATE_ROOT).delete_if {|e| e =~ /(^\.)|svn|CVS/ }
+      valid = Dir.entries(self.class.source_root).delete_if {|e| e =~  /(^\.)|svn|CVS/ }
     end
-    
+
     def load_template_config(template_dir)
-      templ_file = "#{template_dir}/templates.yml"
-      templ_conf = YAML.load(File.read(templ_file)) rescue {}
-      return templ_conf
+      YAML.load(File.read(File.join(template_dir, 'templates.yml'))) rescue {}
     end
+  end
 
-    def banner
-      usage = "Usage: #{$0} vulcanize template_name ...\n"
-      usage << "where template_name is one of:\n\n"
-      valid_templates.each do |t|
-        templ_conf = load_template_config("#{TEMPLATE_ROOT}/#{t}")
-        desc = templ_conf['description']
-        usage << "    #{t}: #{desc}\n" 
-      end
-      return usage
-    end
 end