taste_tester 0.0.1 → 0.0.2

data/bin/taste-tester

@@ -0,0 +1,354 @@
+#!/opt/chef/embedded/bin/ruby
+# vim: syntax=ruby:expandtab:shiftwidth=2:softtabstop=2:tabstop=2
+# rubocop:disable UnusedBlockArgument, AlignParameters
+
+if ENV['MY_RUBY_HOME'] && ENV['MY_RUBY_HOME'].include?('rvm')
+  puts 'Please disable RVM before running taste-tester'
+  exit(1)
+end
+
+require 'rubygems'
+require 'time'
+require 'optparse'
+require 'colorize'
+
+require 'taste_tester/logging'
+require 'taste_tester/config'
+require 'taste_tester/commands'
+require 'taste_tester/hooks'
+
+include TasteTester::Logging
+
+if ENV['USER'] == 'root'
+  logger.warn('You should not be running as root')
+  exit(1)
+end
+
+# Command line parsing and param descriptions
+module TasteTester
+  verify = 'Verify your changes were actually applied as intended!'.red
+  cmd = TasteTester::Config.chef_client_command
+  description = <<-EOF
+Welcome to taste-tester!
+
+Usage: taste-tester <mode> [<options>]
+
+TLDR; Most common usage is:
+  vi cookbooks/...             # Make your changes and commit locally
+  taste-tester test -s [host]  # Put host in test mode
+  ssh root@[host]              # Log on host
+  #{format('%-28s', "  #{cmd}")} # Run chef and watch it break
+  vi cookbooks/...             # Fix your cookbooks
+  taste-tester upload          # Upload the diff
+  ssh root@[host]              # Log on host
+  #{format('%-28s', "  #{cmd}")} # Run chef and watch it succeed
+  <#{verify}>
+  taste-tester untest [host]   # Put host back in production
+                               #   (optional - will revert itself after 1 hour)
+
+And you're done! See the above wiki page for more details.
+
+MODES:
+  test
+    Sync your local repo to your virtual Chef server (same as 'upload'), and
+    point some production server specified by -s to your virtual chef server for
+    testing.  If you have you a plugin that uses the hookpoint, it'll may amend
+    your commit message to denote the server you tested.
+
+  upload
+    Sync your local repo to your virtual Chef server (i.e. just the first step
+    of 'test'). By defailt, it intelligently uploads whatever has changed since
+    the last time you ran upload (or test), but tracking git changes (even
+    across branch changes). You may specify -f to force a full upload of all
+    cookbooks and roles. It also does a fair amount of sanity checking on
+    your repo and you may specify --skip-repo-checks to bypass this.
+
+  keeptesting
+    Extend the testing time on server specified by -s by 1 hour unless
+    otherwise specified by -t.
+
+  untest
+    Return the server specified in -s to production.
+
+  status
+    Print out the state of the world.
+
+  run
+    Run #{cmd} on the machine specified by '-s' over SSH and print the output.
+    NOTE!! This is #{'NOT'.red} a sufficient test, you must log onto the remote
+    machine and verify the changes you are trying to make are actually present.
+
+  stop
+    You probably don't want this. It will shutdown the chef-zero server on
+    your localhost.
+
+  start
+    You probably don't want this. It will start up the chef-zero server on
+    your localhost. taste-tester dynamically starts this if it's down, so there
+    should be no need to do this manually.
+
+  restart
+    You probably don't want this. It will restart up the chef-zero server on
+    your localhost. taste-tester dynamically starts this if it's down, so there
+    should be no need to do this manually.
+  EOF
+
+  mode = ARGV.shift unless ARGV.size > 0 && ARGV[0].start_with?('-')
+
+  unless mode
+    mode = 'help'
+    puts "ERROR: No mode specified\n\n"
+  end
+
+  options = { :config_file => TasteTester::Config.config_file }
+  parser = OptionParser.new do |opts|
+    opts.banner = description
+
+    opts.separator ''
+    opts.separator 'Global options:'.upcase
+
+    opts.on('-c', '--config FILE', 'Config file') do |file|
+      unless File.exists?(File.expand_path(file))
+        logger.error("Sorry, cannot find #{file}")
+        exit(1)
+      end
+      options[:config_file] = file
+    end
+
+    opts.on('-v', '--verbose', 'Verbosity, provide twice for all debug') do
+      # If -vv is supplied this block is executed twice
+      if options[:verbosity]
+        options[:verbosity] = Logger::DEBUG
+      else
+        options[:verbosity] = Logger::INFO
+      end
+    end
+
+    opts.on('-p', '--plugin-path FILE', String, 'Plugin file') do |file|
+      unless File.exists?(File.expand_path(file))
+        logger.error("Sorry, cannot find #{file}")
+        exit(1)
+      end
+      options[:plugin_path] = file
+    end
+
+    opts.on('-h', '--help', 'Print help message.') do
+      print opts
+      exit
+    end
+
+    opts.on('-T', '--timestamp', 'Time-stamped log style output') do
+      options[:timestamp] = true
+    end
+
+    opts.separator ''
+    opts.separator 'Sub-command options:'.upcase
+
+    opts.on(
+      '-C', '--cookbooks COOKBOOK[,COOKBOOK]', Array,
+      'Specific cookbooks to upload. Intended mostly for debugging,' +
+        ' not recommended. Works on upload and test. Not yet implemented.'
+    ) do |cbs|
+      options[:cookbooks] = cbs
+    end
+
+    opts.on(
+      '-D', '--databag DATABAG/ITEM[,DATABAG/ITEM]', Array,
+      'Specific cookbooks to upload. Intended mostly for debugging,' +
+        ' not recommended. Works on upload and test. Not yet implemented.'
+    ) do |cbs|
+      options[:databags] = cbs
+    end
+
+    opts.on(
+      '-f', '--force-upload',
+      'Force upload everything. Works on upload and test.'
+    ) do
+      options[:force_upload] = true
+    end
+
+    opts.on(
+      '--chef-port-range PORT1,PORT2', Array,
+      'Port range for chef-zero'
+    ) do |ports|
+      unless ports.count == 2
+        logger.error("Invalid port range: #{ports}")
+        exit 1
+      end
+      options[:chef_port_range] = ports
+    end
+
+    opts.on(
+      '--tunnel-port PORT', 'Port for ssh tunnel'
+    ) do |port|
+      options[:user_tunnel_port] = port
+    end
+
+    opts.on(
+      '-l', '--linkonly', 'Only setup the remote server, skip uploading.'
+    ) do
+      options[:linkonly] = true
+    end
+
+    opts.on(
+      '-t', '--testing-timestamp TIME',
+        'Until when should the host remain in testing.' +
+        ' Anything parsable is ok, such as "5/18 4:35" or "16/9/13".'
+    ) do |time|
+      begin
+        options[:testing_until] = Time.parse(time)
+      rescue
+        logger.error("Invalid date: #{time}")
+        exit 1
+      end
+    end
+
+    opts.on(
+      '-t', '--testing-time TIME',
+        'How long should the host remain in testing.' +
+        ' Takes a simple relative time string, such as "45m", "4h" or "2d".'
+    ) do |time|
+      m = time.match(/^(\d+)([d|h|m]+)$/)
+      if m
+        exp = {
+          :d => 60 * 60 * 24,
+          :h => 60 * 60,
+          :m => 60,
+        }[m[2].to_sym]
+        delta = m[1].to_i * exp
+        options[:testing_until] = Time.now + delta.to_i
+      else
+        logger.error("Invalid testing-time: #{time}")
+        exit 1
+      end
+    end
+
+    opts.on(
+      '-r', '--repo DIR',
+      "Custom repo location, current deafult is #{TasteTester::Config.repo}." +
+        ' Works on upload and test.'
+    ) do |dir|
+      options[:repo] = dir
+    end
+
+    opts.on(
+      '-R', '--roles ROLE[,ROLE]', Array,
+      'Specific roles to upload. Intended mostly for debugging,' +
+        ' not recommended. Works on upload and test. Not yet implemented.'
+    ) do |roles|
+      options[:roles] = roles
+    end
+
+    opts.on('--really', 'Really do link-only. DANGEROUS!') do |r|
+      options[:really] = r
+    end
+
+    opts.on(
+      '-s', '--servers SERVER[,SERVER]', Array,
+      'Server to test/untest/keeptesting.'
+    ) do |s|
+      options[:servers] = s
+    end
+
+    opts.on(
+      '--user USER', 'Custom username for SSH, defaults to "root".' +
+        ' If custom user is specified, we will use sudo for all commands.'
+    ) do |user|
+      options[:user] = user
+    end
+
+    opts.on(
+      '-S', '--[no-]use-ssh-tunnels', 'Protect Chef traffic with SSH tunnels'
+    ) do |s|
+      options[:use_ssh_tunnels] = s
+    end
+
+    opts.on('--skip-repo-checks', 'Skip repository sanity checks') do
+      options[:skip_repo_checks] = true
+    end
+
+    opts.on('-y', '--yes', 'Do not prompt before testing.') do
+      options[:yes] = true
+    end
+
+    opts.separator ''
+    opts.separator 'Control local hook behavior with these options:'
+
+    opts.on(
+      '--skip-pre-upload-hook', 'Skip pre-upload hook. Works on upload, test.'
+    ) do
+      options[:skip_pre_upload_hook] = true
+    end
+
+    opts.on(
+      '--skip-post-upload-hook', 'Skip post-upload hook. Works on upload, test.'
+    ) do
+      options[:skip_post_upload_hook] = true
+    end
+
+    opts.on(
+      '--skip-pre-test-hook', 'Skip pre-test hook. Works on test.'
+    ) do
+      options[:skip_pre_test_hook] = true
+    end
+
+    opts.on(
+      '--skip-post-test-hook', 'Skip post-test hook. Works on test.'
+    ) do
+      options[:skip_post_test_hook] = true
+    end
+
+    opts.on(
+      '--skip-repo-checks-hook', 'Skip repo-checks hook. Works on upload, test.'
+    ) do
+      options[:skip_post_test_hook] = true
+    end
+  end
+
+  if mode == 'help'
+    puts parser
+    exit
+  end
+
+  parser.parse!
+
+  if File.exists?(File.expand_path(options[:config_file]))
+    TasteTester::Config.from_file(File.expand_path(options[:config_file]))
+  end
+  TasteTester::Config.merge!(options)
+  TasteTester::Logging.verbosity = TasteTester::Config.verbosity
+  TasteTester::Logging.use_log_formatter = TasteTester::Config.timestamp
+
+  if File.exists?(File.expand_path(TasteTester::Config.plugin_path))
+    TasteTester::Hooks.get(File.expand_path(TasteTester::Config[:plugin_path]))
+  end
+
+  case mode.to_sym
+  when :start
+    TasteTester::Commands.start
+  when :stop
+    TasteTester::Commands.stop
+  when :restart
+    TasteTester::Commands.restart
+  when :keeptesting
+    TasteTester::Commands.keeptesting
+  when :status
+    TasteTester::Commands.status
+  when :test
+    TasteTester::Commands.test
+  when :untest
+    TasteTester::Commands.untest
+  when :run
+    TasteTester::Commands.runchef
+  when :upload
+    TasteTester::Commands.upload
+  else
+    logger.error("Invalid mode: #{mode}")
+    puts parser
+    exit(1)
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  include TasteTester
+end

data/lib/taste_tester/client.rb

@@ -0,0 +1,169 @@
+# vim: syntax=ruby:expandtab:shiftwidth=2:softtabstop=2:tabstop=2
+
+require 'taste_tester/logging'
+require 'between_meals/repo'
+require 'between_meals/knife'
+require 'between_meals/changeset'
+
+module TasteTester
+  # Client side upload functionality
+  # Ties together Repo/Changeset diff logic
+  # and Server/Knife uploads
+  class Client
+    include TasteTester::Logging
+    include BetweenMeals::Util
+
+    attr_accessor :force, :skip_checks
+
+    def initialize(server)
+      @server = server
+      @knife = BetweenMeals::Knife.new(
+        :logger => logger,
+        :user => @server.user,
+        :host => @server.host,
+        :port => @server.port,
+        :role_dir => TasteTester::Config.roles,
+        :cookbook_dirs => TasteTester::Config.cookbooks,
+        :databag_dir => TasteTester::Config.databags,
+        :checksum_dir => TasteTester::Config.checksum_dir,
+      )
+      @knife.write_user_config
+      @repo = BetweenMeals::Repo.get(TasteTester::Config.repo_type,
+                                     TasteTester::Config.repo, logger)
+      fail 'Could not read repo' unless @repo
+    end
+
+    def checks
+      unless @skip_checks
+        TasteTester::Hooks.repo_checks(TasteTester::Config.dryrun, @repo)
+      end
+    end
+
+    def upload
+      checks unless @skip_checks
+
+      logger.warn("Using #{TasteTester::Config.repo}")
+      logger.info("Last commit: #{@repo.head_rev} " +
+        "'#{@repo.last_msg.split("\n").first}'" +
+        " by #{@repo.last_author[:email]}")
+
+      if @force || !@server.latest_uploaded_ref
+        logger.info('Full upload forced') if @force
+        unless TasteTester::Config.skip_pre_upload_hook
+          TasteTester::Hooks.pre_upload(TasteTester::Config.dryrun,
+                                        @repo,
+                                        nil,
+                                        @repo.head_rev)
+        end
+        time(logger) { full }
+        unless TasteTester::Config.skip_post_upload_hook
+          TasteTester::Hooks.post_upload(TasteTester::Config.dryrun,
+                                         @repo,
+                                         nil,
+                                         @repo.head_rev)
+        end
+      else
+        # Since we also upload the index, we always need to run the
+        # diff even if the version we're on is the same as the last
+        # revision
+        unless TasteTester::Config.skip_pre_upload_hook
+          TasteTester::Hooks.pre_upload(TasteTester::Config.dryrun,
+                                        @repo,
+                                        @server.latest_uploaded_ref,
+                                        @repo.head_rev)
+        end
+        begin
+          time(logger) { partial }
+        rescue BetweenMeals::Changeset::ReferenceError
+          logger.warn('Something changed with your repo, doing full upload')
+          time(logger) { full }
+        end
+        unless TasteTester::Config.skip_post_upload_hook
+          TasteTester::Hooks.post_upload(TasteTester::Config.dryrun,
+                                         @repo,
+                                         @server.latest_uploaded_ref,
+                                         @repo.head_rev)
+        end
+      end
+
+      @server.latest_uploaded_ref = @repo.head_rev
+    end
+
+    private
+
+    def full
+      logger.warn('Doing full upload')
+      @knife.cookbook_upload_all
+      @knife.role_upload_all
+      @knife.databag_upload_all
+    end
+
+    def partial
+      logger.info('Doing differential upload from ' +
+                   @server.latest_uploaded_ref)
+      changeset = BetweenMeals::Changeset.new(
+        logger,
+        @repo,
+        @server.latest_uploaded_ref,
+        nil,
+        {
+          :cookbook_dirs =>
+            TasteTester::Config.relative_cookbook_dirs,
+          :role_dir =>
+            TasteTester::Config.relative_role_dir,
+          :databag_dir =>
+            TasteTester::Config.relative_databag_dir,
+        },
+      )
+
+      cbs = changeset.cookbooks
+      deleted_cookbooks = cbs.select { |x| x.status == :deleted }
+      modified_cookbooks = cbs.select { |x| x.status == :modified }
+      roles = changeset.roles
+      deleted_roles = roles.select { |x| x.status == :deleted }
+      modified_roles = roles.select { |x| x.status == :modified }
+      databags = changeset.databags
+      deleted_databags = databags.select { |x| x.status == :deleted }
+      modified_databags = databags.select { |x| x.status == :modified }
+
+      didsomething = false
+      unless deleted_cookbooks.empty?
+        didsomething = true
+        logger.warn("Deleting cookbooks: [#{deleted_cookbooks.join(' ')}]")
+        @knife.cookbook_delete(deleted_cookbooks)
+      end
+
+      unless modified_cookbooks.empty?
+        didsomething = true
+        logger.warn("Uploading cookbooks: [#{modified_cookbooks.join(' ')}]")
+        @knife.cookbook_upload(modified_cookbooks)
+      end
+
+      unless deleted_roles.empty?
+        didsomething = true
+        logger.warn("Deleting roles: [#{deleted_roles.join(' ')}]")
+        @knife.role_delete(deleted_roles)
+      end
+
+      unless modified_roles.empty?
+        didsomething = true
+        logger.warn("Uploading roles: [#{modified_roles.join(' ')}]")
+        @knife.role_upload(modified_roles)
+      end
+
+      unless deleted_databags.empty?
+        didsomething = true
+        logger.warn("Deleting databags: [#{deleted_databags.join(' ')}]")
+        @knife.databag_delete(deleted_databags)
+      end
+
+      unless modified_databags.empty?
+        didsomething = true
+        logger.warn("Uploading databags: [#{modified_databags.join(' ')}]")
+        @knife.databag_upload(modified_databags)
+      end
+
+      logger.warn('Nothing to upload!') unless didsomething
+    end
+  end
+end

data/lib/taste_tester/commands.rb

@@ -0,0 +1,144 @@
+# vim: syntax=ruby:expandtab:shiftwidth=2:softtabstop=2:tabstop=2
+# rubocop:disable UnusedBlockArgument, UnusedMethodArgument
+
+require 'taste_tester/server'
+require 'taste_tester/host'
+require 'taste_tester/config'
+require 'taste_tester/client'
+require 'taste_tester/logging'
+
+module TasteTester
+  # Functionality dispatch
+  module Commands
+    extend TasteTester::Logging
+
+    def self.start
+      server = TasteTester::Server.new
+      return if TasteTester::Server.running?
+      server.start
+    end
+
+    def self.restart
+      server = TasteTester::Server.new
+      server.stop if TasteTester::Server.running?
+      server.start
+    end
+
+    def self.stop
+      server = TasteTester::Server.new
+      server.stop
+    end
+
+    def self.status
+      server = TasteTester::Server.new
+      if TasteTester::Server.running?
+        logger.warn("Local taste-tester server running on port #{server.port}")
+        if server.latest_uploaded_ref
+          logger.warn('Latest uploaded revision is ' +
+            server.latest_uploaded_ref)
+        else
+          logger.warn('No cookbooks/roles uploads found')
+        end
+      else
+        logger.warn('Local taste-tester server not running')
+      end
+    end
+
+    def self.test
+      hosts = TasteTester::Config.servers
+      unless hosts
+        logger.warn('You must provide a hostname')
+        exit(1)
+      end
+      unless TasteTester::Config.yes
+        printf("Set #{TasteTester::Config.servers} to test mode? [y/N] ")
+        ans = STDIN.gets.chomp
+        exit(1) unless ans =~ /^[yY](es)?$/
+      end
+      if TasteTester::Config.linkonly && TasteTester::Config.really
+        logger.warn('Skipping upload at user request... potentially dangerous!')
+      else
+        if TasteTester::Config.linkonly
+          logger.warn('Ignoring --linkonly because --really not set')
+        end
+        upload
+      end
+      server = TasteTester::Server.new
+      repo = BetweenMeals::Repo.get(TasteTester::Config.repo_type,
+                                    TasteTester::Config.repo, logger)
+      unless TasteTester::Config.skip_pre_test_hook
+        TasteTester::Hooks.pre_test(TasteTester::Config.dryrun, repo, hosts)
+      end
+      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
+          host.test
+          tested_hosts << hostname
+        end
+      end
+      unless TasteTester::Config.skip_post_test_hook
+        TasteTester::Hooks.post_test(TasteTester::Config.dryrun, repo,
+                                     tested_hosts)
+      end
+    end
+
+    def self.untest
+      hosts = TasteTester::Config.servers
+      unless hosts
+        logger.warn('You must provide a hostname')
+        exit(1)
+      end
+      server = TasteTester::Server.new
+      hosts.each do |hostname|
+        host = TasteTester::Host.new(hostname, server)
+        host.untest
+      end
+    end
+
+    def self.runchef
+      hosts = TasteTester::Config.servers
+      unless hosts
+        logger.warn('You must provide a hostname')
+        exit(1)
+      end
+      server = TasteTester::Server.new
+      hosts.each do |hostname|
+        host = TasteTester::Host.new(hostname, server)
+        host.run
+      end
+    end
+
+    def self.keeptesting
+      hosts = TasteTester::Config.servers
+      unless hosts
+        logger.warn('You must provide a hostname')
+        exit(1)
+      end
+      server = TasteTester::Server.new
+      hosts.each do |hostname|
+        host = TasteTester::Host.new(hostname, server)
+        host.keeptesting
+      end
+    end
+
+    def self.upload
+      server = TasteTester::Server.new
+      # On a fore-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
+        server.restart
+      else
+        server.start unless TasteTester::Server.running?
+      end
+      client = TasteTester::Client.new(server)
+      client.skip_checks = true if TasteTester::Config.skip_checks
+      client.force = true if TasteTester::Config.force_upload
+      client.upload
+    end
+  end
+end