taste_tester 0.0.12 → 0.0.17

data/lib/taste_tester/commands.rb

@@ -14,12 +14,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# rubocop:disable UnusedBlockArgument, UnusedMethodArgument
 require 'taste_tester/server'
 require 'taste_tester/host'
 require 'taste_tester/config'
 require 'taste_tester/client'
 require 'taste_tester/logging'
+require 'taste_tester/exceptions'
 
 module TasteTester
   # Functionality dispatch
@@ -29,6 +29,7 @@ module TasteTester
     def self.start
       server = TasteTester::Server.new
       return if TasteTester::Server.running?
+
       server.start
     end
 
@@ -46,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
@@ -78,13 +84,17 @@ 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?
-          raise "Could not open repo from #{TasteTester::Config.repo}"
+        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
       unless TasteTester::Config.skip_pre_test_hook ||
@@ -94,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 ||
@@ -107,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
@@ -131,7 +158,7 @@ module TasteTester
       server = TasteTester::Server.new
       hosts.each do |hostname|
         host = TasteTester::Host.new(hostname, server)
-        host.run
+        host.runchef
       end
     end
 
@@ -150,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
@@ -162,7 +189,7 @@ module TasteTester
       client.skip_checks = true if TasteTester::Config.skip_repo_checks
       client.force = true if TasteTester::Config.force_upload
       client.upload
-    rescue => exception
+    rescue StandardError => exception
       # We're trying to recover from common chef-zero errors
       # Most of them happen due to half finished uploads, which leave
       # chef-zero in undefined state
@@ -183,5 +210,168 @@ 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)
+
+      # Perform preliminary impact analysis. By default, use Knife to find
+      # the roles dependent on modified cookbooks. Custom logic may provide
+      # additional information by defining the find_impact plugin method.
+      basic_impact = TasteTester::Hooks.find_impact(changes)
+      basic_impact ||= _find_roles(changes)
+
+      # Do any post processing required on the list of impacted roles, such
+      # as looking up hostnames associated with each role. By default, pass
+      # the preliminary results through unmodified.
+      final_impact = TasteTester::Hooks.post_impact(basic_impact)
+      final_impact ||= basic_impact
+
+      # 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 define the find_impact method in a local plugin.')
+        exit(1)
+      end
+
+      cookbooks = Set.new(changes.cookbooks)
+      roles = Set.new(changes.roles)
+      databags = Set.new(changes.databags)
+
+      if cookbooks.empty? && roles.empty?
+        unless TasteTester::Config.json
+          logger.warn('No cookbooks or roles have been modified.')
+        end
+        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,10 +37,12 @@ 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'
     ref_file "#{ENV['HOME']}/.chef/taste-tester-ref.json"
+    knife_config "#{ENV['HOME']}/.chef/knife-#{ENV['USER']}-taste-tester.rb"
     checksum_dir "#{ENV['HOME']}/.chef/checksums"
     skip_repo_checks false
     chef_client_command 'chef-client'
@@ -50,11 +52,26 @@ 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'
     chef_config 'client.rb'
     my_hostname nil
+    track_symlinks false
+    transport 'ssh'
+    no_repo false
+    json false
+    jumps nil
+    windows_target 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
@@ -94,6 +111,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 = (
@@ -113,11 +134,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

@@ -20,5 +20,14 @@ module TasteTester
     end
     class LocalLinkError < StandardError
     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

@@ -26,39 +26,47 @@ module TasteTester
     extend BetweenMeals::Util
 
     # Do stuff before we upload to chef-zero
-    def self.pre_upload(_dryrun, _repo, _last_ref, _cur_ref)
-    end
+    def self.pre_upload(_dryrun, _repo, _last_ref, _cur_ref); end
 
     # Do stuff after we upload to chef-zero
-    def self.post_upload(_dryrun, _repo, _last_ref, _cur_ref)
-    end
+    def self.post_upload(_dryrun, _repo, _last_ref, _cur_ref); end
 
     # Do stuff before we put hosts in test mode
-    def self.pre_test(_dryrun, _repo, _hosts)
-    end
+    def self.pre_test(_dryrun, _repo, _hosts); end
 
     # This should return an array of commands to execute on
     # remote systems.
-    def self.test_remote_cmds(_dryrun, _hostname)
-    end
+    def self.test_remote_cmds(_dryrun, _hostname); end
 
     # Should return a string with extra stuff to shove
     # in the remote client.rb
-    def self.test_remote_client_rb_extra_code(_hostname)
-    end
+    def self.test_remote_client_rb_extra_code(_hostname); end
 
     # Do stuff after we put hosts in test mode
-    def self.post_test(_dryrun, _repo, _hosts)
-    end
+    def self.post_test(_dryrun, _repo, _hosts); end
 
     # Additional checks you want to do on the repo
-    def self.repo_checks(_dryrun, _repo)
-    end
+    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.find_impact(_changes); end
+
+    # Do stuff after we find impacted roles
+    # This should return a JSON serializable object with the final impact
+    # assessment. You will probably also want to define a print_impact method
+    # which returns true to override the default output logic.
+    def self.post_impact(_impacted_roles); end
+
+    # Customize 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}")
-      unless File.exists?(path)
+      logger.warn("Loading plugin at #{path}") unless TasteTester::Config.json
+      unless File.exist?(path)
         logger.error('Plugin file not found')
         exit(1)
       end

data/lib/taste_tester/host.rb

@@ -20,14 +20,19 @@ require 'open3'
 require 'colorize'
 
 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)
@@ -42,25 +47,11 @@ module TasteTester
     def runchef
       logger.warn("Running '#{TasteTester::Config.chef_client_command}' " +
                   "on #{@name}")
-      cmd = "#{TasteTester::Config.ssh_command} " +
-            "#{TasteTester::Config.user}@#{@name} "
-      if TasteTester::Config.user != 'root'
-        cc = Base64.encode64(cmds).delete("\n")
-        cmd += "\"echo '#{cc}' | base64 --decode | sudo bash -x\""
-      else
-        cmd += "\"#{cmds}\""
-      end
-      status = IO.popen(
-        cmd,
-      ) do |io|
-        # rubocop:disable AssignmentInCondition
-        while line = io.gets
-          puts line.chomp!
-        end
-        # rubocop:enable AssignmentInCondition
-        io.close
-        $CHILD_STATUS.to_i
-      end
+      transport = get_transport
+      transport << TasteTester::Config.chef_client_command
+
+      io = IO.new(1)
+      status, = transport.run(io)
       logger.warn("Finished #{TasteTester::Config.chef_client_command}" +
                   " on #{@name} with status #{status}")
       if status.zero?
@@ -72,12 +63,14 @@ module TasteTester
     end
 
     def get_transport
-      if TasteTester::Config.locallink
-        transport = TasteTester::LocalLink.new
+      case TasteTester::Config.transport
+      when 'locallink'
+        TasteTester::LocalLink.new
+      when 'noop'
+        TasteTester::NoOp.new
       else
-        transport = TasteTester::SSH.new(@name)
+        TasteTester::SSH.new(@name)
       end
-      transport
     end
 
     def test
@@ -91,22 +84,35 @@ 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
 
-      transport << 'logger -t taste-tester Moving server into taste-tester' +
-        " for #{@user}"
-      transport << touchcmd
-      transport << "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}/" +
-        "#{TasteTester::Config.chef_config}; true )"
-      transport.run!
+      # see if someone else is taste-testing
+      transport << we_testing
+
+      if TasteTester::Config.windows_target
+        add_windows_test_cmds(transport, serialized_config)
+      else
+        add_sane_os_test_cmds(transport, serialized_config)
+      end
+
+      # 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
+
+      status, output = transport.run
+
+      case status
+      when 0
+        # no problem, keep going.
+        nil
+      when 42
+        fail TasteTester::Exceptions::AlreadyTestingError, output.chomp
+      else
+        transport.error!
+      end
 
       # Then run any other stuff they wanted
       cmds = TasteTester::Hooks.test_remote_cmds(
@@ -114,7 +120,7 @@ module TasteTester
         @name,
       )
 
-      if cmds && cmds.any?
+      if cmds&.any?
         transport = get_transport
         cmds.each { |c| transport << c }
         transport.run!
@@ -127,62 +133,49 @@ module TasteTester
       if TasteTester::Config.use_ssh_tunnels
         TasteTester::Tunnel.kill(@name)
       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} " +
-          "#{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 " +
-          "#{TasteTester::Config.chef_config_path}/client.pem",
-        "rm -vf #{TasteTester::Config.timestamp_file}",
-        'logger -t taste-tester Returning server to production',
-      ].each do |cmd|
-        transport << cmd
+      if TasteTester::Config.windows_target
+        add_windows_untest_cmds(transport)
+      else
+        add_sane_os_untest_cmds(transport)
       end
       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
+      # 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.
+      if TasteTester::Config.windows_target
+        shellcode = <<~ENDOFSHELLCODE
+          Get-Content #{config_file} | ForEach-Object {
+            if (\$_ -match "#{USER_PREAMBLE}" ) {
+              $user = \$_.Split()[-1]
+              if (\$user -ne "#{@user}") {
+                echo \$user
+                exit 42
+              }
+            }
+          }
+        ENDOFSHELLCODE
+        shellcode.chomp
       else
-        false
+        shellcode = <<~ENDOFSHELLCODE
+          awk "\\$0 ~ /^#{USER_PREAMBLE}/{
+            if (\\$NF != \\"#{@user}\\"){
+              print \\$NF;
+              exit 42
+            }
+          }" #{config_file}
+        ENDOFSHELLCODE
+        shellcode.delete("\n")
       end
+      shellcode
     end
 
     def keeptesting
@@ -201,15 +194,140 @@ module TasteTester
 
     private
 
+    # Sources must be 'registered' with the Eventlog, so check if we have
+    # registered and register if necessary
+    def create_eventlog_if_needed_cmd
+      get_src = 'Get-EventLog -LogName Application -source taste-tester 2>$null'
+      mk_src = 'New-EventLog -source "taste-tester" -LogName Application'
+      "if (-Not (#{get_src})) { #{mk_src} }"
+    end
+
+    # Remote testing commands for most OSes...
+    def add_sane_os_test_cmds(transport, serialized_config)
+      transport << 'logger -t taste-tester Moving server into taste-tester' +
+        " for #{@user}"
+      transport << touchcmd
+      # 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 )"
+    end
+
+    # Remote testing commands for Windows
+    def add_windows_test_cmds(transport, serialized_config)
+      # This is the closest equivalent to 'bash -x' - but if we put it on
+      # by default the way we do with linux it badly breaks our output. So only
+      # set it if we're in debug
+      #
+      # This isn't the most optimal place for this. It should be in ssh_util
+      # and we should jam this into the beggining of the cmds list we get,
+      # but this is early enough and good enough for now and we can think about
+      # that when we refactor tunnel.sh, ssh.sh and ssh_util.sh into one sane
+      # class.
+      if logger.level == Logger::DEBUG
+        transport << 'Set-PSDebug -trace 1'
+      end
+
+      ttconfig =
+        "#{TasteTester::Config.chef_config_path}/#{TASTE_TESTER_CONFIG}"
+      realconfig = "#{TasteTester::Config.chef_config_path}/" +
+        TasteTester::Config.chef_config
+      [
+        create_eventlog_if_needed_cmd,
+        'Write-EventLog -LogName "Application" -Source "taste-tester" ' +
+          '-EventID 1 -EntryType Information ' +
+          "-Message \"Moving server into taste-tester for #{@user}\"",
+        touchcmd,
+        "$b64 = \"#{serialized_config}\"",
+        "$ttconfig = \"#{ttconfig}\"",
+        "$realconfig = \"#{realconfig}\"",
+
+        '$tmp64 = (New-TemporaryFile).name',
+        '$tmp = (New-TemporaryFile).name',
+
+        '$b64 | Out-File -Encoding ASCII $tmp64 -Force',
+
+        # Remove our tmp file before we write to it or certutil crashes...
+        'if (Test-Path $tmp) { rm $tmp }',
+        'certutil -decode $tmp64 $tmp',
+        'mv $tmp $ttconfig -Force',
+
+        'New-Item -ItemType SymbolicLink -Value $ttconfig $realconfig -Force',
+      ].each do |cmd|
+        transport << cmd
+      end
+    end
+
     def touchcmd
-      touch = Base64.encode64(
-        "if [ 'Darwin' = $(uname) ]; then touch -t \"$(date -r " +
-        "#{TasteTester::Config.testing_end_time.to_i} +'%Y%m%d%H%M.%S')\" " +
-        "#{TasteTester::Config.timestamp_file}; else touch --date \"$(date " +
-        "-d @#{TasteTester::Config.testing_end_time.to_i} +'%Y-%m-%d %T')\" " +
-        "#{TasteTester::Config.timestamp_file}; fi",
-      ).delete("\n")
-      "echo -n '#{touch}' | base64 --decode | bash"
+      if TasteTester::Config.windows_target
+        # There's no good touch equivalent in Windows. You can force
+        # creation of a new file, but that'll nuke it's contents, which if we're
+        # 'keeptesting'ing, then we'll loose the contents (PID and such).
+        # We can set the timestamp with Get-Item.creationtime, but it must exist
+        # if we're not gonna crash. So do both.
+        [
+          "$ts = \"#{TasteTester::Config.timestamp_file}\"",
+          'if (-Not (Test-Path $ts)) { New-Item -ItemType file $ts }',
+          '(Get-Item "$ts").LastWriteTime=("' +
+            "#{TasteTester::Config.testing_end_time}\")",
+        ].join(';')
+      else
+        touch = Base64.encode64(
+          "if [ 'Darwin' = $(uname) ]; then touch -t \"$(date -r " +
+          "#{TasteTester::Config.testing_end_time.to_i} +'%Y%m%d%H%M.%S')\" " +
+          "#{TasteTester::Config.timestamp_file}; else touch --date \"$(date " +
+          "-d @#{TasteTester::Config.testing_end_time.to_i} +'%Y-%m-%d %T')\"" +
+          " #{TasteTester::Config.timestamp_file}; fi",
+        ).delete("\n")
+        "/bin/echo -n '#{touch}' | base64 --decode | bash"
+      end
+    end
+
+    # Remote untesting commands for Windows
+    def add_windows_untest_cmds(transport)
+      config_prod = TasteTester::Config.chef_config.split('.').join('-prod.')
+      [
+        'New-Item -ItemType SymbolicLink -Force -Value ' +
+          "#{TasteTester::Config.chef_config_path}/#{config_prod} " +
+          "#{TasteTester::Config.chef_config_path}/" +
+          TasteTester::Config.chef_config,
+        'New-Item -ItemType SymbolicLink -Force -Value ' +
+          "#{TasteTester::Config.chef_config_path}/client-prod.pem " +
+          "#{TasteTester::Config.chef_config_path}/client.pem",
+        'rm -Force ' +
+          "#{TasteTester::Config.chef_config_path}/#{TASTE_TESTER_CONFIG}",
+        "rm -Force #{TasteTester::Config.timestamp_file}",
+        create_eventlog_if_needed_cmd,
+        'Write-EventLog -LogName "Application" -Source "taste-tester" ' +
+          '-EventID 4 -EntryType Information -Message "Returning server ' +
+          'to production"',
+      ].each do |cmd|
+        transport << cmd
+      end
+    end
+
+    # Remote untesting commands for most OSes...
+    def add_sane_os_untest_cmds(transport)
+      config_prod = TasteTester::Config.chef_config.split('.').join('-prod.')
+      [
+        "ln -vsf #{TasteTester::Config.chef_config_path}/#{config_prod} " +
+          "#{TasteTester::Config.chef_config_path}/" +
+          TasteTester::Config.chef_config,
+        "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|
+        transport << cmd
+      end
     end
 
     def config
@@ -217,41 +335,91 @@ 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
-      return ttconfig
+      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
+      ttconfig
     end
   end
 end