tdd_deploy 0.0.3 → 0.1.1

data/lib/tdd_deploy/environ.rb

@@ -78,6 +78,8 @@ module TddDeploy
       'local_admin_email' => :string,
 
       'site' => :string,
+      'site_url' => :string,
+      'site_path' => :string,
       'site_user' => :string,
 
       # 'hosts' => :list,
@@ -96,12 +98,14 @@ module TddDeploy
       'local_admin_email' => "local_admin@bogus.tld",
 
       'site' => "site",
+      'site_url' => 'www.site.com',                    # don't include the scheme
+      'site_path' => '/home/site_user/site.d/current',   # default for Capistrano
       'site_user' => "site_user",
 
       # 'hosts' => "bar,foo",
-      'balance_hosts' => '',
-      'db_hosts' => 'bar,foo',
-      'web_hosts' => 'bar,foo',
+      'balance_hosts' => 'arch',
+      'db_hosts' => 'arch',
+      'web_hosts' => 'arch',
     }
     
     def env_types
@@ -124,9 +128,10 @@ module TddDeploy
         when :list then DataCache.env_hash[k] = self.str_to_list(v)
         else
           if k == 'hosts'
-            if DataCache.env_hash['web_hosts'] == DataCache.env_hash['db_hosts']
+            if DataCache.env_hash['web_hosts'] == DataCache.env_hash['db_hosts'] &&  DataCache.env_hash['web_hosts'] == DataCache.env_hash['balance_hosts']
               DataCache.env_hash['web_hosts'] =
-                DataCache.env_hash['db_hosts'] = self.str_to_list(v)
+                DataCache.env_hash['db_hosts'] =
+                  DataCache.env_hash['balance_hosts'] = self.str_to_list(v)
             else
               raise RuntimeError.new("#{self}#reset_env(): Cannot assign value to 'hosts' if web_hosts &/or db_hosts already set.\n web_hosts: #{DataCache.env_hash['web_hosts']}\n db_hosts: #{DataCache.env_hash['db_hosts']}")
               # raise RuntimeError.new("Cannot change hosts key if web_hosts != db_hosts")
@@ -231,7 +236,8 @@ module TddDeploy
     def hosts=(list)
       if (self.web_hosts.nil? && self.db_hosts.nil?) || self.web_hosts == self.db_hosts
         self.web_hosts =
-          self.db_hosts = self.str_to_list(list)
+          self.db_hosts =
+            self.balance_hosts = self.str_to_list(list)
       else
         raise RuntimeError.new("Cannot assign value to 'hosts' if web_hosts &/or db_hosts already set.\n web_hosts: #{self.web_hosts}\n db_hosts: #{self.db_hosts}")
       end

data/lib/tdd_deploy/host_tests/host_connection.rb

@@ -4,24 +4,23 @@ module TddDeploy
   class HostConnection < TddDeploy::Base
     # ping - pings all hosts
     def ping
-      require 'net/ping'
       result = true
       self.hosts.each do |host|
-        result &= assert Net::Ping::External.new(host).ping?, "Host #{host} should respond to ping"
+        result &= assert host, ping_host(host), "Host #{host} should respond to ping"
        end
        result
     end
 
     # ssh_login - attempts to log in as *host_admin* on all hosts from current user
     def ssh_login
-      deploy_test_on_all_hosts "/home/#{self.host_admin}\n", "should be able to connect via ssh" do
+      deploy_test_on_hosts_as self.host_admin, self.hosts, "/home/#{self.host_admin}\n", "should be able to connect via ssh" do
         'pwd'
       end
     end
     
     # ssh_login_as_root - attempts to log in as *root* on all hosts from current user
     def ssh_login_as_root
-      deploy_test_on_all_hosts_as 'root', '/root', "Should be able to connect as root via ssh" do
+      deploy_test_on_hosts_as 'root', self.hosts, '/root', "Should be able to connect as root via ssh" do
         'pwd'
       end
     end

data/lib/tdd_deploy/host_tests/remote_ip_tables.rb

@@ -12,23 +12,31 @@ module TddDeploy
       self.hosts.each do |host|
         # Linode seems to refuse to block 21 - FTP control
         #  [20, 21, 23, 25, 53, 5432, 2812].each do |port|
-        [20, 23, 25, 53, 5432, 2812].each do |port|
-          tcp_socket = TCPSocket.new(host, port) rescue 'failed'
-          assert_equal 'failed', tcp_socket, "Host: #{host}: Should not be able to connect via tcp to port #{port}"
+        if self.ping_host(host)
+          [20, 23, 25, 53, 5432, 2812].each do |port|
+            tcp_socket = TCPSocket.new(host, port) rescue 'failed'
+            assert_equal host, 'failed', tcp_socket, "Host: #{host}: Should not be able to connect via tcp to port #{port}"
+          end
+        else
+          fail host, "Host: #{host}: iptables cannot be tested - host does not respond to ping"
         end
       end
     end
 
+    # Unfortunately, this doesn't work with UDP. I'd need a resonder on the server
+    # to see if the ports were blocked & I don't have one.
     # udp_some_blocked_ports - checks UDP ports
-    def udp_some_blocked_ports
-      self.hosts.each do |host|
-        # Linode seems to refuse to block 21 - FTP control
-        #  [20, 21, 23, 25, 53, 5432, 2812].each do |port|
-        [20, 23, 25, 53, 5432, 2812].each do |port|
-          udp_socket = UDPSocket.new(host, port) rescue 'failed'
-          assert_equal 'failed', udp_socket, "Host: #{host}: Should not be able to connect via udp to port #{port}"
-        end
-      end
-    end
+    # def udp_some_blocked_ports
+    #   self.hosts.each do |host|
+    #     # Linode seems to refuse to block 21 - FTP control
+    #     #  [20, 21, 23, 25, 53, 5432, 2812].each do |port|
+    #     [20, 23, 25, 53, 5432, 2812].each do |port|
+    #       # udp_socket = UDPSocket.new(host, port) rescue 'failed'
+    #       udp_socket = UDPSocket.new
+    #       udp_socket.bind(host, port) rescue 'failed to bind'
+    #       assert_equal host, 'failed', udp_socket, "Host: #{host}: Should not be able to connect via udp to port #{port}"
+    #     end
+    #   end
+    # end
   end
 end

data/lib/tdd_deploy/host_tests/remote_monit.rb

@@ -3,15 +3,11 @@ require 'tdd_deploy/base'
 module TddDeploy
   class RemoteMonit < TddDeploy::Base
     def test_monit_installed
-      deploy_test_on_all_hosts '/usr/bin/monit', "monit should be installed" do
-       'ls /usr/bin/monit'
-      end
+      deploy_test_file_exists_on_hosts_as self.host_admin, self.hosts, '/usr/bin/monit', 'monit should be installed'
     end
 
     def test_monit_running
-      deploy_test_on_all_hosts /\smonit\s/, "monit should be running" do
-       'ps -p `cat /var/run/monit.pid`'
-      end
+      deploy_test_process_running_on_hosts_as 'root', self.hosts, '/var/run/monit.pid', "monit should be running"
     end
   end
 end

data/lib/tdd_deploy/host_tests/remote_nginx.rb

@@ -3,15 +3,11 @@ require 'tdd_deploy/base'
 module TddDeploy
   class RemoteNginx < TddDeploy::Base
     def test_nginx_installed
-      deploy_test_on_all_hosts '/usr/sbin/nginx', "nginx should be installed" do
-        'ls /usr/sbin/nginx'
-      end
+      deploy_test_file_exists_on_hosts_as self.host_admin, self.web_hosts + self.balance_hosts, '/usr/sbin/nginx', "nginx should be installed"
     end
 
     def test_nginx_running
-      deploy_test_on_all_hosts /\snginx\s/, "nginx shold be running" do
-        'ps -p `cat /var/run/nginx.pid`'
-      end
+      deploy_test_process_running_on_hosts_as self.host_admin, self.web_hosts + self.balance_hosts, '/var/run/nginx.pid', "nginx shold be running"
     end
   end
 end

data/lib/tdd_deploy/host_tests/remote_postfix.rb

@@ -3,19 +3,15 @@ require 'tdd_deploy/base'
 module TddDeploy
   class RemotePostfix < TddDeploy::Base
     def test_postfix_installed
-      deploy_test_on_all_hosts '/usr/sbin/postfix', "postfix should be installed" do
-        'ls /usr/sbin/postfix'
-      end
+      deploy_test_file_exists_on_hosts_as 'root', self.hosts, '/usr/sbin/postfix', "postfix should be installed"
     end
 
     def test_postfix_running
-      deploy_test_on_all_hosts_as 'root', /\smaster\s/, "postfix should be running" do
-        'ps -p `cat /var/spool/postfix/pid/master.pid`'
-      end
+      deploy_test_process_running_on_hosts_as 'root', self.hosts, '/var/spool/postfix/pid/master.pid', "postfix should be running"
     end
 
     def test_postfix_accepts_mail
-      deploy_test_on_all_hosts "mail works\n", 'postfix accepts mail' do |host, login, userid|
+      deploy_test_on_hosts_as self.host_admin, self.hosts, "mail works\n", 'postfix accepts mail' do |host, login, userid|
         "echo \"test mail\" | mail -s 'test mail' -r #{userid}@#{host} #{self.local_admin_email} && echo 'mail works'"
       end
     end

data/lib/tdd_deploy/host_tests/remote_postgresql.rb

@@ -3,15 +3,11 @@ require 'tdd_deploy/base'
 module TddDeploy
   class RemotePostgresql < TddDeploy::Base
     def test_postgresql_installed
-      deploy_test_on_all_hosts "/usr/bin/postgres\n", 'postgres should be installed' do |host, login, admin|
-        "ls /usr/bin/postgres"
-      end
+      deploy_test_file_exists_on_hosts_as 'root', self.db_hosts, "/usr/bin/postgres", 'postgres should be installed'
     end
 
     def test_postgresql_running
-      deploy_test_on_all_hosts /postgres\s*\|\s*postgres/, "postgresql server should be running" do
-        "psql --command='\\l' postgres postgres"
-      end
+      deploy_test_process_running_on_hosts_as 'root', self.db_hosts, '/var/lib/postgres/data/postmaster.pid', 'postgresql server should be running'
     end
   end
 end

data/lib/tdd_deploy/run_methods.rb

@@ -1,44 +1,46 @@
 module TddDeploy
   module RunMethods
     require 'net/ssh'
+    require 'net/ping'
     
     # runs the output of the block on all hosts defined in self.hosts as user self.host_admin.
     # Returns a hash of two element arrays containing output [stdout, stderr] returned from the command.
     # Hash keys are host names as strings.
-    def run_on_all_hosts(&block)
-      run_on_all_hosts_as self.host_admin, &block
+    def run_on_all_hosts(cmd = nil, &block)
+      run_on_all_hosts_as self.host_admin, cmd, &block
     end
 
     # Runs the output of the block on all hosts defined in self.hosts as user 'userid'.
     # Returns a hash of two element arrays containing output [stdout, stderr] returned from the command.
     # Hash keys are host names as strings.
-    def run_on_all_hosts_as(userid, &block)
-      results = {}
-      self.hosts.each do |host|
-        results[host] = run_in_ssh_session_as(userid, host, &block)
-      end
-      results
+    def run_on_all_hosts_as(userid, cmd = nil, &block)
+      run_on_hosts_as userid, self.hosts, cmd, &block
     end
-
-    # Runs the command secified in &block on 'host' as user 'self.host_admin'.
-    # Returns an array [stdout, stderr] returned from the command.
-    def run_in_ssh_session(host, &block)
-      run_in_ssh_session_as(self.host_admin, host, &block)
+    
+    # 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
+      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_as(userid, host, &block)
+    def run_in_ssh_session_on_host_as(userid, host, cmd = nil, &block)
       login = "#{userid}@#{host}"
       match = Regexp.new(match) if match.is_a? String
-      raise ArgumentError, 'match expression cannot be empty' if match =~ ''
+      raise ArgumentError.new('match expression cannot be empty') if match =~ ''
 
       rsp = nil
       err_rsp = nil
-      cmd = block.call(host, login, userid)
+      cmd = block.call if block_given?
+      raise ArgumentError.new('cmd cannot be empty') if cmd.empty?
 
       begin
-        ssh_session = Net::SSH.start(host, userid, :timeout => self.ssh_timeout)
+        ssh_session = Net::SSH.start(host, userid, :timeout => self.ssh_timeout, :languages => 'en')
         raise "Unable to establish connecton to #{host} as #{userid}" if ssh_session.nil?
 
         ssh_session.open_channel do |channel|
@@ -52,8 +54,9 @@ module TddDeploy
               err_rsp ||= ''
               err_rsp += data.to_s
             end
-
           end
+          
+          channel.wait
         end
 
         # must do this or the channel only runs once
@@ -66,6 +69,7 @@ module TddDeploy
       end
       [rsp, err_rsp, cmd]
     end
+
   
     # run locally runs a comman locally and returns the output of stdout, stderr, and the command
     # run in a 3 element array
@@ -122,5 +126,8 @@ module TddDeploy
       [stdout, stderr, cmd]
     end
 
+    def ping_host host
+      Net::Ping::External.new(host).ping?
+    end
   end
 end

data/lib/tdd_deploy/server.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 $:.unshift File.expand_path('../lib', __FILE__)
 
+require 'uri'
 require 'tdd_deploy'
 
 module TddDeploy
@@ -9,11 +10,13 @@ module TddDeploy
     HOST_TESTS_DIR = File.join(Dir.pwd, 'lib', 'tdd_deploy', 'host_tests')
     SITE_TESTS_DIR = File.join(Dir.pwd, 'lib', 'tdd_deploy', 'site_tests')
     LOCAL_TESTS_DIR = File.join(Dir.pwd, 'lib', 'tdd_deploy', 'local_tests')
+    TEMPLATE_PATH = File.join(LIB_DIR, 'tdd_deploy', 'server-templates', 'test_results.html.erb')
 
-    attr_accessor :test_classes
+    attr_accessor :test_classes, :query_hash, :failed_tests
   
     def initialize *args
       @already_defined = TddDeploy.constants
+      load_all_tests
       super
     end
 
@@ -31,28 +34,105 @@ module TddDeploy
           end
         end
       end
+
       self.test_classes = TddDeploy::Base.children - [self.class]
+
+      @test_to_class_map = {}
+      self.test_classes.each do |klass|
+        klass.instance_methods(false).each do |func|
+          @test_to_class_map[func.to_s] = klass
+        end
+      end
     end
     
-    def run_all_tests
-      load_all_tests
-      
+    def run_all_tests(test_group = nil)
+      read_env
       reset_tests
 
+      test_classes = if test_group && defined?(@test_classes_hash)
+        failed_test_keys = test_group.split(',')
+        @test_classes_hash.select { |k, v| failed_test_keys.include? k }.values
+      else
+        self.test_classes
+      end
+
       ret = true
-      self.test_classes.each do |klass|
-        obj = klass.new
-        # puts "#{klass}.instance_methods: #{klass.instance_methods(false)}"
-        klass.instance_methods(false).each do |func|
-          ret &= obj.send func.to_sym
-        end
+      @failed_tests = []
+      test_classes.each do |klass|
+        ret &= run_all_tests_in_class(klass)
+      end
+      ret
+    end
+    
+    def run_selected_tests(test_list)
+      read_env
+      ret = true
+      test_list = test_list.split(/[\s,]+/) if test_list.is_a? String
+      test_list.each do |test|
+        ret &= run_a_test test
+      end
+      ret
+    end
+
+    def run_all_tests_in_class klass
+      read_env
+      obj = klass.new
+      ret = true
+      # puts "#{klass}.instance_methods: #{klass.instance_methods(false)}"
+      klass.instance_methods(false).each do |func|
+        test_result = obj.send func.to_sym
+        @failed_tests.push(func) unless test_result
+        ret &= test_result
       end
       ret
     end
     
+    def run_a_test test
+      read_env
+      obj = @test_to_class_map[test].new
+      test_result = obj.send test.to_sym
+      @failed_tests.push(test) unless test_result
+      test_result
+    end
+    
+    def parse_query_string(query_string)
+      return '' unless query_string.is_a? String
+      Hash[query_string.split('&').map { |tmp| key,value = tmp.split('='); value ? [key, URI.decode(value)] : [key, 'true']}]
+    end
+    
+    def render_results
+      f = File.new(TEMPLATE_PATH)
+      template = ERB.new f.read, nil, '<>'
+      f.close
+      
+      template.result(binding)
+    end
+    
+    def new_query_string
+      str = "failed-tests=" + URI.escape(@failed_tests.join(',')) unless @failed_tests.nil? || @failed_tests.empty?
+    end
+
     def call(env)
-      run_all_tests
-      body = ["<h1>TDD Test Results:</h1>", self.test_results]
+      self.query_hash = parse_query_string(env['QUERY_STRING'])
+
+      if query_hash['run_configurator']
+        require 'tdd_deploy/configurator'
+        configurator = TddDeploy::Configurator.new
+        configurator.make_configuration_files
+      end
+      
+      if query_hash['failed-tests']
+        remove_failed_tests
+        run_selected_tests(query_hash['failed-tests'])
+      else
+        run_all_tests
+      end
+      
+      query_string = new_query_string
+      body = [
+        render_results,
+        "#{env.inspect}"
+        ]
       return [200, {'Content-Length' => body.join('').length.to_s, 'Content-Type' => 'text/html'}, body]
     end
   end

data/lib/tdd_deploy/site_tests/site_database.rb

@@ -7,7 +7,7 @@ module TddDeploy
   class SiteDatabase < TddDeploy::Base
 
     def test_site_db_defined
-      deploy_test_on_all_hosts "#{self.site}\s*\|\s*#{self.site}", "database for #{self.site} should exist" do
+      deploy_test_on_hosts_as self.site_user, self.db_hosts, "#{self.site}\s*\|\s*#{self.site}", "database for #{self.site} should exist" do
         "psql --command='\\l' postgres postgres"
       end
     end

data/lib/tdd_deploy/site_tests/site_layout.rb

@@ -8,39 +8,43 @@ module TddDeploy
   #
   #  The sub directories tested for are:
   #
-  #     *site* - a directory named for the name of the site.
-  #     *site*/releases - a standard directory used by Capistrano
-  #     *site*/nginx.conf - an nginx configuratino fragment which tells nginx to
+  #     *site*.d - a directory named for the name of the site.
+  #     *site*.d/releases - a standard directory used by Capistrano
+  #     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
+  #     site/monitrc - a monit configuration fragment which tells monit how to monitor
   #      the site's *thin* servers.
   class SiteLayout < TddDeploy::Base
     def test_site_subdir
-      deploy_test_on_all_hosts_as self.site_user, "#{self.site}/", \
-          "directory /home/#{self.site_user}/#{self.site} should exist" do
-        'ls -F'
-      end
+      deploy_test_file_exists_on_hosts_as self.site_user, self.web_hosts, "#{self.site_path}"
     end
 
     def test_releases_subdir
-      deploy_test_on_all_hosts_as self.site_user, "releases", \
-          "directory /home/#{self.site_user}/#{self.site}/releases should exist" do
-        "ls -F #{self.site}"
-      end
+      deploy_test_file_exists_on_hosts_as self.site_user, self.web_hosts, "#{self.site_path}/../releases"
+    end
+
+    def test_site_dir_exists
+      deploy_test_file_exists_on_hosts_as self.site_user, self.web_hosts, "#{self.site_path}/site"
     end
 
     def test_monitrc
-      deploy_test_on_all_hosts_as self.site_user, 'monitrc', \
-          "file /home/#{self.site_user}/monitrc should exist" do
-            'ls'
-      end
+      deploy_test_file_exists_on_hosts_as self.site_user, self.web_hosts, "#{self.site_path}/site/monitrc"
     end
 
     def test_nginx_conf
-      deploy_test_on_all_hosts_as self.site_user, 'nginx.conf', \
-          "file /home/#{self.site_user}/nginx.conf should exist" do
-            'ls'
-      end
+      deploy_test_file_exists_on_hosts_as self.site_user, self.web_hosts, "#{self.site_path}/site/nginx.conf"
+    end
+
+    def test_thin_conf
+      deploy_test_file_exists_on_hosts_as self.site_user, self.web_hosts, "#{site_path}/config/thin.conf"
+    end
+
+    def test_one_thin_server_conf
+      deploy_test_file_exists_on_hosts_as self.site_user, self.web_hosts, "#{site_path}/config/one_thin_server.conf"
+    end
+
+    def test_one_thin_server
+      deploy_test_file_exists_on_hosts_as self.site_user, self.web_hosts, "#{site_path}/site/one_thin_server"
     end
   end
 end