beaker 3.13.0 → 3.14.0

data/lib/beaker/options/parser.rb

@@ -204,7 +204,8 @@ module Beaker
       #   2.  ARGV or provided arguments array
       #   3.  the 'CONFIG' section of the hosts file
       #   4.  options file values
-      #   5.  default or preset values are given the lowest priority
+      #   5.  subcommand options, if executing beaker subcommands
+      #   6.  default or preset values are given the lowest priority
       #
       # @param [Array] args ARGV or a provided arguments array
       # @raise [ArgumentError] Raises error on bad input
@@ -214,6 +215,12 @@ module Beaker
         cmd_line_options                = @command_line_parser.parse(args)
         cmd_line_options[:command_line] = ([$0] + args).join(' ')
         @attribution = @attribution.merge(tag_sources(cmd_line_options, "flag"))
+
+        # Subcommands are the first to get merged into presets
+        subcommand_options = Beaker::Options::SubcommandOptionsParser.parse_subcommand_options(args)
+        @attribution = @attribution.merge(tag_sources(subcommand_options, 'subcommand'))
+        @options.merge!(subcommand_options)
+
         file_options                    = Beaker::Options::OptionsFileParser.parse_options_file(cmd_line_options[:options_file])
         @attribution = @attribution.merge(tag_sources(file_options, "options_file"))
 

data/lib/beaker/options/subcommand_options_file_parser.rb

@@ -0,0 +1,20 @@
+module Beaker
+  module Options
+    #A set of functions to read options files
+    module SubcommandOptionsParser
+
+      # @return [OptionsHash, Hash] returns an empty OptionHash or loads subcommand options yaml
+      #   from disk
+      def self.parse_subcommand_options(argv)
+        result = OptionsHash.new
+        if Beaker::Subcommands::SubcommandUtil.execute_subcommand?(argv[0])
+          return result if argv[0] == 'init'
+          if Beaker::Subcommands::SubcommandUtil::SUBCOMMAND_OPTIONS.exist?
+           result = YAML.load_file(Beaker::Subcommands::SubcommandUtil::SUBCOMMAND_OPTIONS)
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/beaker/ssh_connection.rb

@@ -108,7 +108,7 @@ module Beaker
 
     # Wait for the ssh connection to fail, returns true on connection failure and false otherwise
     # @param [Hash{Symbol=>String}] options Options hash to control method conditionals
-    # @option options [Boolean] :pty Should we request a terminal when attempting 
+    # @option options [Boolean] :pty Should we request a terminal when attempting
     #                                to send a command over this connection?
     # @option options [String] :stdin Any input to be sent along with the command
     # @param [IO] stdout_callback An IO stream to send connection stdout to, defaults to nil

data/lib/beaker/subcommand.rb

@@ -6,9 +6,13 @@ module Beaker
   class Subcommand < Thor
     SubcommandUtil = Beaker::Subcommands::SubcommandUtil
 
+
     def initialize(*args)
       super
-      @@config = SubcommandUtil.init_config()
+      FileUtils.mkdir_p(SubcommandUtil::CONFIG_DIR)
+      FileUtils.touch(SubcommandUtil::SUBCOMMAND_OPTIONS) unless SubcommandUtil::SUBCOMMAND_OPTIONS.exist?
+      FileUtils.touch(SubcommandUtil::SUBCOMMAND_STATE) unless SubcommandUtil::SUBCOMMAND_STATE.exist?
+      @cli = Beaker::CLI.new
     end
 
     # Options listed in this group 'Beaker run' are options that can be set on subcommands
@@ -49,55 +53,163 @@ module Beaker
     class_option :'exclude-tags', :type => :string, :group => 'Beaker run'
     class_option :'xml-time-order', :type => :boolean, :group => 'Beaker run'
 
-    desc "init HYPERVISOR", "Initialises the beaker test environment configuration"
-    option :help, :type => :boolean, :hide => true
+    desc "init BEAKER_RUN_OPTIONS", "Initializes the required configuration for Beaker subcommand execution"
     long_desc <<-LONGDESC
-
-      Initialises a test environment configuration for a specific hypervisor
-
-      Supported hypervisors are: vagrant (default), vmpooler
-
+      Initializes the required .beaker configuration folder. This folder contains
+      a subcommand_options.yaml file that is user-facing; altering this file will
+      alter the options subcommand execution. Subsequent subcommand execution,
+      such as `provision`, will result in beaker making modifications to this file
+      as necessary.
     LONGDESC
-    def init(hypervisor='vagrant')
+    option :help, :type => :boolean, :hide => true
+    def init()
       if options[:help]
         invoke :help, [], ["init"]
         return
       end
-      SubcommandUtil.verify_init_args(hypervisor)
-      SubcommandUtil.require_tasks()
-      SubcommandUtil.init_hypervisor(hypervisor)
-      say "Writing host config to .beaker/acceptance/config/default_#{hypervisor}_hosts.yaml"
-      SubcommandUtil.store_config({:hypervisor => hypervisor})
-      SubcommandUtil.delete_config([:provisioned])
+
+      @cli.parse_options
+
+      # delete unnecessary keys for saving the options
+      options_to_write = @cli.configured_options
+      # Remove keys we don't want to save
+      [:timestamp, :logger, :command_line, :beaker_version, :hosts_file].each do |key|
+        options_to_write.delete(key)
+      end
+
+      options_to_write = SubcommandUtil.sanitize_options_for_save(options_to_write)
+
+      @cli.logger.notify 'Writing configured options to disk'
+      File.open(SubcommandUtil::SUBCOMMAND_OPTIONS, 'w') do |f|
+        f.write(options_to_write.to_yaml)
+      end
+      @cli.logger.notify "Options written to #{SubcommandUtil::SUBCOMMAND_OPTIONS}"
+
+      state = YAML::Store.new(SubcommandUtil::SUBCOMMAND_STATE)
+      state.transaction do
+        state['provisioned'] = false
+      end
     end
 
-    desc "provision", "Provisions the beaker test configuration"
-    option :validate, :type => :boolean, :default => true
-    option :configure, :type => :boolean, :default => true
-    option :help, :type => :boolean, :hide => true
+    desc "provision", "Provisions the beaker systems under test(SUTs)"
     long_desc <<-LONGDESC
-    Provisions a beaker configuration
+    Provisions hosts defined in your subcommand_options file. You can pass the --hosts
+    flag here to override any hosts provided there. Really, you can pass most any beaker
+    flag here to override.
     LONGDESC
+    option :help, :type => :boolean, :hide => true
     def provision()
       if options[:help]
         invoke :help, [], ["provision"]
         return
       end
 
-      hypervisor = @@config.transaction { @@config[:hypervisor] }
+      state = YAML::Store.new(SubcommandUtil::SUBCOMMAND_STATE)
+      if state.transaction { state['provisioned']}
+        SubcommandUtil.error_with('Provisioned SUTs detected. Please destroy and reprovision.')
+      end
+
+      @cli.parse_options
+      @cli.provision
+
+      # Sanitize the hosts
+      cleaned_hosts = SubcommandUtil.sanitize_options_for_save(@cli.combined_instance_and_options_hosts)
+
+      # Update each host provisioned with a flag indicating that it no longer needs
+      # provisioning
+      cleaned_hosts.each do |host, host_hash|
+        host_hash['provision'] = false
+      end
+
+      # should we only update the options here with the new host? Or update the settings
+      # with whatever new flags may have been provided with provision?
+      options_storage = YAML::Store.new(SubcommandUtil::SUBCOMMAND_OPTIONS)
+      options_storage.transaction do
+        @cli.logger.notify 'updating HOSTS key in subcommand_options'
+        options_storage['HOSTS'] = cleaned_hosts
+        options_storage['hosts_preserved_yaml_file'] = @cli.options[:hosts_preserved_yaml_file]
+      end
+
+      @cli.preserve_hosts_file
+
+      state.transaction do
+        state['provisioned'] = true
+      end
+    end
+
+    desc 'exec FILE/BEAKER_SUITE', 'execute a directory, file, or beaker suite'
+    long_desc <<-LONG_DESC
+    Run a single file, directory, or beaker suite. If supplied a file or directory,
+    that resource will be run in the context of the `tests` suite; If supplied a beaker
+    suite, then just that suite will run. If no resource is supplied, then this command
+    executes the suites as they are defined in the configuration.
+    LONG_DESC
+    option :help, :type => :boolean, :hide => true
+    def exec(resource=nil)
+      if options[:help]
+        invoke :help, [], ["exec"]
+        return
+      end
+
+      @cli.parse_options
+      @cli.initialize_network_manager
 
-      unless hypervisor
-        SubcommandUtil.error_with("Please initialise a configuration")
+      if !resource
+        @cli.execute!
+        return
       end
 
-      provisioned = @@config.transaction { @@config[:provisioned] }
+      beaker_suites = [:pre_suite, :tests, :post_suite, :pre_cleanup]
 
-      if !provisioned or options[:force]
-        SubcommandUtil.provision(hypervisor, options)
-        SubcommandUtil.store_config({:provisioned => true})
+      if Pathname(resource).exist?
+        # If we determine the resource is a valid file resource, then we empty
+        # all the suites and run that file resource in the tests suite. In the
+        # future, when we have the ability to have custom suites, we should change
+        # this to run in a custom suite. You know, in the future.
+        beaker_suites.each do |suite|
+          @cli.options[suite] = []
+        end
+        if Pathname(resource).directory?
+          @cli.options[:tests] = Dir.glob("#{Pathname(resource).expand_path}/*.rb")
+        else
+          @cli.options[:tests] = [Pathname(resource).expand_path.to_s]
+        end
+      elsif resource.match(/pre-suite|tests|post-suite|pre-cleanup/)
+        # The regex match here is loose so that users can supply multiple suites,
+        # such as `beaker exec pre-suite,tests`.
+        beaker_suites.each do |suite|
+          @cli.options[suite] = [] unless resource.gsub(/-/, '_').match(suite.to_s)
+        end
       else
-        say "Hosts have already been provisioned"
+        raise ArgumentError, "Unable to parse #{resource} with beaker exec"
       end
+      @cli.execute!
+    end
+
+    desc "destroy", "Destroys the provisioned VMs"
+    long_desc <<-LONG_DESC
+    Destroys the currently provisioned VMs
+    LONG_DESC
+    option :help, :type => :boolean, :hide => true
+    def destroy()
+      if options[:help]
+        invoke :help, [], ["destroy"]
+        return
+      end
+
+      state = YAML::Store.new(SubcommandUtil::SUBCOMMAND_STATE)
+      unless state.transaction { state['provisioned']}
+        SubcommandUtil.error_with('Please provision an environment')
+      end
+
+      @cli.parse_options
+      @cli.options[:provision] = false
+      @cli.initialize_network_manager
+      @cli.network_manager.cleanup
+
+      state.transaction {
+        state.delete('provisioned')
+      }
     end
   end
 end

data/lib/beaker/subcommands/subcommand_util.rb

@@ -1,3 +1,4 @@
+require 'json'
 require 'rake'
 require 'stringio'
 require 'yaml/store'
@@ -7,87 +8,27 @@ module Beaker
   module Subcommands
     # Methods used in execution of Subcommands
     # - should we execute a subcommand?
-    # - reset ARGV
-    # - execute Beaker
-    # - update a rakefile to require beaker quickstart tasks
-    # - initialise a rake application
-    # - execute a rake task
-    # - execute the vagrant quickstart task
-    # - execute the vmpooler quickstart task
+    # - sanitize options for saving as json
     # - exit with a specific message
-    # - execute the quick start task for the specified hypervisor
     # - capture stdout and stderr
     module SubcommandUtil
-      BEAKER_REQUIRE = "require 'beaker/tasks/quick_start'"
-      HYPERVISORS = ["vagrant", "vmpooler"]
       CONFIG_DIR = ".beaker"
-      CONFIG_KEYS = [:hypervisor, :provisioned]
+      SUBCOMMAND_OPTIONS = Pathname("#{CONFIG_DIR}/subcommand_options.yaml")
+      SUBCOMMAND_STATE = Pathname("#{CONFIG_DIR}/.subcommand_state.yaml")
+      PERSISTED_HOSTS = Pathname("#{CONFIG_DIR}/.hosts.yaml")
+      PERSISTED_HYPERVISORS = Pathname("#{CONFIG_DIR}/.hypervisors.yaml")
 
-      # Check if the first argument to the beaker execution is a subcommand
-      # @return [Boolean] true if argv[0] is "help" or a method defined in the Subcommands class, false otherwise
       def self.execute_subcommand?(arg0)
         return false if arg0.nil?
         (Beaker::Subcommand.instance_methods(false) << :help).include? arg0.to_sym
       end
 
-      # Reset ARGV to contain the arguments determined by a specific subcommand
-      # @param [Array<String>] args the arguments determined by a specific subcommand
-      def self.reset_argv(args)
-        ARGV.clear
-        args.each do |arg|
-          ARGV << arg
-        end
-      end
-
-      # Update ARGV and call Beaker
-      # @param [Array<String>] args the arguments determined by a specific subcommand
-      def self.execute_beaker(*args)
-        reset_argv(args)
-        Beaker::CLI.new.execute!
-      end
-
-      # Determines what Rakefile to use
-      # @return [String] the name of the rakefile to use
-      def self.determine_rake_file()
-        rake_app.find_rakefile_location() ? rake_app.find_rakefile_location()[0] : "Rakefile"
-      end
-
-      # Check for the presence of a Rakefile containing the require of the
-      # quick start tasks
-      def self.require_tasks()
-        rake_file = determine_rake_file()
-        FileUtils.touch(rake_file)
-        unless File.readlines(rake_file).grep(/#{BEAKER_REQUIRE}/).any?
-          File.open(rake_file, "a+") { |f| f.puts(BEAKER_REQUIRE) }
-        end
-      end
-
-      # Initialises a rake application
-      # @return [Object] a rake application
-      def self.rake_app()
-        unless @rake_app
-          ARGV.clear
-          @rake_app = Rake.application
-          @rake_app.init
-        end
-        @rake_app
-      end
-
-      # Clear ARGV and execute a Rake task
-      # @param [String] task the rake task to execute
-      def self.execute_rake_task(task)
-        rake_app.load_rakefile()
-        with_captured_output { rake_app.invoke_task(task) }
-      end
-
-      # Execute the quick start task for vagrant
-      def self.init_vagrant()
-        execute_rake_task("beaker_quickstart:gen_hosts[vagrant]")
-      end
-
-      # Execute the quick start task for vmpooler
-      def self.init_vmpooler()
-        execute_rake_task("beaker_quickstart:gen_hosts[vmpooler]")
+      def self.sanitize_options_for_save(options)
+        # God help us, the YAML library won't stop adding tags to objects, so this
+        # hack is a way to force the options into the basic object types so that
+        # an eventual YAML.dump or .to_yaml call doesn't add tags.
+        # Relevant stackoverflow: http://stackoverflow.com/questions/18178098/how-do-i-have-ruby-yaml-dump-a-hash-subclass-as-a-simple-hash
+        JSON.parse(options.to_json)
       end
 
       # Print a message to the console and exit with specified exit code, defaults to 1
@@ -100,25 +41,6 @@ module Beaker
         exit(exit_code)
       end
 
-      # Call the quick start task for the specified hypervisor
-      # @param [String] hypervisor the hypervisor we want to query
-      def self.init_hypervisor(hypervisor)
-        case hypervisor
-        when "vagrant"
-          init_vagrant
-        when "vmpooler"
-          init_vmpooler
-        end
-      end
-
-      # Verify that a valid hypervisor has been specified
-      # @param [String] hypervisor the hypervisor we want to validate
-      def self.verify_init_args(hypervisor)
-        unless HYPERVISORS.include?(hypervisor)
-          error_with("Invalid hypervisor. Currently supported hypervisors are: #{HYPERVISORS.join(', ')}")
-        end
-      end
-
       # Execute a task but capture stdout and stderr to a buffer
       def self.with_captured_output
         begin
@@ -133,41 +55,6 @@ module Beaker
         end
       end
 
-      # Initialise the beaker config
-      def self.init_config()
-        FileUtils.mkdir_p CONFIG_DIR
-        @@store = YAML::Store.new("#{CONFIG_DIR}/config")
-      end
-
-      # Store values from a hash into the beaker config
-      # @param [Hash{Symbol=>String}] config values we want to store
-      def self.store_config(config)
-        @@store.transaction do
-          CONFIG_KEYS.each do |key|
-            @@store[key] = config[key] unless config[key].nil?
-          end
-        end
-      end
-
-      # Delete keys from the beaker configi
-      # @param [Array<Object>] keys the keys we want to delete from the config
-      def self.delete_config(keys)
-        @@store.transaction {
-          keys.each do |key|
-            @@store.delete(key)
-          end
-        }
-      end
-
-      # Reset args and provision nodes
-      # @param [String] hypervisor the hypervisor to use
-      # @param [Array<Object>] options the options to use when provisioning
-      def self.provision(hypervisor, options)
-        reset_argv(["--hosts", "#{CONFIG_DIR}/acceptance/config/default_#{hypervisor}_hosts.yaml", "--validate", options[:validate], "--configure", options[:configure]])
-        beaker = Beaker::CLI.new.parse_options
-        beaker.provision
-        beaker.preserve_hosts_file
-      end
     end
   end
 end

data/lib/beaker/version.rb

@@ -1,5 +1,5 @@
 module Beaker
   module Version
-    STRING = '3.13.0'
+    STRING = '3.14.0'
   end
 end

data/spec/beaker/cli_spec.rb

@@ -50,6 +50,36 @@ module Beaker
       Beaker::CLI.new.parse_options
     }
 
+    context '#configured_options' do
+      it 'returns a list of options that were not presets' do
+        attribution = cli.instance_variable_get(:@attribution)
+        attribution.each do |attribute, setter|
+          if setter == 'preset'
+            expect(cli.configured_options[attribute]).to be_nil
+          end
+        end
+      end
+    end
+
+    context '#combined_instance_and_options_hosts' do
+      let (:options_host) { {'HOSTS' => {'ubuntu' => {:options_attribute => 'options'}} }}
+      let (:instance_host ) {
+        [Beaker::Host.create('ubuntu', {:platform => 'host'}, {} )]
+      }
+      before do
+        cli.instance_variable_set(:@options, options_host)
+        cli.instance_variable_set(:@hosts, instance_host)
+      end
+      it 'combines the options and instance host objects' do
+        merged_host = cli.combined_instance_and_options_hosts
+        expect(merged_host).to have_key('ubuntu')
+        expect(merged_host['ubuntu']).to have_key(:options_attribute)
+        expect(merged_host['ubuntu']).to have_key(:platform)
+        expect(merged_host['ubuntu'][:options_attribute]).to eq('options')
+        expect(merged_host['ubuntu'][:platform]).to eq('host')
+      end
+    end
+
     context 'execute!' do
       before :each do
        stub_const("Beaker::Logger", double().as_null_object )
@@ -503,6 +533,7 @@ module Beaker
           expect( answer.start_with?(command_correct) ).to be_truthy
         end
       end
+
     end
   end
 end