tdd_deploy 0.0.3 → 0.1.1

data/bin/tdd_deploy_site_installer

@@ -0,0 +1,7 @@
+#! /usr/bin/env ruby
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'tdd_deploy/site_installer'
+
+TddDeploy::SiteInstaller.new.install

data/lib/tasks/tdd_deploy_site_install.rake

@@ -0,0 +1,17 @@
+require 'rake'
+
+desc 'Clean'
+task :clean do
+  ['monitrc', 'one_thin_server'].each do |fname|
+    FileUtils.rm File.join('site', fname)
+  end
+  ['nginx.conf', 'thin.conf', 'thin_one_server.conf'].each do |fname|
+    FileUtils.rm File.join('config', fname)
+  end
+end
+
+desc 'Create Site Config & Site files'
+task :create_site_files do
+  require 'tdd_deploy_site_installer'
+  
+end

data/lib/tdd_deploy/assertions.rb

@@ -1,14 +1,16 @@
 module TddDeploy
   module Assertions
-    GREEN = '#0c0'
-    RED   = '#c00'
-    WRAP_ELT_TAG = 'p'
+    GREEN = '#080'
+    RED   = '#800'
+    GROUP_ELT_TAG = 'ul'
+    HEADER_ELT_TAG = 'h2'
+    RESULT_ELT_TAG = 'li'
     # TddDeploy re-implements popular assertions so that they can be used
     # in multi-host testing.
     #
     # These assertions differ from usual TDD assertions in that they do not stop
     # tests after failing. Rather they continue and accumulate failure counts and messages
-    # which can be displayed using *announce_test_results()*.
+    # which can be displayed using *announce_formatted_test_results()*.
     #
     # all assertions return boolean *true* or *false*
 
@@ -21,126 +23,161 @@ module TddDeploy
     # are initialized - which can easily differ from where they are declared.
     class Stats
       class << self
-        attr_accessor :test_count, :failure_count, :failure_messages, :test_messages
+        attr_accessor :test_results
       end
     end
 
-    # test_results returns the string string of all test messages
-    def test_results
-      unless Stats.failure_count.nil? || Stats.failure_count == 0
-        str = "<#{WRAP_ELT_TAG} style=\"color:#{RED}\">#{Stats.failure_count} Failed Test" + (Stats.failure_count == 1 ? '' : 's') + "</#{WRAP_ELT_TAG}>"
-      else
-        str = "<#{WRAP_ELT_TAG} style=\"color:#{GREEN}\">All Tests Passed</#{WRAP_ELT_TAG}>"
-      end
-      Stats.test_messages ? str + Stats.test_messages.join("\n") : str
-    end
-    
-    def test_failures
-      return '' unless Stats.failure_count > 0
-      "<#{WRAP_ELT_TAG} style=\"color:#{RED}\">Failed #{Stats.failure_count} tests</#{WRAP_ELT_TAG}>\n" + Stats.failure_messages.join("\n")
-    end
-    
-    def test_messages
-      Stats.test_messages
-    end
-    
-    # reset_tests zeros out failure messages and count
-    def reset_tests
-      Stats.test_count = 0
-      Stats.failure_count = 0
-      Stats.failure_messages = []
-      Stats.test_messages = []
-    end
-
     # Assertions all return true or false. The last parameter is always the assertions
     # message and is optional.
     #
     # assert(prediccate, msg) returns true if prediccate is true, else adds *msg*
     # to failure messages and returns false
-    def assert predicate, msg
-      assert_primative predicate, msg
+    def assert key, predicate, msg
+      assert_primative key, predicate, msg
     end
   
-    def assert_equal expect, value, msg
-      assert_primative expect == value, msg
+    def assert_equal key, expect, value, msg
+      assert_primative key, expect == value, msg
     end
     
-    def assert_match regx, value, msg
+    def assert_match key, regx, value, msg
       regx = Regexp.new(regx.to_s) unless regx.instance_of? Regexp
-      assert_primative regx.match(value), msg
+      assert_primative key, regx.match(value), msg
     end
   
-    def assert_nil value, msg
-      assert_primative value.nil?, msg
+    def assert_nil key, value, msg
+      assert_primative key, value.nil?, msg
     end
   
-    def assert_not_nil value, msg
-      assert_primative !value.nil?, msg
+    def assert_not_nil key, value, msg
+      assert_primative key, !value.nil?, msg
     end
 
-    def assert_raises exception = Exception, msg, &block
+    def assert_raises key, exception = Exception, msg, &block
       begin
         block.call
       rescue exception => e
+        pass key, msg
         return true
       end
-      assert_primative false, msg
+      fail key, msg
     end
 
-    def refute predicate, msg
-      assert_primative !predicate, msg
+    def refute key, predicate, msg
+      assert_primative key, !predicate, msg
     end
   
-    def refute_equal expect, value, msg
-      assert_primative expect != value, msg
+    def refute_equal key, expect, value, msg
+      assert_primative key, expect != value, msg
     end
   
-    def pass msg
-      assert_primative true, msg
+    def pass key, msg
+      assert_primative key, true, msg
+    end
+
+    def fail key, msg
+      assert_primative key, false, msg
+    end
+
+    # public stats access
+
+    # don't use formatted_test_results or formatted_test_results_for_key
+    # use the supplied test_results.html.erb template instead
+    # formatted_test_results returns the string string of all test messages
+    def formatted_test_results
+      str = ''
+      Stats.test_results.keys.sort.each do |key|
+        str += formatted_test_results_for_key(key)
+      end
+      str
+    end
+    
+    def formatted_test_results_for_key key
+      str = "<#{GROUP_ELT_TAG} class=\"test-result-group\" id=\"test-result-group-#{key}\">\n<#{HEADER_ELT_TAG} class=\"test-result-header\" id=\"test-result-header-#{key}\">Results for '#{key}'</#{HEADER_ELT_TAG}>\n"
+      if failure_count(key) == 0
+        str += "<#{RESULT_ELT_TAG} class=\"test-result-summary-success\" id=\"test-result-summary-#{key}\">All #{test_count(key)} Tests Passed</#{RESULT_ELT_TAG}>\n"
+      else
+        str += "<#{RESULT_ELT_TAG} class=\"test-result-summary-failure\" id=\"test-result-summary-#{key}\">#{failure_count(key)} of #{test_count(key)} Tests Failed</#{RESULT_ELT_TAG}>\n"
+      end
+      toggle = true
+      tmp = Stats.test_results[key].map { |msg| toggle = !toggle ; "<#{RESULT_ELT_TAG} class=\"#{(toggle ? "even" : "odd")}\">#{msg}</#{RESULT_ELT_TAG}>\n" }
+      str += tmp.join("\n") + "\n" if Stats.test_results
+      str + "</#{GROUP_ELT_TAG}>\n"
+    end
+    
+    # test_results returns the test_results hash
+    def test_results
+      Stats.test_results
+    end
+    
+    # reset_tests 
+    def reset_tests
+      Stats.test_results = {}
+    end
+    
+    # removes all failed test results
+    def remove_failed_tests
+      tmp = {}
+      Stats.test_results.each do |host, results|
+        tmp[host] = results.select { |tmp| tmp[0] }
+      end
+      Stats.test_results = tmp
+    end
+
+    def total_failures
+      count = 0
+      Stats.test_results.values.each do |messages|
+        count += messages.select { |msg| !msg[0] }.length
+      end
+      count
+    end
+
+    def total_tests
+      Stats.test_results.values.reduce(0) { |memo, obj| memo += obj.length }
     end
 
-    def fail msg
-      assert_primative false, msg
+    def failure_count(key)
+      return nil unless Stats.test_results[key]
+      failure_messages(key).length
+    end
+
+    def test_count(key)
+      return nil unless Stats.test_results[key]
+      Stats.test_results[key].length
+    end
+
+    def test_messages(key)
+      Stats.test_results[key]
+    end
+    
+    def failure_messages(key)
+      Stats.test_results[key].select { |tmp| !tmp[0] }
     end
 
     # private methods
     private
-    def assert_primative predicate, msg
-      predicate ? test_passed("Passed: #{msg}") : test_failed("Failed: #{msg}")
+    def assert_primative key, predicate, msg
+      predicate ? test_passed(key, "Passed: #{msg}") : test_failed(key, "Failed: #{msg}")
       predicate
     end
     
     # test message handling
-    def test_failed(msg)
-      msg = "<#{WRAP_ELT_TAG} style=\"color:#{RED}\">#{msg}</#{WRAP_ELT_TAG}>"
-      add_failure(msg)
-      add_message(msg)
+    def test_failed(key, msg)
+      add_message(key, false, msg)
     end
     
-    def test_passed(msg)
-      msg = "<#{WRAP_ELT_TAG} style=\"color:#{GREEN}\">#{msg}</#{WRAP_ELT_TAG}>"
-      add_message(msg)
-    end
-
-    def add_failure(msg)
-      Stats.failure_messages ||= []
-      Stats.failure_count ||= 0
-      Stats.failure_messages.push(msg)
-      Stats.failure_count += 1
+    def test_passed(key, msg)
+      add_message(key, true, msg)
     end
 
-    def add_message(msg)
-      Stats.test_messages ||= []
-      Stats.test_count ||= 0
-      Stats.test_messages.push(msg)
-      Stats.test_count += 1
+    def add_message(key, result, msg)
+      Stats.test_results ||= {}
+      Stats.test_results[key] ||= []
+      Stats.test_results[key].push([result, msg])
     end
     
     def self.included(mod)
-      Stats.test_count = 0
-      Stats.failure_count = 0
-      Stats.failure_messages = []
-      Stats.test_messages = []
+      Stats.test_results = {}
     end
   end
 end

data/lib/tdd_deploy/base.rb

@@ -25,7 +25,7 @@ require 'tdd_deploy/deploy_test_methods'
 #
 #  class HostFacilityTest < TddDeploy::Base
 #     def test_for_file
-#       deploy_test_on_all_hosts_as user_id, match_string_or_regx, err_msg { command }
+#       deploy_test_on_hosts_as user_id, match_string_or_regx, err_msg { command }
 #     end
 #     etc
 #   end

data/lib/tdd_deploy/configurator.rb

@@ -0,0 +1,78 @@
+#! /usr/bin/env ruby
+#  -*- ruby-mode -*-
+
+require 'erb'
+require 'tdd_deploy/base'
+
+module TddDeploy
+  # == TddDeployConfigurator
+  #
+  # TddDeployConfigurator is used to create site/host specific configuration files for
+  # sites. The files are defined by templates in subdirectories of the 'site-erb' directory.
+  # At present there are templates in 'site-erb/config' and 'site-erb/site'. Rendered files
+  # are written to corresponding subdirectories of the app. For example, 'site-erb/config/foo.erb'
+  # will produce the file 'app/config/foo'
+  #
+  # files dropped into 'app/site/' are assumed to be executable, so their permissions are
+  # set to 0755
+  class Configurator < TddDeploy::Base
+    # install - reads all the templates in gem-home/site-erb, renders them using the
+    #  current environment context, and writes the renderings to the appropriate
+    #  files in app/sites and app/config
+    def make_configuration_files
+      # create local directory for output files
+      tdd_deploy_configs = File.join Dir.pwd, 'tdd_deploy_configs'
+      Dir.mkdir(tdd_deploy_configs) unless File.exists? tdd_deploy_configs
+
+      ['balance_hosts', 'db_hosts', 'web_hosts'].each do |host_dir|
+        host_path = File.join(tdd_deploy_configs, host_dir)
+        Dir.mkdir(host_path) unless File.exists? host_path
+
+        ['config', 'site'].each do |subdir|
+          subdir_path = File.join(host_path, subdir)
+          Dir.mkdir(subdir_path) unless File.exists? subdir_path
+        end
+      end
+
+      # instantiate all templates and write output to tdd_deploy_configs
+      erb_dir = File.expand_path('../site-erb', __FILE__)
+      Dir.new(erb_dir).each do |host_dir_fname|
+        next if host_dir_fname[0] == '.'
+        
+        host_dir_path = File.join(erb_dir, host_dir_fname)
+        
+        Dir.new(host_dir_path).each do |subdir|
+          next if subdir[0] == '.'
+          
+          subdir_path = File.join(host_dir_path, subdir)
+          
+          Dir.new(subdir_path).each do |fname|
+            file_path = File.join(subdir_path, fname)
+            next unless fname =~ /\.erb$/ && File.exists?(file_path)
+
+            f = File.new(file_path)
+            # '>' removes new-lines from lines ending in %>
+            # template = ERB.new f.read, nil, '>'
+            # '>' removes new-lines from lines starting with <% and ending in %>
+            template = ERB.new f.read, nil, '<>'
+            f.close
+            
+            file_content = template.result(binding)
+            
+            out_fname = File.basename(fname, '.erb')
+
+            Dir.mkdir(subdir_path) unless File.exists? subdir
+            out_path = File.join(tdd_deploy_configs, host_dir_fname, subdir, out_fname)
+
+            f = File.new(out_path, "w")
+            f.write template.result(binding)
+            f.close
+          
+            # make files in 'app/site' executable
+            File.chmod 0755, out_path if subdir == 'site'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tdd_deploy/copy_methods.rb

@@ -0,0 +1,54 @@
+require 'net/ssh'
+require 'net/sftp'
+
+module TddDeploy
+  module RunMethods
+
+    def copy_string_to_remote_file_on_hosts_as userid, host_list, str, dst
+      result = true
+      host_list = [host_list] if host_list.is_a? String
+      host_list.uniq.each do |host|
+        result &= copy_string_to_remote_file_as userid, host, str, dst
+      end
+      result
+    end
+
+    def copy_file_to_remote_on_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|
+        result &= copy_file_to_remote_as userid, host, src, dst
+      end
+      result
+    end
+
+    #single host methods
+    
+    def mkdir_on_remote_as userid, host, dir, options = {}
+      result = nil
+      options[:permissions] = 0755 unless options.include? :permissions
+      Net::SFTP.start(host, userid) do |sftp|
+        result = sftp.mkdir dir, options
+      end
+      result
+    end
+
+    def copy_string_to_remote_file_as userid, host, str, dst
+      result = nil
+      Net::SFTP.start(host, userid) do |sftp|
+        result = sftp.file.open(dst, "w")  do |f|
+          f.write str
+        end
+      end
+      result
+    end
+
+    def copy_file_to_remote_as(userid, host, src, dst)
+      require 'net/sftp'
+      raise ArgumentError.new("file name cannot be empty") if src.empty?
+      raise RuntimeError.new("unable to copy #{src} to #{userid}@#{host}: #{src} not found") unless File.exists? src
+      
+      copy_string_to_remote_file_as userid, host, File.new(src).read, dst
+    end
+  end
+end

data/lib/tdd_deploy/deploy_test_methods.rb

@@ -6,36 +6,34 @@ module TddDeploy
     include TddDeploy::Assertions
     include TddDeploy::RunMethods
     
-    # deploy_test_on_all_hosts runs the command(s) return by '&block' on all hosts in self.hosts
-    # as user 'self.host_admin'.
-    # For each host, an error is declared if EITHER STDOUT does not match 'match_expr_or_str'
-    # OR if the command returns anything on STDERR.
-    # 'match_expr_or_str' can be a Regexp or a string (which will be converted to a Regexp)
-    def deploy_test_on_all_hosts(match_expr_or_str, success_msg, &block)
-      deploy_test_on_all_hosts_as self.host_admin, match_expr_or_str, success_msg, &block
+    def deploy_test_process_running_on_hosts_as(userid, host_list, pid_file_path, success_msg = nil)
+      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
+        "ps -p `cat #{pid_file_path} | awk '{ print $1 ; exit }'`"
+      end
     end
 
-    # deploy_test_on_all_hosts_as runs the command(s) return by '&block' on all hosts in self.hosts
+    def deploy_test_file_exists_on_hosts_as(userid, host_list, path, success_msg = nil)
+      deploy_test_on_hosts_as(userid, host_list, /^\s*success\s*$/, success_msg || "path #{path} should exist") do
+        "test -s #{path} && echo success || echo fail"
+      end
+    end
+
+    # deploy_test_on_hosts_as runs the command(s) return by '&block' on hosts in 'host_list'
     # as the specified user 'userid'.
     # For each host, an error is declared if EITHER STDOUT does not match 'match_expr_or_str'
     # OR if the command returns anything on STDERR.
     # 'match_expr_or_str' can be a Regexp or a string (which will be converted to a Regexp)
-    def deploy_test_on_all_hosts_as(userid, match_expr_or_str, success_msg, &block)
+    def deploy_test_on_hosts_as userid, host_list, match_expr_or_str, success_msg, &block
       ret = true
-      self.hosts.each do |host|
+      host_list = [host_list] if host_list.is_a? String
+      host_list.uniq.each do |host|
         ret &= deploy_test_in_ssh_session_as userid, host, match_expr_or_str, success_msg, &block
       end
       ret
     end
 
-    # deploy_test_in_ssh_session host, match_exp_or_string, success_msg, &block runs the command
-    # returned by 'block.call' on the specified host as user 'self.host_admin'.
-    # 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(host, match, success_msg, &block)
-      deploy_test_in_ssh_session_as(self.host_admin, host, match, success_msg, &block)
-    end
-
     # deploy_test_in_ssh_session_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
@@ -44,19 +42,19 @@ module TddDeploy
       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_as(userid, host, &block)
+      rsp, err_rsp, cmd = run_in_ssh_session_on_host_as(userid, host, &block)
 
       result = err_rsp.nil?
       
       prefix = "user@host: #{userid}@#{host}: #{success_msg}"
 
-      fail "#{prefix}: command generated error data:\n" +
+      fail host, "#{prefix}: command generated error data:\n" +
         "  command: #{cmd}\n stdout: '#{rsp}'\n stderr: '#{err_rsp}'" if err_rsp
 
       if rsp.nil?
-        fail "#{prefix}: stdout is empty for command '#{cmd}'"
+        fail host, "#{prefix}: stdout is empty for command '#{cmd}'"
         result &= false
-      elsif !assert_match match, rsp, prefix
+      elsif !assert_match host, match, rsp, prefix
         result &= false
       end