jstorimer-deep-test 0.2.0 → 1.0.0

data/lib/deep_test/distributed/establish_beachhead.rb

@@ -1,19 +0,0 @@
-require File.dirname(__FILE__) + "/../../deep_test"
-options = DeepTest::Options.from_command_line(ENV['OPTIONS'])
-ENV['DEEP_TEST_LOG_LEVEL'] = options.environment_log_level
-options.ssh_client_connection_info = DeepTest::Distributed::SshClientConnectionInfo.new
-
-DeepTest.logger.debug { "mirror establish_beachhead for #{options.origin_hostname}" }
-
-STDIN.close
-
-beachhead_port = DeepTest::Distributed::Beachhead.new(
-  File.join(options.mirror_path, File.basename(options.sync_options[:source])), 
-  options
-).daemonize
-
-puts "Beachhead port: #{beachhead_port}"
-$stdout.flush
-
-exit!(0)
-

data/lib/deep_test/distributed/landing_fleet.rb

@@ -1,30 +0,0 @@
-module DeepTest
-  module Distributed
-    class LandingFleet
-      def initialize(options, slaves)
-        DeepTest.logger.debug { "LandingFleet#initialize #{slaves.length} slaves" }
-        @slave_controller = DispatchController.new(options, slaves)
-      end
-
-      def establish_beachhead(options)
-        DeepTest.logger.debug { "dispatch establish_beachhead for #{options.origin_hostname}" }
-        @slave_controller.dispatch :establish_beachhead, options
-      end
-
-      def push_code(options)
-        DeepTest.logger.debug { "dispatch push_code for #{options.origin_hostname}" }
-        @slave_controller.dispatch :push_code, options
-      end
-
-      def load_files(files)
-        DeepTest.logger.debug { "dispatch load_files" }
-        @slave_controller.dispatch :load_files, files
-      end
-
-      def deploy_agents
-        DeepTest.logger.debug { "dispatch deploy_agents" }
-        @slave_controller.dispatch :deploy_agents
-      end
-    end
-  end
-end

data/lib/deep_test/distributed/landing_ship.rb

@@ -1,60 +0,0 @@
-module DeepTest
-  module Distributed
-    class LandingShip
-      def initialize(config)
-        @config = config
-      end
-
-      def push_code(options)
-        RSync.push(@config[:address], options.sync_options, options.mirror_path)
-      end
-
-      def establish_beachhead(options)
-        command  = "#{ssh_command(options)} '#{spawn_command(options)}' 2>&1"
-        DeepTest.logger.debug { "Establishing Beachhead: #{command}" }
-        
-        output = `#{command}`
-        output.each do |line|
-          if DeepTest.logger.level == Logger::DEBUG
-            puts output
-          end
-          if line =~ /Beachhead port: (.+)/
-            @wire = Telegraph::Wire.connect(@config[:address], $1.to_i)
-          end
-        end
-        raise "LandingShip unable to establish Beachhead.  Output from #{@config[:address]} was:\n#{output}" unless @wire
-      end
-
-      def load_files(files)
-        @wire.send_message Beachhead::LoadFiles.new(files)
-      end
-
-      def deploy_agents
-        @wire.send_message Beachhead::DeployAgents
-        begin
-          message = @wire.next_message :timeout => 1
-          raise "Unexpected message from Beachhead: #{message.inspect}" unless message.body == Beachhead::Done
-        rescue Telegraph::NoMessageAvailable
-          retry
-        end
-      end
-
-      def ssh_command(options)
-        username_option = if options.sync_options[:username]
-                            " -l #{options.sync_options[:username]}"
-                          else
-                            ""
-                          end
-
-        "ssh -4 #{@config[:address]}#{username_option}"
-      end
-
-      def spawn_command(options)
-        "#{ShellEnvironment.like_login} && " + 
-        "cd #{options.mirror_path} && " + 
-        "OPTIONS=#{options.to_command_line} " + 
-        "ruby lib/deep_test/distributed/establish_beachhead.rb" 
-      end
-    end
-  end
-end

data/lib/deep_test/distributed/remote_deployment.rb

@@ -1,56 +0,0 @@
-module DeepTest
-  module Distributed
-    class RemoteDeployment
-      def initialize(options, landing_fleet, failover_deployment)
-        @failover_deployment = failover_deployment
-        @options = options
-        @landing_fleet = landing_fleet
-      end
-
-      def load_files(filelist)
-        # load one file before calling listeners to make sure environment has
-        # been initialized as expected
-        #
-        load filelist.first
-        @options.new_listener_list.before_sync
-
-        t = Thread.new do
-          @landing_fleet.push_code(@options)
-          @landing_fleet.establish_beachhead(@options)
-          @landing_fleet.load_files filelist
-        end
-
-        filelist[1..-1].each {|f| load f}
-
-        begin
-          t.join
-        rescue => e
-          # The failover here doesn't invoke load_files on the failover_deployment
-          # because it will be a LocalDeployment, which forks from the current 
-          # process.  The fact that we depend in this here is damp...
-          #
-          fail_over("load_files", e)
-        end
-      end
-
-      def deploy_agents
-        DeepTest.logger.debug { "RemoteDeployment deploying agents with #{@landing_fleet}" }
-        @landing_fleet.deploy_agents
-      rescue => e
-        raise if failed_over?
-        fail_over("deploy_agents", e)
-        retry
-      end
-
-      def fail_over(method, exception)
-        DeepTest.logger.debug { "RemoteDeployment failing over on #{method}." }
-        @options.ui_instance.distributed_failover_to_local(method, exception)
-        @landing_fleet = @failover_deployment
-      end
-
-      def failed_over?
-        @landing_fleet == @failover_deployment
-      end
-    end
-  end
-end

data/lib/deep_test/distributed/shell_environment.rb

@@ -1,50 +0,0 @@
-module DeepTest
-  module Distributed
-    class ShellEnvironment
-      def self.like_login
-        login_env = new
-        login_env.include_first '/etc/profile'
-        login_env.include_first '~/.profile', '~/.bash_profile',  '~/.bashrc'
-        login_env
-      end
-
-      def initialize
-        @source_file_lists = []
-      end
-
-      def include_first(*filenames)
-        source_file_lists << SourceFileList.new(filenames)
-      end
-
-      def to_s
-        source_file_lists.join(" && ")
-      end
-
-      def ==(other)
-        source_file_lists == other.source_file_lists
-      end
-
-      attr_reader :source_file_lists
-      protected :source_file_lists
-
-      class SourceFileList
-        def initialize(filenames)
-          @filenames = filenames
-        end
-
-        def to_s
-          "if" + 
-          filenames.map {|f| " [[ -f #{f} ]]; then . #{f}; "}.join("elif") +
-          "fi"
-        end
-
-        def ==(other)
-          filenames == other.filenames
-        end
-
-        attr_reader :filenames
-        protected :filenames
-      end
-    end
-  end
-end

data/lib/deep_test/distributed/ssh_client_connection_info.rb

@@ -1,14 +0,0 @@
-module DeepTest
-  module Distributed
-    class SshClientConnectionInfo
-      attr_reader :address
-
-      def initialize
-        raise "SSH_CLIENT environment variable not set" unless ENV['SSH_CLIENT']
-        ENV['SSH_CLIENT'] =~ /^(.+) \d+ \d+$/
-        raise "Unable to extract address from SSH_CLIENT (#{ENV['SSH_CLIENT']})" unless $1
-        @address = $1
-      end
-    end
-  end
-end

data/lib/deep_test/failure_message.rb

@@ -1,19 +0,0 @@
-module DeepTest
-  module FailureMessage
-    def self.show(title, message, width = 70)
-      lines = [" #{title} ".center(width, '*')]
-      message.each do |line|
-        lines << "* #{line.strip}".ljust(width - 1) + "*"
-      end
-      lines <<  "*" * width
-      string = lines.join("\n")
-      begin
-        puts string
-      rescue
-        IO.new(2) do |err|
-          err.puts string
-        end
-      end
-    end
-  end
-end

data/lib/deep_test/lib_root.rb

@@ -1,4 +0,0 @@
-module DeepTest
-  LIB_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '/..')) unless defined?(DeepTest::LIB_ROOT)
-end
-

data/lib/deep_test/local_deployment.rb

@@ -1,46 +0,0 @@
-module DeepTest
-  class LocalDeployment
-    attr_reader :warlock
-
-    def initialize(options, agent_class = DeepTest::Agent)
-      @options = options
-      @agent_class = agent_class
-    end
-
-    def warlock
-      @warlock ||= Warlock.new @options
-    end
-
-    def load_files(files)
-      files.each {|f| load f}
-    end
-
-    def deploy_agents
-      DeepTest.logger.debug { "Deploying #{number_of_agents} #{@agent_class}s" }
-      wait_for_connect_threads = []
-      each_agent do |agent_num|
-        stream_from_child_process, stream_to_parent_process = IO.pipe
-        warlock.start "agent #{agent_num}", @agent_class.new(agent_num, @options, @options.new_listener_list), 
-                      stream_from_child_process, stream_to_parent_process
-        wait_for_connect_threads << Thread.new do
-          stream_to_parent_process.close
-          message = stream_from_child_process.read
-          stream_from_child_process.close
-          raise "Agent was not able to connect: #{message}" unless message == "Connected\n"
-        end
-      end        
-
-      wait_for_connect_threads.each { |t| t.join }
-    end
-
-    def number_of_agents
-      @options.number_of_agents
-    end
-
-    private
-
-    def each_agent
-      number_of_agents.to_i.times { |agent_num| yield agent_num }
-    end
-  end
-end

data/lib/deep_test/main.rb

@@ -1,41 +0,0 @@
-module DeepTest
-  class Main
-    attr_reader :central_command
-
-    def initialize(options, deployment, runner, central_command = nil)
-      @options = options
-      @deployment = deployment
-      @runner = runner
-      @central_command = central_command || CentralCommand.start(options)
-    end
-
-    def load_files(files)
-      @deployment.load_files files
-    end
-    
-    def run(exit_when_done = true)
-      passed = false
-
-      begin
-        @options.new_listener_list.before_starting_agents
-        @deployment.deploy_agents
-        begin
-          DeepTest.logger.debug { "Main: About to process work units (#{$$})" }
-          passed = @runner.process_work_units(central_command)
-        ensure
-          shutdown
-        end
-      ensure
-        DeepTest.logger.debug { "Main: Stopping CentralCommand" }
-        @central_command.stop
-      end
-
-      Kernel.exit(passed ? 0 : 1) if exit_when_done
-    end
-
-    def shutdown
-      DeepTest.logger.debug { "Main: Shutting Down" }
-      @central_command.done_with_work
-    end
-  end
-end

data/lib/deep_test/metrics/data.rb

@@ -1,34 +0,0 @@
-module DeepTest
-  module Metrics
-    class Data
-      def initialize
-        @measurements_by_category = {}
-      end
-
-      def add(measurement)
-        categories = @measurements_by_category[measurement.category] ||= []
-        categories << measurement
-      end
-
-      def summary
-        summary = []
-        summary << "Metrics Data\n"
-        summary << "------------\n"
-
-        @measurements_by_category.keys.sort.map do |category|
-          measurements = @measurements_by_category[category]
-          units = measurements.first.units
-          summary << "#{category}: #{Measurement.average(measurements)} avg / #{Measurement.total(measurements)} total #{units}\n"
-        end
-
-        summary.join
-      end
-
-      def save(file)
-        File.open(file, "w") do |f|
-          f << summary
-        end
-      end
-    end
-  end
-end

data/lib/deep_test/metrics/measurement.rb

@@ -1,39 +0,0 @@
-module DeepTest
-  module Metrics
-    class Measurement
-      attr_reader :category, :value, :units
-
-      def initialize(category, value, units)
-        @category = category
-        @value = value
-        @units = units
-      end
-
-      def self.average(measurements)
-        total(measurements).to_f / measurements.size
-      end
-
-      def self.total(measurements)
-        measurements.inject(0) { |sum, m| sum + m.value }
-      end
-
-      def self.of_time_taken(category)
-        start = Time.now
-        yield
-        Measurement.new category, Time.now - start, "seconds"
-      end
-
-      def self.send_home(category, wire, options)
-        result = nil
-        measurement = of_time_taken(category) { result = yield }
-        if options.gathering_metrics?
-          begin
-            wire.send_message measurement
-          rescue Telegraph::LineDead
-          end
-        end
-        result
-      end
-    end
-  end
-end

data/lib/deep_test/proxy_io.rb

@@ -1,77 +0,0 @@
-module DeepTest
-  class ProxyIO < StringIO
-    def initialize(output_module, wire)
-      @output_module = output_module
-      @wire = wire
-      super("")
-    end
-
-    def write(*args)
-      super
-      @wire.send_message @output_module::Output.new(string)
-      self.string = ""
-    end
-
-    def flush
-      @wire.send_message @output_module::Flush.new
-    end
-
-    def self.replace_stdout_stderr!(wire)
-      old_stdout_const, old_stdout_global = STDOUT, $stdout
-      old_stderr_const, old_stderr_global = STDERR, $stderr
-
-      supress_warnings { Object.const_set :STDOUT, ProxyIO.new(Stdout, wire) }
-      $stdout = STDOUT
-
-      supress_warnings { Object.const_set :STDERR, ProxyIO.new(Stderr, wire) }
-      $stderr = STDERR
-
-      DeepTest.logger = nil
-
-      yield
-    ensure
-      $stdout = old_stdout_global
-      supress_warnings { Object.const_set :STDOUT, old_stdout_const }
-
-      $stderr = old_stderr_global
-      supress_warnings { Object.const_set :STDERR, old_stderr_const }
-    end
-
-    def self.supress_warnings
-      old_verbose, $VERBOSE = $VERBOSE, nil
-      yield
-    ensure
-      $VERBOSE = old_verbose
-    end
-
-    class AbstractOutput
-      include CentralCommand::Operation
-      attr_reader :s
-      def initialize(s); @s = s; end
-      def execute; stream.write s; end
-      def ==(other); self.class == other.class && s == other.s; end
-    end
-
-    module Stdout
-      class Output < AbstractOutput
-        def stream; $stdout; end
-      end
-
-      class Flush
-        include CentralCommand::Operation
-        def execute; $stdout.flush; end
-      end
-    end
-
-    module Stderr
-      class Output < AbstractOutput
-        def stream; $stderr; end
-      end
-
-      class Flush
-        include CentralCommand::Operation
-        def execute; $stderr.flush; end
-      end
-    end
-  end
-end