tdd_deploy 0.1.7 → 0.1.8

data/Capfile

@@ -6,7 +6,9 @@ role :hosts, "arch"
 #role :hosts, "ubuntu"
 # role :hosts, 'li371-193.members.linode.com'
 
-desc "Test to See if we have root access on hosts"
-task :check_host_access do
-     
+namespace :deploy do
+  desc "Moc deploy:update"
+  task :update do
+    system "echo 'mock deloy:update'"
+  end
 end

data/lib/tdd_deploy/base.rb

@@ -36,15 +36,5 @@ module TddDeploy
       self.env_hash || read_env || reset_env
       set_env(args.pop) if args.last.is_a? Hash
     end
-    
-    # gather up all descendents so we know what tests to run
-    class <<self
-      attr_accessor :children
-      
-      def inherited(child)
-        self.children ||= []
-        self.children << child
-      end
-    end
   end
 end

data/lib/tdd_deploy/copy_methods.rb

@@ -13,7 +13,7 @@ module TddDeploy
       result
     end
 
-    def copy_file_to_remote_on_hosts_as userid, host_list, src, dst
+    def copy_file_to_remote_hosts_as userid, host_list, src, dst
       result = true
       host_list = [host_list] if host_list.is_a? String
       host_list.uniq.each do |host|
@@ -22,8 +22,8 @@ module TddDeploy
       result
     end
 
-    def copy_dir_to_remote_on_hosts_as(userid, host_list, src_dir, dest_dir)
-      raise ::ArgumentError.new("copy_dir_to_remote_on_hosts_as: src_dir does not exist: #{src_dir}") \
+    def copy_dir_to_remote_hosts_as(userid, host_list, src_dir, dest_dir)
+      raise ::ArgumentError.new("copy_dir_to_remote_hosts_as: src_dir does not exist: #{src_dir}") \
           unless File.directory? src_dir
       host_list = [host_list] if host_list.is_a? String
       result = true
@@ -33,7 +33,7 @@ module TddDeploy
       Dir.open(src_dir).each do |fname|
         next if fname[0] == '.'
         path = File.join(src_dir, fname)
-        result &= copy_file_to_remote_on_hosts_as userid, host_list, path, File.join(dest_dir, fname)
+        result &= copy_file_to_remote_hosts_as userid, host_list, path, File.join(dest_dir, fname)
       end
       result
     end
@@ -47,7 +47,7 @@ module TddDeploy
       result
     end
 
-    def append_file_to_remote_on_hosts_as userid, host_list, src, dst
+    def append_file_to_remote_hosts_as userid, host_list, src, dst
       result = true
       host_list = [host_list] if host_list.is_a? String
       host_list.uniq.each do |host|
@@ -56,8 +56,8 @@ module TddDeploy
       result
     end
 
-    def append_dir_to_remote_on_hosts_as(userid, host_list, src_dir, dest_dir)
-      raise ::ArgumentError.new("append_dir_to_remote_on_hosts_as: src_dir does not exist: #{src_dir}") \
+    def append_dir_to_remote_hosts_as(userid, host_list, src_dir, dest_dir)
+      raise ::ArgumentError.new("append_dir_to_remote_hosts_as: src_dir does not exist: #{src_dir}") \
           unless File.directory? src_dir
       host_list = [host_list] if host_list.is_a? String
       result = true
@@ -67,7 +67,7 @@ module TddDeploy
       Dir.open(src_dir).each do |fname|
         next if fname[0] == '.'
         path = File.join(src_dir, fname)
-        result &= append_file_to_remote_on_hosts_as userid, host_list, path, File.join(dest_dir, fname)
+        result &= append_file_to_remote_hosts_as userid, host_list, path, File.join(dest_dir, fname)
       end
       result
     end

data/lib/tdd_deploy/deploy_test_methods.rb

@@ -14,12 +14,13 @@ module TddDeploy
   #
   # the most frequently used are 'deploy_test_process_running_on_hosts_as' and 'deploy_test_file_exists_on_hosts_as'.
   #
-  # 'deploy_test_on_hosts_as' and 'deploy_test_in_ssh_session_as' are more primative and flexible.
+  # 'deploy_test_on_hosts_as' and 'deploy_test_on_a_host_as' are more primative and flexible.
   module DeployTestMethods
     include TddDeploy::Assertions
     include TddDeploy::RunMethods
     
     def deploy_test_process_running_on_hosts_as(userid, host_list, pid_file_path, success_msg = nil)
+      host_list = rationalize_host_list(host_list)
       success_msg ||= "Process associated with #{pid_file_path} should be running"
       ret = deploy_test_file_exists_on_hosts_as(userid, host_list, pid_file_path, success_msg + " no such pid file: #{pid_file_path}") ||
       ret &= deploy_test_on_hosts_as(userid, host_list, /.+\n\s*\d+.*?\d\d:\d\d:\d\d/, "Process for #{pid_file_path} is running") do
@@ -40,38 +41,32 @@ module TddDeploy
     # 'match_expr_or_str' can be a Regexp or a string (which will be converted to a Regexp)
     def deploy_test_on_hosts_as userid, host_list, match_expr_or_str, success_msg, &block
       ret = true
-      host_list = [host_list] if host_list.is_a? String
+      host_list = rationalize_host_list(host_list)
       host_list.uniq.each do |host|
-        ret &= deploy_test_in_ssh_session_as userid, host, match_expr_or_str, success_msg, &block
+        ret &= deploy_test_on_a_host_as userid, host, match_expr_or_str, success_msg, &block
       end
       ret
     end
 
-    # deploy_test_in_ssh_session_as runs the command(s) return by '&block' on the specified host
+    # deploy_test_on_a_host_as runs the command(s) return by '&block' on the specified host
     # as user 'userid'
     # declares an error if EITHER STDOUT does not match 'match' OR STDERR returns anything
     # 'match' can be a Regexp or a string (which will be converted to a Regexp)
-    def deploy_test_in_ssh_session_as(userid, host, match, success_msg, &block)
+    def deploy_test_on_a_host_as(userid, host, match, success_msg, &block)
       match = Regexp.new(match) if match.is_a? String
       raise ArgumentError, 'match expression cannot be empty' if match =~ ''
 
-      rsp, err_rsp, cmd = run_in_ssh_session_on_host_as(userid, host, &block)
-
-      result = err_rsp.nil?
-      
+      rsp, err_rsp, cmd = run_on_a_host_as(userid, host, &block)
       prefix = "user@host: #{userid}@#{host}: #{success_msg}"
 
-      fail host, "#{prefix}: command generated error data:\n" +
-        "  command: #{cmd}\n stdout: '#{rsp}'\n stderr: '#{err_rsp}'" if err_rsp
-
-      if rsp.nil?
-        fail host, "#{prefix}: stdout is empty for command '#{cmd}'"
-        result &= false
-      elsif !assert_match host, match, rsp, prefix
-        result &= false
+      if err_rsp
+        return fail host, "#{prefix}: command generated error data:\n" +
+          "  command: #{cmd}\n stdout: '#{rsp}'\n stderr: '#{err_rsp}'"
+      elsif rsp.nil?
+        return fail host, "#{prefix}: stdout is empty for command '#{cmd}'"
+      else
+        return assert_match host, match, rsp, prefix
       end
-
-      result
     end
   end
 end

data/lib/tdd_deploy/environ.rb

@@ -392,5 +392,20 @@ module TddDeploy
     def migration_hosts
       self.capfile.migration_host_list
     end
+    
+    # takes the name of a list (as a string or symbol), a single string, or an array of host names
+    def rationalize_host_list(host_list_or_list_name)
+      if host_list_or_list_name.is_a? String
+        return self.respond_to?(host_list_or_list_name.to_sym) ? self.send(host_list_or_list_name.to_sym) :
+          [host_list_or_list_name]
+      elsif host_list_or_list_name.is_a? Symbol
+        return self.respond_to?(host_list_or_list_name) ? self.send(host_list_or_list_name) :
+              [host_list_or_list_name.to_s]
+      elsif host_list_or_list_name.is_a? Array
+        return host_list_or_list_name.map { |host| host.to_s }
+      else
+        raise ArgumentError.new("rationalize_host_list(#{host_list_or_list_name.inspect}) is invalid")
+      end
+    end
   end
 end

data/lib/tdd_deploy/host_tests/host_connection.rb

@@ -1,10 +1,10 @@
-require 'tdd_deploy/base'
+require 'tdd_deploy/test_base'
 
 module TddDeploy
   # == TddDeploy::HostConnection
   #
   # tests that hosts are pingable and that the current user can log in as both 'host_admin' and 'root'
-  class HostConnection < TddDeploy::Base
+  class HostConnection < TddDeploy::TestBase
     # ping - pings all hosts
     def ping
       result = true

data/lib/tdd_deploy/host_tests/remote_ip_tables.rb

@@ -1,4 +1,4 @@
-require 'tdd_deploy/base'
+require 'tdd_deploy/test_base'
 
 module TddDeploy
   # == TddDeploy::RemoteIpTables
@@ -6,7 +6,7 @@ module TddDeploy
   # checks to see if iptables is working by attempting to connect to each host on a collection
   # of 'interesting' ports. the ports probed are: 20, 23, 25, 53, 5432, 2812
   #
-  class RemoteIpTables < TddDeploy::Base
+  class RemoteIpTables < TddDeploy::TestBase
     # tcp_some_blocked_ports - checks TCP ports
     def tcp_some_blocked_ports
       self.hosts.each do |host|

data/lib/tdd_deploy/host_tests/remote_monit.rb

@@ -1,10 +1,10 @@
-require 'tdd_deploy/base'
+require 'tdd_deploy/test_base'
 
 module TddDeploy
   # == TddDeploy::RemoteMonit
   #
   # verifies monit executable is present and running on all hosts
-  class RemoteMonit < TddDeploy::Base
+  class RemoteMonit < TddDeploy::TestBase
     def test_monit_installed
       deploy_test_file_exists_on_hosts_as self.host_admin, self.hosts, '/usr/bin/monit', 'monit should be installed'
     end

data/lib/tdd_deploy/host_tests/remote_nginx.rb

@@ -1,10 +1,10 @@
-require 'tdd_deploy/base'
+require 'tdd_deploy/test_base'
 
 module TddDeploy
   # == TddDeploy::RemoteNginx
   #
   # verifies Nginx executable is both present and running on web_hosts + balance_hosts
-  class RemoteNginx < TddDeploy::Base
+  class RemoteNginx < TddDeploy::TestBase
     def test_nginx_installed
       deploy_test_file_exists_on_hosts_as self.host_admin, self.web_hosts + self.balance_hosts, '/usr/sbin/nginx', "nginx should be installed"
     end

data/lib/tdd_deploy/host_tests/remote_postfix.rb

@@ -1,11 +1,11 @@
-require 'tdd_deploy/base'
+require 'tdd_deploy/test_base'
 
 module TddDeploy
   # == TddDeploy::RemotePostfix
   #
   # verifies that postfix executable is installed, running and will accept mail to local_admin_mail
   # on all hosts
-  class RemotePostfix < TddDeploy::Base
+  class RemotePostfix < TddDeploy::TestBase
     def test_postfix_installed
       deploy_test_file_exists_on_hosts_as 'root', self.hosts, '/usr/sbin/postfix', "postfix should be installed"
     end

data/lib/tdd_deploy/host_tests/remote_postgresql.rb

@@ -1,10 +1,10 @@
-require 'tdd_deploy/base'
+require 'tdd_deploy/test_base'
 
 module TddDeploy
   # == TddDeploy::RemotePostgresql
   #
   # verifies that the postgresql exectuable is both installed and running on db_hosts
-  class RemotePostgresql < TddDeploy::Base
+  class RemotePostgresql < TddDeploy::TestBase
     def test_postgresql_installed
       deploy_test_file_exists_on_hosts_as 'root', self.db_hosts, "/usr/bin/postgres", 'postgres should be installed'
     end

data/lib/tdd_deploy/installer.rb

@@ -0,0 +1,38 @@
+require 'tdd_deploy/base'
+require 'tdd_deploy/copy_methods'
+
+module TddDeploy
+  class Installer < TddDeploy::Base
+    include TddDeploy::CopyMethods
+
+    def install_config_files_on_host_list_as userid, host_list_name
+      raise ::ArgumentError.new("install_config_files_on_host_list_as(userid, host_list_name): invalid host_list_name: #{host_list_name}") \
+          unless self.respond_to? host_list_name.to_sym
+      config_dir = File.join(self.site_doc_root, '..', 'config')
+      src_dir = File.join('tdd_deploy_configs', host_list_name.to_s, 'config')
+      copy_dir_to_remote_hosts_as userid, rationalize_host_list(host_list_name), src_dir, config_dir
+    end
+
+    def empty_special_dir userid, host_list_name
+      raise ::ArgumentError.new("install_config_files_on_host_list_as(userid, host_list_name): invalid host_list_name: #{host_list_name}") \
+          unless self.respond_to? host_list_name.to_sym
+      host_list = rationalize_host_list host_list_name
+      run_on_hosts_as(userid, host_list, "rm #{self.site_special_dir}/*")
+    end
+
+    def install_special_files_on_host_list_as userid, host_list_name
+      raise ::ArgumentError.new("install_config_files_on_host_list_as(userid, host_list_name): invalid host_list_name: #{host_list_name}") \
+          unless self.respond_to? host_list_name.to_sym
+      
+      host_list = rationalize_host_list host_list_name
+      src_dir = File.join('tdd_deploy_configs', host_list_name.to_s, 'site')
+      append_dir_to_remote_hosts_as userid, host_list, src_dir, self.site_special_dir
+    end
+    
+    def run_cap_deploy
+      stdout, stderr, cmd = run_locally { 'cap deploy:update' }
+      return fail if stderr =~ /failed|rolling back/
+      return true
+    end
+  end
+end

data/lib/tdd_deploy/local_tests/smoke_test.rb

@@ -1,4 +1,4 @@
-require 'tdd_deploy/base'
+require 'tdd_deploy/test_base'
 
 module TddDeploy
   # == TddDeploy::SmokeTest
@@ -9,7 +9,7 @@ module TddDeploy
   #
   # * return_true
   # * smoke
-  class SmokeTest < TddDeploy::Base
+  class SmokeTest < TddDeploy::TestBase
     
     # returns true
     def return_true

data/lib/tdd_deploy/run_methods.rb

@@ -31,17 +31,18 @@ module TddDeploy
     
     # runs supplied command on list of hosts as specified user
     def run_on_hosts_as userid, host_list, cmd = nil, &block
+      
       host_list = [host_list] if host_list.is_a? String
       result = {}
       host_list.uniq.each do |host|
-        result[host] = run_in_ssh_session_on_host_as userid, host, cmd, &block
+        result[host] = run_on_a_host_as userid, host, cmd, &block
       end
       result
     end
 
     # Runs the command secified in &block on 'host' as user 'userid'.
     # Returns an array [stdout, stderr] returned from the command.
-    def run_in_ssh_session_on_host_as(userid, host, cmd = nil, &block)
+    def run_on_a_host_as(userid, host, cmd = nil, &block)
       login = "#{userid}@#{host}"
       match = Regexp.new(match) if match.is_a? String
       raise ArgumentError.new('match expression cannot be empty') if match =~ ''

data/lib/tdd_deploy/server-templates/test_results.html.erb

@@ -72,7 +72,13 @@ end
 	 .even { background: #ccc;}
 	 .red { color: #800;}
 	 .green { color: #080;}
-	 .warn { color: #f80;}
+	 .warn {
+	    color: #e0ffff;
+      padding: 5px;
+	    border: 1px solid black;
+	    font-weight: normal;
+	    background: #800000;
+	  }
 	</style>
 	<!-- Date: 2011-08-20 -->
 </head>
@@ -81,7 +87,7 @@ end
     <h1>TddDeploy (<%= TddDeploy::VERSION %>) Test Results: site: <%= site %> / hosts: <%= hosts %></h1>
   
     <% if (failures = total_failures) == 0 %>
-    <p id="test-summary-passed">All Tests Passed</p>
+    <p id="test-summary-passed">All <%= total_tests %> Tests Passed</p>
     <% else %>
     <p id="test-summary-failed"><%= failures %> of <%= total_tests %> Tests Failed</p>
     <% end %>
@@ -98,11 +104,15 @@ end
         <td><a href="/?run_configurator">Run Configurator</a></td>
         <td></td>
       </tr>
-      <!-- <tr class="<%= even_odd %>">
-        <th>Installation</th>
-        <td>Site Specials</td>
-        <td>Site Config</td>
-      </tr> -->
+      <tr class="<%= even_odd %>">
+        <th>Install</th>
+        <td><a href="/?install_special">Site Specials</a></td>
+        <td><a href="/?install_configs">Site Config</a></td>
+      </tr>
+      <tr class="<%= even_odd %>">
+        <th>Capistrano</th>
+        <td><a href="/?run_cap_deploy">run cap deploy:update</a></td>
+      </tr>
     </table>
   </div>  <!-- test summary -->
 
@@ -120,10 +130,10 @@ end
 
     <h3>Capistrano Variables</h3>
     <% if server_obj.app_hosts.sort != (server_obj.app + server_obj.migration_hosts).uniq.sort %>
-    <p class="warn">'app_hosts' does not match Capistrano 'app' and 'migration_hosts'</p>
+    <p><span class="warn">Warning: 'app_hosts' does not match Capistrano 'app' and 'migration_hosts'</span></p>
     <% end %>
     <% if server_obj.db_hosts.uniq.sort != server_obj.db.uniq.sort %>
-    <p class="warn">'db_hosts' does not match Capistrano 'db'</p>
+    <p><span class="warn">Warning: 'db_hosts' does not match Capistrano 'db'</span></p>
     <% end %>
     <table>
       <% reset_even_odd %>

data/lib/tdd_deploy/server.rb

@@ -3,6 +3,7 @@ $:.unshift File.expand_path('../lib', __FILE__)
 
 require 'uri'
 require 'tdd_deploy'
+require 'tdd_deploy/test_base'
 
 module TddDeploy
   # == TddDeploy::Server
@@ -60,6 +61,34 @@ module TddDeploy
         configurator = TddDeploy::Configurator.new
         configurator.make_configuration_files
       end
+      
+      if self.query_hash['install_special']
+        require 'tdd_deploy/installer'
+        installer = TddDeploy::Installer.new
+        [:app_hosts, :balance_hosts, :db_hosts, :web_hosts].each do |host_list|
+          installer.empty_special_dir self.site_user, host_list
+        end
+        [:app_hosts, :balance_hosts, :db_hosts, :web_hosts].each do |host_list|
+          installer.install_special_files_on_host_list_as self.site_user, host_list
+        end
+        query_hash['failed-tests'] = true
+      end
+      
+      if self.query_hash['install_configs']
+        require 'tdd_deploy/installer'
+        installer ||= TddDeploy::Installer.new
+        [:app_hosts, :balance_hosts, :db_hosts, :web_hosts].each do |host_list|
+          installer.install_config_files_on_host_list_as self.site_user, host_list
+        end
+        query_hash['failed-tests'] = true
+      end
+      
+      if self.query_hash['run_cap_deploy']
+        require 'tdd_deploy/installer'
+        installer ||= TddDeploy::Installer.new
+        installer.run_cap_deploy
+        query_hash['failed-tests'] = true
+      end
 
       load_all_tests
       
@@ -83,21 +112,23 @@ module TddDeploy
     # both host_tests and site_tests are clobbered by the rake install task.
     # local_tests is safe.
     def load_all_tests
+      # discard any already defined tests
+      TddDeploy::TestBase.flush_children_methods
+      
+      # reload all tests
       [TddDeploy::Server::HOST_TESTS_DIR, TddDeploy::Server::SITE_TESTS_DIR,
           TddDeploy::Server::LOCAL_TESTS_DIR].each do |dir|
         if File.exists?(dir)
           # puts "gathering tests from #{dir}"
           Dir.new(dir).each do |fname|
-            next if fname[0] == '.'
-
-            load File.join(dir, fname)
+            load File.join(dir, fname) if fname =~ /\.rb$/
           end
         else
           puts "skipping #{dir} - no such directory"
         end
       end
 
-      self.test_classes = TddDeploy::Base.children - [self.class]
+      self.test_classes = TddDeploy::TestBase.children
 
       @test_to_class_map = {}
       self.test_classes.each do |klass|

data/lib/tdd_deploy/site_tests/site_database.rb

@@ -1,10 +1,10 @@
-require 'tdd_deploy/base'
+require 'tdd_deploy/test_base'
 
 module TddDeploy
   # == TddDeploy::SiteDatabase
   #
   #  tests to make sure a database named 'site' is defined in postgresql databases
-  class SiteDatabase < TddDeploy::Base
+  class SiteDatabase < TddDeploy::TestBase
 
     def test_site_db_defined
       deploy_test_on_hosts_as self.site_user, self.db_hosts, "#{self.site}\s*\|\s*#{self.site}", "database for #{self.site} should exist" do

data/lib/tdd_deploy/site_tests/site_layout.rb

@@ -1,4 +1,4 @@
-require 'tdd_deploy/base'
+require 'tdd_deploy/test_base'
 
 module TddDeploy
   # == TddDeploy::SiteLayout
@@ -15,21 +15,21 @@ module TddDeploy
   # * '~/site/nginx.conf - an nginx configuratino fragment which tells nginx to proxy the site's *thin* servers
   # * ~/site/monitrc - a monit configuration fragment which tells monit how to monitor the site's *thin* servers.
   # * ~/site/one_thin_server - shell script to start a single server instance
-  class SiteLayout < TddDeploy::Base
+  class SiteLayout < TddDeploy::TestBase
     def test_site_subdir
       deploy_test_file_exists_on_hosts_as self.site_user, self.web_hosts, "#{self.site_doc_root}"
     end
 
     def test_releases_subdir
-      deploy_test_file_exists_on_hosts_as self.site_user, self.web_hosts, "#{self.site_doc_root}/../releases"
+      deploy_test_file_exists_on_hosts_as self.site_user, self.web_hosts, "#{self.site_doc_root}/../../../releases"
     end
 
     def test_thin_conf
-      deploy_test_file_exists_on_hosts_as self.site_user, self.web_hosts, "#{site_doc_root}/config/thin.conf"
+      deploy_test_file_exists_on_hosts_as self.site_user, self.web_hosts, "#{site_doc_root}/../config/thin.conf"
     end
 
     def test_one_thin_server_conf
-      deploy_test_file_exists_on_hosts_as self.site_user, self.web_hosts, "#{site_doc_root}/config/one_thin_server.conf"
+      deploy_test_file_exists_on_hosts_as self.site_user, self.web_hosts, "#{site_doc_root}/../config/one_thin_server.conf"
     end
 
     def test_site_dir_exists

data/lib/tdd_deploy/site_tests/site_rvm.rb

@@ -1,10 +1,10 @@
-require 'tdd_deploy/base'
+require 'tdd_deploy/test_base'
 
 module TddDeploy
   # = TddDeploy::SiteUser
   #
   # tests all hosts to make sure that the local user can log on as *site_user*
-  class SiteRvm < TddDeploy::Base
+  class SiteRvm < TddDeploy::TestBase
     def test_rvm
       deploy_test_on_hosts_as self.site_user, self.app_hosts, /RVM is the Ruby/, "rvm should be installed" do
         'source ~/.rvm/scripts/rvm ;  rvm'

data/lib/tdd_deploy/site_tests/site_user.rb

@@ -1,10 +1,10 @@
-require 'tdd_deploy/base'
+require 'tdd_deploy/test_base'
 
 module TddDeploy
   # = TddDeploy::SiteUser
   #
   # tests all hosts to make sure that the local user can log on as *site_user*
-  class SiteUser < TddDeploy::Base
+  class SiteUser < TddDeploy::TestBase
     def test_login_as_site_user
       deploy_test_on_hosts_as self.site_user, self.hosts, "/home/#{self.site_user}", "should be able to log into host as #{self.site_user}" do
         'pwd'

data/lib/tdd_deploy/test_base.rb

@@ -0,0 +1,37 @@
+require 'tdd_deploy/base'
+
+module TddDeploy
+  # == TddDeploy::TestBase
+  #
+  # provides a base class for host and site tests.
+  class TestBase < TddDeploy::Base
+    
+    def initialze
+      super
+      
+    end
+
+    # gather up all descendents so we know what tests to run
+    class <<self
+      attr_writer :children
+
+      def children
+        @children ||= []
+      end
+      
+      # removes all methods from defined children.
+      def flush_children_methods
+        self.children.each do |child|
+          child.instance_methods(false).each do |meth|
+            child.send :remove_method, meth
+          end
+        end
+      end
+      
+      def inherited(child)
+        self.children ||= []
+        self.children << child unless self.children.include? child
+      end
+    end
+  end
+end

data/lib/tdd_deploy/version.rb

@@ -1,3 +1,3 @@
 module TddDeploy
-  VERSION = '0.1.7'
+  VERSION = '0.1.8'
 end

data/tests/test_base.rb

@@ -14,7 +14,6 @@ end
 
 class TestBaseTestCase < Test::Unit::TestCase
   def test_tdd_deploy_base_children
-    assert TddDeploy::Base.children.include?(TestBase::Foo), "TddDeploy::Base.children should contain TestBase::Foo"
-    assert TddDeploy::Base.children.include?(TestBase::Bar), "TddDeploy::Base.children should contain TestBase::Bar"
+    assert_equal TddDeploy::Base, TestBase::Foo.superclass, "Foo is a child of TddDeploy::Base"
   end
 end

data/tests/test_copy_methods.rb

@@ -25,10 +25,10 @@ class RunMethodsTestCase < Test::Unit::TestCase
   def test_mkdir_on_remote_as
     result = mkdir_on_remote_as 'site_user', 'arch', 'test-dir'
     assert result, "mkdir_on_remote_as site_user on arch returns true"
-    stdout, stderr, cmd = run_in_ssh_session_on_host_as 'site_user', 'arch', 'test -d test-dir && echo "success"'
+    stdout, stderr, cmd = run_on_a_host_as 'site_user', 'arch', 'test -d test-dir && echo "success"'
     assert_equal "success\n", stdout, "deploy_test_file_exists_on_hosts_as says 'test-dir' exists"
     
-    stdout, stderr, cmd = run_in_ssh_session_on_host_as 'site_user', 'arch', 'rmdir test-dir ; test -d test-dir || echo "success"'
+    stdout, stderr, cmd = run_on_a_host_as 'site_user', 'arch', 'rmdir test-dir ; test -d test-dir || echo "success"'
     assert_equal "success\n", stdout, "deploy_test_file_exists_on_hosts_as says 'test-dir' removed"
   end
 
@@ -37,14 +37,14 @@ class RunMethodsTestCase < Test::Unit::TestCase
     result = append_string_to_remote_file_as 'site_user', 'arch', str, 'test-file'
     assert result, "append_string_to_remote_file_as returns true on success"
     
-    stdout, stderr, cmd = run_in_ssh_session_on_host_as('site_user', 'arch', 'cat test-file')
+    stdout, stderr, cmd = run_on_a_host_as('site_user', 'arch', 'cat test-file')
     assert_equal str, stdout, "test-file should exist on arch"
     assert_nil stderr, "stderr should be nil"
 
     result = append_string_to_remote_file_as 'site_user', 'arch', "another line\n", 'test-file'
     assert result, "append_string_to_remote_file_as returns true on success"
 
-    stdout, stderr, cmd = run_in_ssh_session_on_host_as('site_user', 'arch', 'cat test-file')
+    stdout, stderr, cmd = run_on_a_host_as('site_user', 'arch', 'cat test-file')
     assert_match /line 1/, stdout, "output should contain 'line 1'"
     assert_match /another line/, stdout, "output should contain 'another line'"
     assert_equal 4, stdout.split("\n").length, "output should contain 4 lines"
@@ -55,7 +55,7 @@ class RunMethodsTestCase < Test::Unit::TestCase
     result = copy_string_to_remote_file_as 'site_user', 'arch', str, 'test-file'
     assert result, "copy_string_to_remote_file_as returns true on success"
     
-    stdout, stderr, cmd = run_in_ssh_session_on_host_as('site_user', 'arch', 'cat test-file')
+    stdout, stderr, cmd = run_on_a_host_as('site_user', 'arch', 'cat test-file')
     assert_equal str, stdout, "test-file should exist on arch"
     assert_nil stderr, "stderr should be nil"
   end
@@ -69,7 +69,7 @@ class RunMethodsTestCase < Test::Unit::TestCase
       tmp_file.close
       result = copy_file_to_remote_as 'site_user', 'arch', tmp_file.path, 'test-file'
     
-      stdout, stderr, cmd = run_in_ssh_session_on_host_as 'site_user', 'arch', 'cat test-file'
+      stdout, stderr, cmd = run_on_a_host_as 'site_user', 'arch', 'cat test-file'
       assert_equal input_text, stdout, "remote file should contain input_text"
 
       assert result, "copy should return true"
@@ -91,11 +91,11 @@ class RunMethodsTestCase < Test::Unit::TestCase
       tmp2_file.write input2_text
       tmp2_file.close
       assert append_file_to_remote_file_as('site_user', 'arch', tmp_file.path, 'test-file'), 'copy file should work'
-      stdout, stderr, cmd = run_in_ssh_session_on_host_as 'site_user', 'arch', 'cat test-file'
+      stdout, stderr, cmd = run_on_a_host_as 'site_user', 'arch', 'cat test-file'
       assert_equal input_text, stdout, "remote file should contain input_text"
 
       assert append_file_to_remote_file_as('site_user', 'arch', tmp2_file.path, 'test-file'), 'append should return true'
-      stdout, stderr, cmd = run_in_ssh_session_on_host_as 'site_user', 'arch', 'cat test-file'
+      stdout, stderr, cmd = run_on_a_host_as 'site_user', 'arch', 'cat test-file'
       assert_equal input_text + input2_text, stdout, "remote file should contain input_text + input2_text"
     ensure
       tmp_file.unlink
@@ -103,7 +103,7 @@ class RunMethodsTestCase < Test::Unit::TestCase
     end
   end
   
-  def test_copy_string_to_remote_on_hosts_as
+  def test_copy_string_to_remote_hosts_as
     host_list = ['arch']
     str = "line 1\nline 2\nline 3\n"
     result = copy_string_to_remote_file_on_hosts_as 'site_user', host_list, str, 'test-file'
@@ -116,7 +116,7 @@ class RunMethodsTestCase < Test::Unit::TestCase
   end
   
   
-  def test_copy_string_to_remote_on_hosts_as_with_host_list_as_str
+  def test_copy_string_to_remote_hosts_as_with_host_list_as_str
     host_list = 'arch'
     str = "line 1\nline 2\nline 3\n"
     result = copy_string_to_remote_file_on_hosts_as 'site_user', host_list, str, 'test-file'
@@ -129,7 +129,7 @@ class RunMethodsTestCase < Test::Unit::TestCase
   end
   
   
-  def test_copy_file_to_remote_on_hosts_as
+  def test_copy_file_to_remote_hosts_as
     host_list = ['arch']
     require 'tempfile'
     tmp_file = Tempfile.new('foo')
@@ -137,7 +137,7 @@ class RunMethodsTestCase < Test::Unit::TestCase
       input_text = "line one\nline two\nline 3\n"
       tmp_file.write input_text
       tmp_file.close
-      result = copy_file_to_remote_on_hosts_as 'site_user', host_list, tmp_file.path, 'test-file'
+      result = copy_file_to_remote_hosts_as 'site_user', host_list, tmp_file.path, 'test-file'
     
       results = run_on_hosts_as 'site_user', host_list, 'cat test-file'
       assert_equal input_text, results['arch'][0], "remote file should contain input_text"
@@ -148,7 +148,7 @@ class RunMethodsTestCase < Test::Unit::TestCase
     end
   end
 
-  def test_copy_dir_to_remote_on_hosts_as
+  def test_copy_dir_to_remote_hosts_as
     host_list = ['arch']
     dir_name = 'test-dir'
     Dir.mkdir dir_name unless File.exists? dir_name
@@ -159,7 +159,7 @@ class RunMethodsTestCase < Test::Unit::TestCase
       f.close
     end
     
-    assert copy_dir_to_remote_on_hosts_as('site_user', host_list, dir_name, dir_name), 'copy directory should work'
+    assert copy_dir_to_remote_hosts_as('site_user', host_list, dir_name, dir_name), 'copy directory should work'
 
     result_hash = run_on_hosts_as 'site_user', host_list, "ls"
     assert_match Regexp.new(dir_name), result_hash['arch'][0], "ls of home should contain directory name"
@@ -171,12 +171,12 @@ class RunMethodsTestCase < Test::Unit::TestCase
     end
     ['foo', 'bar', 'baz'].each do |fname|
       path = File.join dir_name, fname
-      stdout, stderr, cmd = run_in_ssh_session_on_host_as 'site_user', 'arch', "cat #{path}"
+      stdout, stderr, cmd = run_on_a_host_as 'site_user', 'arch', "cat #{path}"
       assert_equal "This is a file named #{fname}\n", stdout, "copy_dir... should copy file contents of #{fname}"
     end
   end
   
-  def test_append_string_to_remote_on_hosts_as_with_host_list_as_str
+  def test_append_string_to_remote_hosts_as_with_host_list_as_str
     host_list = 'arch'
     str = "line 1\nline 2\nline 3\n"
     result = append_string_to_remote_file_on_hosts_as 'site_user', host_list, str, 'test-file'
@@ -195,7 +195,7 @@ class RunMethodsTestCase < Test::Unit::TestCase
   end
   
   
-  def test_append_file_to_remote_on_hosts_as
+  def test_append_file_to_remote_hosts_as
     host_list = ['arch']
     require 'tempfile'
     tmp_file = Tempfile.new('foo')
@@ -203,8 +203,8 @@ class RunMethodsTestCase < Test::Unit::TestCase
       input_text = "line one\nline two\nline 3\n"
       tmp_file.write input_text
       tmp_file.close
-      assert append_file_to_remote_on_hosts_as('site_user', host_list, tmp_file.path, 'test-file'), 'should work'
-      assert append_file_to_remote_on_hosts_as('site_user', host_list, tmp_file.path, 'test-file'), 'should work'
+      assert append_file_to_remote_hosts_as('site_user', host_list, tmp_file.path, 'test-file'), 'should work'
+      assert append_file_to_remote_hosts_as('site_user', host_list, tmp_file.path, 'test-file'), 'should work'
     
       results = run_on_hosts_as 'site_user', host_list, 'cat test-file'
       assert_equal input_text * 2, results['arch'][0], "remote file should contain input_text"
@@ -213,7 +213,7 @@ class RunMethodsTestCase < Test::Unit::TestCase
     end
   end
 
-  def test_append_dir_to_remote_on_hosts_as
+  def test_append_dir_to_remote_hosts_as
     host_list = ['arch']
     dir_name = 'test-dir'
     Dir.mkdir dir_name unless File.exists? dir_name
@@ -224,8 +224,8 @@ class RunMethodsTestCase < Test::Unit::TestCase
       f.close
     end
     
-    assert append_dir_to_remote_on_hosts_as('site_user', host_list, dir_name, dir_name), 'append directory should work'
-    assert append_dir_to_remote_on_hosts_as('site_user', host_list, dir_name, dir_name), 'append directory should work'
+    assert append_dir_to_remote_hosts_as('site_user', host_list, dir_name, dir_name), 'append directory should work'
+    assert append_dir_to_remote_hosts_as('site_user', host_list, dir_name, dir_name), 'append directory should work'
 
     result_hash = run_on_hosts_as 'site_user', host_list, "ls"
     assert_match Regexp.new(dir_name), result_hash['arch'][0], "ls of home should contain directory name"
@@ -237,7 +237,7 @@ class RunMethodsTestCase < Test::Unit::TestCase
     end
     ['foo', 'bar', 'baz'].each do |fname|
       path = File.join dir_name, fname
-      stdout, stderr, cmd = run_in_ssh_session_on_host_as 'site_user', 'arch', "cat #{path}"
+      stdout, stderr, cmd = run_on_a_host_as 'site_user', 'arch', "cat #{path}"
       assert_equal "This is a file named #{fname}\nThis is a file named #{fname}\n", stdout, "append_dir... should append file contents of #{fname}"
     end
   end

data/tests/test_deploy_test_methods.rb

@@ -29,6 +29,13 @@ class  DeployTestMethodsTestCase < Test::Unit::TestCase
   def teardown
     @tester = nil
   end
+  
+  def test_rationalize_host_list
+    assert_equal ['arch'], @tester.send(:rationalize_host_list, 'arch'), "rationalize_host_list should translate arch to ['arch']"
+    assert_equal ['arch'], @tester.send(:rationalize_host_list, :web_hosts), "rationalize_host_list should translate :web_hosts to ['arch']"
+    assert_equal ['arch'], @tester.send(:rationalize_host_list, [:arch]), "rationalize_host_list should translate [:arch] to ['arch']"
+    assert_equal ['arch'], @tester.send(:rationalize_host_list, ['arch']), "rationalize_host_list should translate ['arch'] to ['arch']"
+  end
 
   def test_default_env
     @tester.reset_env
@@ -48,28 +55,28 @@ class  DeployTestMethodsTestCase < Test::Unit::TestCase
   end
   
   def test_force_failure
-    result = @tester.deploy_test_in_ssh_session_as 'no-user', @tester.hosts.first, '/home/no-user', 'should fail with bad user' do
+    result = @tester.deploy_test_on_a_host_as 'no-user', @tester.hosts.first, '/home/no-user', 'should fail with bad user' do
       'pwd'
     end
     refute result, "refute version: should fail with bad userid #{result}"
   end
 
-  def test_deploy_test_in_ssh_session_as
+  def test_deploy_test_on_a_host_as
     assert_raises ArgumentError do
-      @tester.deploy_test_in_ssh_session_as 'root', @tester.hosts.first, '', 'session catches empty match expression' do
+      @tester.deploy_test_on_a_host_as 'root', @tester.hosts.first, '', 'session catches empty match expression' do
         'uname -a'
       end
       @tester.reset_tests
     end
 
-    tmp = @tester.deploy_test_in_ssh_session_as 'root', @tester.hosts.first, 'no-file-exists', 'generate an error' do
+    tmp = @tester.deploy_test_on_a_host_as 'root', @tester.hosts.first, 'no-file-exists', 'generate an error' do
       'ls /usr/no-file-exists'
     end
     # @tester.announce_formatted_test_results
     @tester.reset_tests
     refute tmp, "run as root should fail when accessing a non-existent file"
 
-    tmp = @tester.deploy_test_in_ssh_session_as 'root', @tester.hosts.first, "/root", "should run as root on host #{@tester.hosts.first}" do
+    tmp = @tester.deploy_test_on_a_host_as 'root', @tester.hosts.first, "/root", "should run as root on host #{@tester.hosts.first}" do
       'pwd'
     end
     # @tester.announce_formatted_test_results

data/tests/test_installer.rb

@@ -0,0 +1,42 @@
+$:.unshift File.expand_path('..', __FILE__)
+require 'test_helpers'
+require 'tdd_deploy/installer'
+
+class TestTddDeployInstallerTestCase < Test::Unit::TestCase
+  
+  def setup
+    @helper = TddDeploy::Installer.new
+    @helper.set_env :site_user => 'site_user', :app_hosts => ['arch']
+  end
+  
+  def test_install_special_files
+    assert @helper.install_special_files_on_host_list_as('site_user', 'app_hosts'), "install_special_files_on_host_as should copy stuff to app_hosts"
+    stdout, stderr, cmd = @helper.run_on_a_host_as 'site_user', 'arch', "ls #{@helper.site_special_dir}"
+    assert_match /monitrc/, stdout, "special dir should contain monitrc"
+    assert_nil stderr, "test command should run w/o errors"
+  end
+  
+  def test_empty_special_dir
+    @helper.run_on_a_host_as @helper.site_user, 'arch', "echo 'this is a string' >#{@helper.site_special_dir}/foo"
+    stdout, stderr, cmd = @helper.run_on_a_host_as @helper.site_user, 'arch', "ls #{@helper.site_special_dir}"
+    assert_match /foo/, stdout, "should be able to create file 'foo'"
+    
+    assert @helper.empty_special_dir(@helper.site_user, :app_hosts), "empty_special_dir should return true"
+    stdout, stderr, cmd = @helper.run_on_a_host_as @helper.site_user, 'arch', "ls #{@helper.site_special_dir}"
+    assert stdout !~ /foo/, "foo file should be gone"
+  end
+
+  def test_install_config_files
+    assert @helper.install_config_files_on_host_list_as('site_user', 'app_hosts'), 'install config_files should return true'
+
+    config_dir = File.join @helper.site_doc_root, '..', 'config'
+
+    stdout, stderr, cmd = @helper.run_on_a_host_as 'site_user', 'arch', "ls #{config_dir}"
+    assert_match /one_thin_server.conf/, stdout, "config dir should contain one_thin_server.conf"
+    assert_nil stderr, "test command should run w/o errors"
+  end
+  
+  def test_run_cap_deploy
+    assert @helper.run_cap_deploy, "running cap deploy should succeed"
+  end
+end

data/tests/test_run_methods.rb

@@ -19,24 +19,24 @@ class RunMethodsTestCase < Test::Unit::TestCase
     refute ping_host('non-existent-host'), 'cannot ping non-existent-host'
   end
 
-  def test_run_in_ssh_session_on_host_as
-    stdout, stderr, cmd = run_in_ssh_session_on_host_as 'mike', 'arch', 'pwd'
+  def test_run_on_a_host_as
+    stdout, stderr, cmd = run_on_a_host_as 'mike', 'arch', 'pwd'
     assert_equal "/home/mike\n", stdout, "should be able to run as mike on host arch"
     assert_nil stderr, "should not return error if can connect to host"
     assert_equal 'pwd', cmd, 'cmd should be pwd'
       
-    stdout, stderr = run_in_ssh_session_on_host_as 'mike', 'no-host', 'pwd'
+    stdout, stderr = run_on_a_host_as 'mike', 'no-host', 'pwd'
     refute_equal "/home/mike\n", stdout, "should not return home directory for bad host name"
     refute_nil stderr, "should return an error message for bad host name"
     assert_equal 'pwd', cmd, 'cmd should be pwd'
       
-    stdout, stderr = run_in_ssh_session_on_host_as 'no-user', 'arch', 'pwd'
+    stdout, stderr = run_on_a_host_as 'no-user', 'arch', 'pwd'
     refute_equal "/home/mike\n", stdout, "should not return home directory for bad user name"
     refute_nil stderr, "should return an error message for bad user name"
   end
   
-  def test_run_in_ssh_session_on_host_as
-    stdout, stderr, cmd = run_in_ssh_session_on_host_as 'mike', 'arch' do
+  def test_run_on_a_host_as
+    stdout, stderr, cmd = run_on_a_host_as 'mike', 'arch' do
       'pwd'
     end
     assert_equal "/home/mike\n", stdout, "should be able to run as mike on host arch"

data/tests/test_server.rb

@@ -3,6 +3,7 @@ $:.unshift File.expand_path('../../lib', __FILE__)
 require 'test/unit'
 require 'tdd_deploy/environ'
 require 'tdd_deploy/server'
+require 'tdd_deploy/test_base'
 
 class TestServerTestCase < Test::Unit::TestCase
   GEM_ROOT = File.expand_path('../..', __FILE__)
@@ -24,8 +25,10 @@ class TestServerTestCase < Test::Unit::TestCase
   end
   
   def teardown
-    @tester = nil
     system('rm -f site_host_setup.env')
+    TddDeploy::TestBase.flush_children_methods
+    @tester.load_all_tests
+    @tester = nil
   end
   
   def test_env_file_detection

data/tests/test_test_base.rb

@@ -0,0 +1,37 @@
+$:.unshift File.expand_path('../', __FILE__)
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'test_helpers'
+require 'tdd_deploy/test_base'
+require 'tdd_deploy/server'
+
+class TestBaseTestCase < Test::Unit::TestCase
+  def setup
+    TddDeploy::Server.new.load_all_tests
+  end
+  
+  def teardown
+    TddDeploy::Server.new.load_all_tests
+  end
+
+  def test_require_subclass
+    assert TddDeploy::TestBase.children.include?(TddDeploy::HostConnection), "children must contain TddDeploy::HostConnection"
+  end
+  
+  def test_flush_children_methods
+    children_before = TddDeploy::TestBase.children
+    TddDeploy::TestBase.children.each do |child|
+      assert_not_equal [], child.instance_methods(false), "child #{child} should have methods"
+    end
+    TddDeploy::TestBase.flush_children_methods
+    assert_equal children_before, TddDeploy::TestBase.children, "flush_children should not change children Array"
+    TddDeploy::TestBase.children.each do |child|
+      assert_equal [], child.instance_methods(false), "Each child should not have any methods"
+    end
+    
+    TddDeploy::Server.new.load_all_tests
+    TddDeploy::TestBase.children.each do |child|
+      assert_not_equal [], child.instance_methods(false), "child #{child} should have methods after reloading"
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tdd_deploy
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2011-08-16 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
-  requirement: &2160122860 !ruby/object:Gem::Requirement
+  requirement: &2153638900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2160122860
+  version_requirements: *2153638900
 - !ruby/object:Gem::Dependency
   name: net-ping
-  requirement: &2160122180 !ruby/object:Gem::Requirement
+  requirement: &2153638200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2160122180
+  version_requirements: *2153638200
 - !ruby/object:Gem::Dependency
   name: net-ssh
-  requirement: &2160121720 !ruby/object:Gem::Requirement
+  requirement: &2153637600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2160121720
+  version_requirements: *2153637600
 - !ruby/object:Gem::Dependency
   name: rack
-  requirement: &2160121060 !ruby/object:Gem::Requirement
+  requirement: &2153637000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2160121060
+  version_requirements: *2153637000
 - !ruby/object:Gem::Dependency
   name: ZenTest
-  requirement: &2160120340 !ruby/object:Gem::Requirement
+  requirement: &2153636080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +65,10 @@ dependencies:
         version: 4.5.0
   type: :development
   prerelease: false
-  version_requirements: *2160120340
+  version_requirements: *2153636080
 - !ruby/object:Gem::Dependency
   name: autotest-growl
-  requirement: &2160119700 !ruby/object:Gem::Requirement
+  requirement: &2153623700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +76,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2160119700
+  version_requirements: *2153623700
 description: Test driven support for host provisioning & Capistrano deployment - for
   those who don't want to bother learning too much
 email: ! ' mike@clove.com '
@@ -104,6 +104,7 @@ files:
 - lib/tdd_deploy/host_tests/remote_nginx.rb
 - lib/tdd_deploy/host_tests/remote_postfix.rb
 - lib/tdd_deploy/host_tests/remote_postgresql.rb
+- lib/tdd_deploy/installer.rb
 - lib/tdd_deploy/local_tests/smoke_test.rb
 - lib/tdd_deploy/railengine.rb
 - lib/tdd_deploy/run_methods.rb
@@ -112,6 +113,7 @@ files:
 - lib/tdd_deploy/site_tests/site_layout.rb
 - lib/tdd_deploy/site_tests/site_rvm.rb
 - lib/tdd_deploy/site_tests/site_user.rb
+- lib/tdd_deploy/test_base.rb
 - lib/tdd_deploy/version.rb
 - lib/tdd_deploy.rb
 - tests/test_assertions.rb
@@ -123,6 +125,7 @@ files:
 - tests/test_environ.rb
 - tests/test_helpers.rb
 - tests/test_host_tests.rb
+- tests/test_installer.rb
 - tests/test_remote_ip_tables.rb
 - tests/test_remote_monit.rb
 - tests/test_remote_nginx.rb
@@ -136,6 +139,7 @@ files:
 - tests/test_tdd_deploy.rb
 - tests/test_tdd_deploy_context.rb
 - tests/test_tdd_deploy_server.rb
+- tests/test_test_base.rb
 - lib/tasks/tdd_deploy.rake
 - lib/tdd_deploy/server-templates/test_results.html.erb
 - lib/tdd_deploy/site-erb/app_hosts/config/one_thin_server.conf.erb