taste_tester 0.0.13 → 0.0.14

data/lib/taste_tester/commands.rb

@@ -19,6 +19,7 @@ require 'taste_tester/host'
 require 'taste_tester/config'
 require 'taste_tester/client'
 require 'taste_tester/logging'
+require 'taste_tester/exceptions'
 
 module TasteTester
   # Functionality dispatch
@@ -28,6 +29,7 @@ module TasteTester
     def self.start
       server = TasteTester::Server.new
       return if TasteTester::Server.running?
+
       server.start
     end
 
@@ -45,7 +47,12 @@ module TasteTester
       server = TasteTester::Server.new
       if TasteTester::Server.running?
         logger.warn("Local taste-tester server running on port #{server.port}")
-        if server.latest_uploaded_ref
+        if TasteTester::Config.no_repo && server.last_upload_time
+          logger.warn("Last upload time was #{server.last_upload_time}")
+        elsif !TasteTester::Config.no_repo && server.latest_uploaded_ref
+          if server.last_upload_time
+            logger.warn("Last upload time was #{server.last_upload_time}")
+          end
           logger.warn('Latest uploaded revision is ' +
             server.latest_uploaded_ref)
         else
@@ -77,12 +84,16 @@ module TasteTester
       end
       server = TasteTester::Server.new
       unless TasteTester::Config.linkonly
-        repo = BetweenMeals::Repo.get(
-          TasteTester::Config.repo_type,
-          TasteTester::Config.repo,
-          logger,
-        )
-        unless repo.exists?
+        if TasteTester::Config.no_repo
+          repo = nil
+        else
+          repo = BetweenMeals::Repo.get(
+            TasteTester::Config.repo_type,
+            TasteTester::Config.repo,
+            logger,
+          )
+        end
+        if repo && !repo.exists?
           fail "Could not open repo from #{TasteTester::Config.repo}"
         end
       end
@@ -93,12 +104,11 @@ module TasteTester
       tested_hosts = []
       hosts.each do |hostname|
         host = TasteTester::Host.new(hostname, server)
-        if host.in_test?
-          username = host.who_is_testing
-          logger.error("User #{username} is already testing on #{hostname}")
-        else
+        begin
           host.test
           tested_hosts << hostname
+        rescue TasteTester::Exceptions::AlreadyTestingError => e
+          logger.error("User #{e.username} is already testing on #{hostname}")
         end
       end
       unless TasteTester::Config.skip_post_test_hook ||
@@ -106,6 +116,24 @@ module TasteTester
         TasteTester::Hooks.post_test(TasteTester::Config.dryrun, repo,
                                      tested_hosts)
       end
+      # Strictly: hosts and tested_hosts should be sets to eliminate variance in
+      # order or duplicates. The exact comparison works here because we're
+      # building tested_hosts from hosts directly.
+      if tested_hosts == hosts
+        # No exceptions, complete success: every host listed is now configured
+        # to use our chef-zero instance.
+        exit(0)
+      end
+      if tested_hosts.empty?
+        # All requested hosts are being tested by another user. We didn't change
+        # their configuration.
+        exit(3)
+      end
+      # Otherwise, we got a mix of success and failure due to being tested by
+      # another user. We'll be pessemistic and return an error because the
+      # intent to taste test the complete list was not successful.
+      # code.
+      exit(2)
     end
 
     def self.untest
@@ -149,7 +177,7 @@ module TasteTester
 
     def self.upload
       server = TasteTester::Server.new
-      # On a fore-upload rather than try to clean up whatever's on the server
+      # On a force-upload rather than try to clean up whatever's on the server
       # we'll restart chef-zero which will clear everything and do a full
       # upload
       if TasteTester::Config.force_upload
@@ -182,5 +210,165 @@ module TasteTester
       logger.error(exception.backtrace.join("\n"))
       exit 1
     end
+
+    def self.impact
+      # Use the repository specified in config.rb to calculate the changes
+      # that may affect Chef. These changes will be further analyzed to
+      # determine specific roles which may change due to modifed dependencies.
+      repo = BetweenMeals::Repo.get(
+        TasteTester::Config.repo_type,
+        TasteTester::Config.repo,
+        logger,
+      )
+      if repo && !repo.exists?
+        fail "Could not open repo from #{TasteTester::Config.repo}"
+      end
+
+      changes = _find_changeset(repo)
+
+      # Use Knife (or custom logic) to check the dependencies of each role
+      # against the list of changes. `impacted_roles` will contian the set
+      # of roles with direct or indirect (dependency) modifications.
+      impacted_roles = TasteTester::Hooks.impact_find_roles(changes)
+      impacted_roles ||= _find_roles(changes)
+
+      # Do any post processing required on the list of impacted roles, such
+      # as looking up hostnames associated with each role.
+      final_impact = TasteTester::Hooks.post_impact(impacted_roles)
+      final_impact ||= impacted_roles
+
+      # Print the calculated impact. If a print hook is defined that
+      # returns true, then the default print function is skipped.
+      unless TasteTester::Hooks.print_impact(final_impact)
+        _print_impact(final_impact)
+      end
+    end
+
+    def self._find_changeset(repo)
+      # We want to compare changes in the current directory (working set) with
+      # the "most recent" commit in the VCS. For SVN, this will be the latest
+      # commit on the checked out repository (i.e. 'trunk'). Git/Hg may have
+      # different tags or labels assigned to the master branch, (i.e. 'master',
+      # 'stable', etc.) and should be configured if different than the default.
+      start_ref = case repo
+                  when BetweenMeals::Repo::Svn
+                    repo.latest_revision
+                  when BetweenMeals::Repo::Git
+                    TasteTester::Config.vcs_start_ref_git
+                  when BetweenMeals::Repo::Hg
+                    TasteTester::Config.vcs_start_ref_hg
+                  end
+      end_ref = TasteTester::Config.vcs_end_ref
+
+      changeset = BetweenMeals::Changeset.new(
+        logger,
+        repo,
+        start_ref,
+        end_ref,
+        {
+          :cookbook_dirs =>
+            TasteTester::Config.relative_cookbook_dirs,
+          :role_dir =>
+            TasteTester::Config.relative_role_dir,
+          :databag_dir =>
+            TasteTester::Config.relative_databag_dir,
+        },
+        @track_symlinks,
+      )
+
+      return changeset
+    end
+
+    def self._find_roles(changes)
+      if TasteTester::Config.relative_cookbook_dirs.length > 1
+        logger.error('Knife deps does not support multiple cookbook paths.')
+        logger.error('Please flatten the cookbooks into a single directory' +
+                     ' or override the impact_find_roles function.')
+        exit(1)
+      end
+
+      cookbooks = Set.new(changes.cookbooks)
+      roles = Set.new(changes.roles)
+      databags = Set.new(changes.databags)
+
+      if cookbooks.empty? && roles.empty?
+        logger.warn('No cookbooks or roles have been modified.')
+        return Set.new
+      end
+
+      unless cookbooks.empty?
+        logger.info('Modified Cookbooks:')
+        cookbooks.each { |cb| logger.info("\t#{cb}") }
+      end
+      unless roles.empty?
+        logger.info('Modified Roles:')
+        roles.each { |r| logger.info("\t#{r}") }
+      end
+      unless databags.empty?
+        logger.info('Modified Databags:')
+        databags.each { |db| logger.info("\t#{db}") }
+      end
+
+      # Use Knife to list the dependecies for each role in the roles directory.
+      # This creates a recursive tree structure that is then searched for
+      # instances of modified cookbooks. This can be slow since it must read
+      # every line of the Knife output, then search all roles for dependencies.
+      # If you have a custom way to calculate these reverse dependencies, this
+      # is the part you would replace.
+      logger.info('Finding dependencies (this may take a minute or two)...')
+      knife = Mixlib::ShellOut.new(
+        "knife deps /#{TasteTester::Config.role_dir}/*.rb" +
+        " --config #{TasteTester::Config.knife_config}" +
+        " --chef-repo-path #{TasteTester::Config.absolute_base_dir}" +
+        ' --tree --recurse',
+      )
+      knife.run_command
+      knife.error!
+
+      # Collapse the output from Knife into a hash structure that maps roles
+      # to the set of their dependencies. This will ignore duplicates in the
+      # Knife output, but must still process each line.
+      logger.info('Processing Dependencies...')
+      deps_hash = {}
+      curr_role = nil
+
+      knife.stdout.each_line do |line|
+        elem = line.rstrip
+        if elem.length == elem.lstrip.length
+          curr_role = elem
+          deps_hash[curr_role] = Set.new
+        else
+          deps_hash[curr_role].add(File.basename(elem, File.extname(elem)))
+        end
+      end
+
+      # Now we can search for modified dependencies by iterating over each
+      # role and checking the hash created earlier. Roles that have been
+      # modified directly are automatically included in the impacted set.
+      impacted_roles = Set.new(roles.map(&:name))
+      deps_hash.each do |role, deplist|
+        cookbooks.each do |cb|
+          if deplist.include?(cb.name)
+            impacted_roles.add(role)
+            logger.info("\tFound dependency: #{role} --> #{cb.name}")
+            break
+          end
+        end
+      end
+
+      return impacted_roles
+    end
+
+    def self._print_impact(final_impact)
+      if TasteTester::Config.json
+        puts JSON.pretty_generate(final_impact.to_a)
+      elsif final_impact.empty?
+        logger.warn('No impacted roles were found.')
+      else
+        logger.warn('The following roles have modified dependencies.' +
+                    ' Please test a host in each of these roles.')
+        final_impact.each { |r| logger.warn("\t#{r}") }
+      end
+    end
   end
 end

data/lib/taste_tester/config.rb

@@ -37,6 +37,7 @@ module TasteTester
     config_file '/etc/taste-tester-config.rb'
     plugin_path nil
     chef_zero_path nil
+    bundle false
     verbosity Logger::WARN
     timestamp false
     user 'root'
@@ -51,6 +52,7 @@ module TasteTester
     timestamp_file '/etc/chef/test_timestamp'
     use_ssh_tunnels false
     ssh_command 'ssh'
+    ssh_connect_timeout 5
     use_ssl true
     chef_zero_logging true
     chef_config_path '/etc/chef'
@@ -58,6 +60,16 @@ module TasteTester
     my_hostname nil
     track_symlinks false
     transport 'ssh'
+    no_repo false
+    json false
+
+    # Start/End refs for calculating changes in the repo.
+    #  - start_ref should be the "master" commit of the repository
+    #  - end_ref should be nil to compare with the working set,
+    #    or something like '.' to compare with the most recent commit
+    vcs_start_ref_git 'origin/HEAD'
+    vcs_start_ref_hg 'master'
+    vcs_end_ref nil
 
     skip_pre_upload_hook false
     skip_post_upload_hook false
@@ -97,6 +109,10 @@ module TasteTester
       end
     end
 
+    def self.absolute_base_dir
+      File.join(repo, base_dir)
+    end
+
     def self.chef_port
       require 'taste_tester/state'
       port_range = (
@@ -116,11 +132,8 @@ module TasteTester
     end
 
     def self.testing_end_time
-      if TasteTester::Config.testing_until
-        TasteTester::Config.testing_until
-      else
+      TasteTester::Config.testing_until ||
         Time.now + TasteTester::Config.testing_time
-      end
     end
   end
 end

data/lib/taste_tester/exceptions.rb

@@ -22,5 +22,12 @@ module TasteTester
     end
     class NoOpError < StandardError
     end
+    class AlreadyTestingError < StandardError
+      attr_reader :username
+
+      def initialize(username)
+        @username = username
+      end
+    end
   end
 end

data/lib/taste_tester/hooks.rb

@@ -48,6 +48,21 @@ module TasteTester
     # Additional checks you want to do on the repo
     def self.repo_checks(_dryrun, _repo); end
 
+    # Find the set of roles dependent on the changed files.
+    # If returning something other than a set of roles, post_impact and/or
+    # print_impact should be specified to handle the output.
+    def self.impact_find_roles(_changes); end
+
+    # Do stuff after we find impacted roles
+    # This should return a Set object with the final impact. To return more
+    # complex data, you must also provide a print_impact function which returns
+    # true to override the default output.
+    def self.post_impact(_impacted_roles); end
+
+    # Customized the printed output of impact
+    # If this method returns true, the default output will not be printed.
+    def self.print_impact(_final_impact); end
+
     def self.get(file)
       path = File.expand_path(file)
       logger.warn("Loading plugin at #{path}")

data/lib/taste_tester/host.rb

@@ -23,12 +23,16 @@ require 'taste_tester/ssh'
 require 'taste_tester/noop'
 require 'taste_tester/locallink'
 require 'taste_tester/tunnel'
+require 'taste_tester/exceptions'
 
 module TasteTester
   # Manage state of the remote node
   class Host
     include TasteTester::Logging
 
+    TASTE_TESTER_CONFIG = 'client-taste-tester.rb'.freeze
+    USER_PREAMBLE = '# TasteTester by '.freeze
+
     attr_reader :name
 
     def initialize(name, server)
@@ -94,22 +98,45 @@ module TasteTester
         @tunnel.run
       end
 
-      @serialized_config = Base64.encode64(config).delete("\n")
+      serialized_config = Base64.encode64(config).delete("\n")
 
       # Then setup the testing
       transport = get_transport
 
+      # see if someone else is taste-testing
+      transport << we_testing
+
       transport << 'logger -t taste-tester Moving server into taste-tester' +
         " for #{@user}"
       transport << touchcmd
-      transport << "/bin/echo -n '#{@serialized_config}' | base64 --decode" +
-        " > #{TasteTester::Config.chef_config_path}/client-taste-tester.rb"
-      transport << "rm -vf #{TasteTester::Config.chef_config_path}/" +
-        TasteTester::Config.chef_config
-      transport << "( ln -vs #{TasteTester::Config.chef_config_path}" +
-        "/client-taste-tester.rb #{TasteTester::Config.chef_config_path}/" +
+      # shell redirection is also racy, so make a temporary file first
+      transport << "tmpconf=$(mktemp #{TasteTester::Config.chef_config_path}/" +
+        "#{TASTE_TESTER_CONFIG}.TMPXXXXXX)"
+      transport << "/bin/echo -n \"#{serialized_config}\" | base64 --decode" +
+        ' > "${tmpconf}"'
+      # then rename it to replace any existing file
+      transport << 'mv -f "${tmpconf}" ' +
+        "#{TasteTester::Config.chef_config_path}/#{TASTE_TESTER_CONFIG}"
+      transport << "( ln -vsf #{TasteTester::Config.chef_config_path}" +
+        "/#{TASTE_TESTER_CONFIG} #{TasteTester::Config.chef_config_path}/" +
         "#{TasteTester::Config.chef_config}; true )"
-      transport.run!
+
+      # look again to see if someone else is taste-testing. This is where
+      # we work out if we won or lost a race with another user.
+      transport << we_testing
+
+      transport.run
+
+      case transport.status
+      when 0
+        # no problem, keep going.
+        nil
+      when 42
+        fail TasteTester::Exceptions::AlreadyTestingError,
+             transport.output.chomp
+      else
+        transport.error!
+      end
 
       # Then run any other stuff they wanted
       cmds = TasteTester::Hooks.test_remote_cmds(
@@ -117,7 +144,7 @@ module TasteTester
         @name,
       )
 
-      if cmds && cmds.any?
+      if cmds&.any?
         transport = get_transport
         cmds.each { |c| transport << c }
         transport.run!
@@ -132,15 +159,12 @@ module TasteTester
       end
       config_prod = TasteTester::Config.chef_config.split('.').join('-prod.')
       [
-        "rm -vf #{TasteTester::Config.chef_config_path}/" +
-          TasteTester::Config.chef_config,
-        "rm -vf #{TasteTester::Config.chef_config_path}/client-taste-tester.rb",
-        "ln -vs #{TasteTester::Config.chef_config_path}/#{config_prod} " +
+        "ln -vsf #{TasteTester::Config.chef_config_path}/#{config_prod} " +
           "#{TasteTester::Config.chef_config_path}/" +
           TasteTester::Config.chef_config,
-        "rm -vf #{TasteTester::Config.chef_config_path}/client.pem",
-        "ln -vs #{TasteTester::Config.chef_config_path}/client-prod.pem " +
+        "ln -vsf #{TasteTester::Config.chef_config_path}/client-prod.pem " +
           "#{TasteTester::Config.chef_config_path}/client.pem",
+        "rm -vf #{TasteTester::Config.chef_config_path}/#{TASTE_TESTER_CONFIG}",
         "rm -vf #{TasteTester::Config.timestamp_file}",
         'logger -t taste-tester Returning server to production',
       ].each do |cmd|
@@ -149,43 +173,25 @@ module TasteTester
       transport.run!
     end
 
-    def who_is_testing
-      transport = get_transport
-      transport << 'grep "^# TasteTester by"' +
-        " #{TasteTester::Config.chef_config_path}/" +
-        TasteTester::Config.chef_config
-      output = transport.run
-      if output.first.zero?
-        user = output.last.match(/# TasteTester by (.*)$/)
-        if user
-          return user[1]
-        end
-      end
-
-      # Legacy FB stuff, remove after migration. Safe for everyone else.
-      transport = get_transport
-      transport << "file #{TasteTester::Config.chef_config_path}/" +
+    def we_testing
+      config_file = "#{TasteTester::Config.chef_config_path}/" +
         TasteTester::Config.chef_config
-      output = transport.run
-      if output.first.zero?
-        user = output.last.match(/client-(.*)-(taste-tester|test).rb/)
-        if user
-          return user[1]
-        end
-      end
-
-      return nil
-    end
-
-    def in_test?
-      transport = get_transport
-      transport << "test -f #{TasteTester::Config.timestamp_file}"
-      if transport.run.first.zero? && who_is_testing &&
-          who_is_testing != ENV['USER']
-        true
-      else
-        false
-      end
+      # Look for signature of TasteTester
+      # 1. Look for USER_PREAMBLE line prefix
+      # 2. See if user is us, or someone else
+      # 3. if someone else is testing: emit username, exit with code 42 which
+      #    short circuits the test verb
+      # This is written as a squiggly heredoc so the indentation of the awk is
+      # preserved. Later we remove the newlines to make it a bit easier to read.
+      shellcode = <<~ENDOFSHELLCODE
+        awk "\\$0 ~ /^#{USER_PREAMBLE}/{
+          if (\\$NF != \\"#{@user}\\"){
+            print \\$NF;
+            exit 42
+          }
+        }" #{config_file}
+      ENDOFSHELLCODE
+      shellcode.delete("\n")
     end
 
     def keeptesting
@@ -220,40 +226,90 @@ module TasteTester
       if TasteTester::Config.use_ssh_tunnels
         url = "#{scheme}://localhost:#{@tunnel.port}"
       else
-        url = "#{scheme}://#{@server.host}"
+        url = +"#{scheme}://#{@server.host}"
         url << ":#{TasteTester::State.port}" if TasteTester::State.port
       end
-      # rubocop:disable Metrics/LineLength
-      ttconfig = <<-EOS
-# TasteTester by #{@user}
-# Prevent people from screwing up their permissions
-if Process.euid != 0
-  puts 'Please run chef as root!'
-  Process.exit!
-end
+      ttconfig = <<~ENDOFSCRIPT
+        #{USER_PREAMBLE}#{@user}
+        # Prevent people from screwing up their permissions
+        if Process.euid != 0
+          puts 'Please run chef as root!'
+          Process.exit!
+        end
 
-log_level :info
-log_location STDOUT
-chef_server_url '#{url}'
-ssl_verify_mode :verify_none
-ohai.plugin_path << '#{TasteTester::Config.chef_config_path}/ohai_plugins'
+        log_level :info
+        log_location STDOUT
+        ssl_verify_mode :verify_none
+        ohai.plugin_path << File.join('#{TasteTester::Config.chef_config_path}', 'ohai_plugins')
+      ENDOFSCRIPT
 
-EOS
-      # rubocop:enable Metrics/LineLength
+      if TasteTester::Config.bundle
+        ttconfig += <<~ENDOFSCRIPT
+          taste_tester_dest = File.join(Dir.tmpdir, 'taste-tester')
+          puts 'INFO: Downloading bundle from #{url}...'
+          FileUtils.rmtree(taste_tester_dest)
+          FileUtils.mkpath(taste_tester_dest)
+          FileUtils.touch(File.join(taste_tester_dest, 'chefignore'))
+          uri = URI('#{url}/file_store/tt.tgz')
+          Net::HTTP.start(
+            uri.host,
+            uri.port,
+            :use_ssl => #{TasteTester::Config.use_ssl},
+            # we expect self signed certificates
+            :verify_mode => OpenSSL::SSL::VERIFY_NONE,
+          ) do |http|
+            http.request_get(uri) do |response|
+              # the use of stringIO means we are buffering the entire file in
+              # memory. This isn't very efficient, but it should work for
+              # most practical cases.
+              stream = Zlib::GzipReader.new(StringIO.new(response.body))
+              Gem::Package::TarReader.new(stream).each do |e|
+                dest = File.join(taste_tester_dest, e.full_name)
+                FileUtils.mkpath(File.dirname(dest))
+                if e.symlink?
+                  File.symlink(e.header.linkname, dest)
+                else
+                  File.open(dest, 'wb+') do |f|
+                    # https://github.com/rubygems/rubygems/pull/2303
+                    # IO.copy_stream(e, f)
+                    # workaround:
+                    f.write(e.read)
+                  end
+                end
+              end
+            end
+          end
+          puts 'INFO: Download complete'
+          solo true
+          local_mode true
+        ENDOFSCRIPT
+      else
+        ttconfig += <<~ENDOFSCRIPT
+          chef_server_url '#{url}'
+        ENDOFSCRIPT
+      end
 
       extra = TasteTester::Hooks.test_remote_client_rb_extra_code(@name)
       if extra
-        ttconfig += <<-EOS
-# Begin user-hook specified code
-        #{extra}
-# End user-hook secified code
+        ttconfig += <<~ENDOFSCRIPT
+          # Begin user-hook specified code
+                  #{extra}
+          # End user-hook secified code
 
-        EOS
+        ENDOFSCRIPT
       end
 
-      ttconfig += <<-EOS
-puts 'INFO: Running on #{@name} in taste-tester by #{@user}'
-      EOS
+      ttconfig += <<~ENDOFSCRIPT
+        puts 'INFO: Running on #{@name} in taste-tester by #{@user}'
+      ENDOFSCRIPT
+
+      if TasteTester::Config.bundle
+        # This is last in the configuration file because it needs to override
+        # any values in test_remote_client_rb_extra_code
+        ttconfig += <<~ENDOFSCRIPT
+          chef_repo_path taste_tester_dest
+        ENDOFSCRIPT
+      end
       return ttconfig
     end
   end

data/lib/taste_tester/locallink.rb

@@ -22,7 +22,7 @@ module TasteTester
     include TasteTester::Logging
     include BetweenMeals::Util
 
-    attr_reader :output
+    attr_reader :output, :status
 
     def initialize
       @host = 'localhost'
@@ -43,7 +43,11 @@ module TasteTester
       @status, @output = exec!(cmd, logger)
     rescue StandardError => e
       logger.error(e.message)
-      raise TasteTester::Exceptions::LocalLinkError
+      error!
+    end
+
+    def error!
+      fail TasteTester::Exceptions::LocalLinkError
     end
 
     private

data/lib/taste_tester/logging.rb

@@ -35,8 +35,8 @@ module TasteTester
       @logger ||= Logger.new(STDOUT)
     end
 
-    def self.formatterproc=(p)
-      @@formatter_proc = p
+    def self.formatterproc=(process)
+      @@formatter_proc = process
     end
 
     def self.use_log_formatter=(use_log_formatter)
@@ -49,6 +49,7 @@ module TasteTester
 
     def formatter
       return @@formatter_proc if @@formatter_proc
+
       if @@use_log_formatter
         proc do |severity, datetime, _progname, msg|
           if severity == 'ERROR'
@@ -58,7 +59,7 @@ module TasteTester
         end
       else
         proc do |severity, _datetime, _progname, msg|
-          msg.to_s.prepend("#{severity}: ") unless severity == 'WARN'
+          msg.dup.to_s.prepend("#{severity}: ") unless severity == 'WARN'
           if severity == 'ERROR'
             msg = msg.to_s.red
           end