beaker 2.7.1 → 2.8.0

data/lib/beaker/dsl/install_utils/ezbake_utils.rb

@@ -0,0 +1,256 @@
+require 'fileutils'
+
+module Beaker
+  module DSL
+    module InstallUtils
+      # This module contains methods to assist in installing projects from source
+      # that use ezbake for packaging.
+      #
+      module EZBakeUtils
+
+        # @!group Public DSL Methods
+
+        # Installs leiningen project with given name and version on remote host.
+        #
+        # @param [Host] host A single remote host on which to install the
+        #   specified leiningen project.
+        def install_from_ezbake host
+          ezbake_validate_support host
+          ezbake_tools_available?
+          install_ezbake_tarball_on_host host
+          ezbake_installsh host, "service"
+        end
+
+        # Installs termini with given name and version on remote host.
+        #
+        # @param [Host] host A single remote host on which to install the
+        #   specified leiningen project.
+        def install_termini_from_ezbake host
+          ezbake_validate_support host
+          ezbake_tools_available?
+          install_ezbake_tarball_on_host host
+          ezbake_installsh host, "termini"
+        end
+
+        # Install a development version of ezbake into the local m2 repository
+        #
+        # This can be useful if you want to work on a development branch of
+        # ezbake that hasn't been released yet. Ensure your project dependencies
+        # in your development branch include a reference to the -SNAPSHOT
+        # version of the project for it to successfully pickup a pre-shipped
+        # version of ezbake.
+        #
+        # @param url [String] git url
+        # @param branch [String] git branch
+        def ezbake_dev_build url = "git@github.com:puppetlabs/ezbake.git",
+                             branch = "master"
+          ezbake_dir = 'tmp/ezbake'
+          conditionally_clone url, ezbake_dir, branch
+          lp = ezbake_lein_prefix
+
+          Dir.chdir(ezbake_dir) do
+            ezbake_local_cmd "#{lp} install",
+                              :throw_on_failure => true
+          end
+        end
+
+        # @!endgroup
+
+        class << self
+          attr_accessor :config
+        end
+
+        # @!group Private helpers
+
+        # Test for support in one place
+        #
+        # @param [Host] host host to check for support
+        # @raise [RuntimeError] if OS is not supported
+        # @api private
+        def ezbake_validate_support host
+          variant, version, _, _ = host['platform'].to_array
+          unless variant =~ /^(fedora|el|centos|debian|ubuntu)$/
+            raise RuntimeError,
+                  "No support for #{variant} within ezbake_utils ..."
+          end
+        end
+
+        # Build, copy & unpack tarball on remote host
+        #
+        # @param [Host] host installation destination
+        # @api private
+        def install_ezbake_tarball_on_host host
+          if not ezbake_config
+            ezbake_stage
+          end
+
+          # Skip installation if the remote directory exists
+          result = on host, "test -d #{ezbake_install_dir}", :acceptable_exit_codes => [0, 1]
+          return if result.exit_code == 0
+
+          ezbake_staging_dir = File.join('target', 'staging')
+          Dir.chdir(ezbake_staging_dir) do
+            ezbake_local_cmd 'rake package:tar'
+          end
+
+          local_tarball = ezbake_staging_dir + "/pkg/" + ezbake_install_name + ".tar.gz"
+          remote_tarball = ezbake_install_dir + ".tar.gz"
+          scp_to host, local_tarball, remote_tarball
+
+          # untar tarball on host
+          on host, "tar -xzf " + remote_tarball
+
+          # Check to ensure directory exists
+          on host, "test -d #{ezbake_install_dir}"
+        end
+
+        LOCAL_COMMANDS_REQUIRED = [
+          ['leiningen', 'lein --version', nil],
+          ['lein-pprint', 'lein with-profile ci pprint :version',
+            'Must have lein-pprint installed under the :ci profile.'],
+          ['java', 'java -version', nil],
+          ['git', 'git --version', nil],
+          ['rake', 'rake --version', nil],
+        ]
+
+        # Checks given host for the tools necessary to perform
+        # install_from_ezbake.
+        #
+        # @raise [RuntimeError] if tool is not found
+        # @api private
+        def ezbake_tools_available?
+          LOCAL_COMMANDS_REQUIRED.each do |software_name, command, additional_error_message|
+            if not system command
+              error_message = "Must have #{software_name} installed on development system.\n"
+              if additional_error_message
+                error_message += additional_error_message
+              end
+              raise RuntimeError, error_message
+            end
+          end
+        end
+
+        # Return the ezbake config.
+        #
+        # @return [Hash] configuration for ezbake, usually from ezbake.rb
+        # @api private
+        def ezbake_config
+          EZBakeUtils.config
+        end
+
+        # Returns a leiningen prefix with local m2 repo capability
+        #
+        # @return [String] lein prefix command that uses a local build
+        #   m2 repository.
+        # @api private
+        def ezbake_lein_prefix
+          # Get the absolute path to the local repo
+          m2_repo = File.join(Dir.pwd, 'tmp', 'm2-local')
+
+          'lein update-in : assoc :local-repo "\"' + m2_repo + '\"" --'
+        end
+
+        # Prepares a staging directory for the specified project.
+        #
+        # @api private
+        def ezbake_stage
+          # Install the PuppetDB jar into the local repository
+          ezbake_local_cmd "#{ezbake_lein_prefix} install",
+                           :throw_on_failure => true
+
+          # Run ezbake stage
+          ezbake_local_cmd "#{ezbake_lein_prefix} with-profile ezbake ezbake stage",
+                           :throw_on_failure => true
+
+          # Boostrap packaging, and grab configuration info from project
+          staging_dir = File.join('target','staging')
+          Dir.chdir(staging_dir) do
+            ezbake_local_cmd 'rake package:bootstrap'
+
+            load 'ezbake.rb'
+            ezbake = EZBake::Config
+            ezbake[:package_version] = `echo -n $(rake pl:print_build_param[ref] | tail -n 1)`
+            EZBakeUtils.config = ezbake
+          end
+        end
+
+        # Executes a local command using system, logging the prepared command
+        #
+        # @param [String] cmd command to execute
+        # @param [Hash] opts options
+        # @option opts [bool] :throw_on_failure If true, throws an
+        #   exception if the exit code is non-zero. Defaults to false.
+        # @return [bool] true if exit == 0 false if otherwise
+        # @raise [RuntimeError] if :throw_on_failure is true and
+        #   command fails
+        # @api private
+        def ezbake_local_cmd cmd, opts={}
+          opts = {
+            :throw_on_failure => false,
+          }.merge(opts)
+
+          logger.notify "localhost $ #{cmd}"
+          result = system cmd
+          if opts[:throw_on_failure] && result == false
+            raise RuntimeError, "Command failure #{cmd}"
+          end
+          result
+        end
+
+        # Retrieve the tarball installation name. This is the name of
+        # the tarball without the .tar.gz extension, and the name of the
+        # path where it will unpack to.
+        #
+        # @return [String] name of the tarball and directory
+        # @api private
+        def ezbake_install_name
+          ezbake = ezbake_config
+          project_package_version = ezbake[:package_version]
+          project_name = ezbake[:project]
+          "%s-%s" % [ project_name, project_package_version ]
+        end
+
+        # Returns the full path to the installed software on the remote host.
+        #
+        # This only returns the path, it doesn't work out if its installed or
+        # not.
+        #
+        # @return [String] path to the installation dir
+        # @api private
+        def ezbake_install_dir
+          "/root/#{ezbake_install_name}"
+        end
+
+        # A helper that wraps the execution of install.sh in the proper
+        # ezbake installation directory.
+        #
+        # @param [Host] host Host to run install.sh on
+        # @param [String] task Task to execute with install.sh
+        # @api private
+        def ezbake_installsh host, task=""
+          on host, "cd #{ezbake_install_dir}; bash install.sh #{task}"
+        end
+
+        # Only clone from given git URI if there is no existing git clone at the
+        # given local_path location.
+        #
+        # @param [String] upstream_uri git URI
+        # @param [String] local_path path to conditionally install to
+        # @param [String] branch to checkout
+        # @api private
+        def conditionally_clone upstream_uri, local_path, branch="origin/HEAD"
+          if ezbake_local_cmd "git --work-tree=#{local_path} --git-dir=#{local_path}/.git status"
+            ezbake_local_cmd "git --work-tree=#{local_path} --git-dir=#{local_path}/.git fetch origin"
+            ezbake_local_cmd "git --work-tree=#{local_path} --git-dir=#{local_path}/.git checkout #{branch}"
+          else
+            parent_dir = File.dirname(local_path)
+            FileUtils.mkdir_p(parent_dir)
+            ezbake_local_cmd "git clone #{upstream_uri} #{local_path}"
+            ezbake_local_cmd "git --work-tree=#{local_path} --git-dir=#{local_path}/.git checkout #{branch}"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/beaker/dsl/install_utils/module_utils.rb

@@ -0,0 +1,237 @@
+module Beaker
+  module DSL
+    module InstallUtils
+      #
+      # This module contains methods to help install puppet modules
+      #
+      # To mix this is into a class you need the following:
+      # * a method *hosts* that yields any hosts implementing
+      #   {Beaker::Host}'s interface to act upon.
+      # * a method *options* that provides an options hash, see {Beaker::Options::OptionsHash}
+      # * the module {Beaker::DSL::Roles} that provides access to the various hosts implementing
+      #   {Beaker::Host}'s interface to act upon
+      # * the module {Beaker::DSL::Wrappers} the provides convenience methods for {Beaker::DSL::Command} creation
+      module ModuleUtils
+
+        # The directories in the module directory that will not be scp-ed to the test system when using 
+        # `copy_module_to`
+        PUPPET_MODULE_INSTALL_IGNORE = ['.bundle', '.git', '.idea', '.vagrant', '.vendor', 'vendor', 'acceptance',
+                                        'bundle', 'spec', 'tests', 'log']
+
+        # Install the desired module on all hosts using either the PMT or a
+        #   staging forge
+        #
+        # @see install_dev_puppet_module
+        def install_dev_puppet_module_on( host, opts )
+          if options[:forge_host]
+            with_forge_stubbed_on( host ) do
+              install_puppet_module_via_pmt_on( host, opts )
+            end
+          else
+            copy_module_to( host, opts )
+          end
+        end
+        alias :puppet_module_install_on :install_dev_puppet_module_on
+
+        # Install the desired module on all hosts using either the PMT or a
+        #   staging forge
+        #
+        # Passes options through to either `install_puppet_module_via_pmt_on`
+        #   or `copy_module_to`
+        #
+        # @param opts [Hash]
+        #
+        # @example Installing a module from the local directory
+        #   install_dev_puppet_module( :source => './', :module_name => 'concat' )
+        #
+        # @example Installing a module from a staging forge
+        #   options[:forge_host] = 'my-forge-api.example.com'
+        #   install_dev_puppet_module( :source => './', :module_name => 'concat' )
+        #
+        # @see install_puppet_module_via_pmt
+        # @see copy_module_to
+        def install_dev_puppet_module( opts )
+          block_on( hosts ) {|h| install_dev_puppet_module_on( h, opts ) }
+        end
+        alias :puppet_module_install :install_dev_puppet_module
+
+        # Install the desired module with the PMT on a given host
+        #
+        # @param opts [Hash]
+        # @option opts [String] :module_name The short name of the module to be installed
+        # @option opts [String] :version The version of the module to be installed
+        def install_puppet_module_via_pmt_on( host, opts = {} )
+          block_on host do |h|
+            version_info = opts[:version] ? "-v #{opts[:version]}" : ""
+            if opts[:source]
+              author_name, module_name = parse_for_modulename( opts[:source] )
+              modname = "#{author_name}-#{module_name}"
+            else
+              modname = opts[:module_name]
+            end
+
+            puppet_opts = {}
+            if host[:default_module_install_opts].respond_to? :merge
+              puppet_opts = host[:default_module_install_opts].merge( puppet_opts )
+            end
+
+            on h, puppet("module install #{modname} #{version_info}", puppet_opts)
+          end
+        end
+
+        # Install the desired module with the PMT on all known hosts
+        # @see #install_puppet_module_via_pmt_on
+        def install_puppet_module_via_pmt( opts = {} )
+          install_puppet_module_via_pmt_on(hosts, opts)
+        end
+
+        # Install local module for acceptance testing
+        # should be used as a presuite to ensure local module is copied to the hosts you want, particularly masters
+        # @param [Host, Array<Host>, String, Symbol] one_or_more_hosts
+        #                   One or more hosts to act upon,
+        #                   or a role (String or Symbol) that identifies one or more hosts.
+        # @option opts [String] :source ('./')
+        #                   The current directory where the module sits, otherwise will try
+        #                         and walk the tree to figure out
+        # @option opts [String] :module_name (nil)
+        #                   Name which the module should be installed under, please do not include author,
+        #                     if none is provided it will attempt to parse the metadata.json and then the Module file to determine
+        #                     the name of the module
+        # @option opts [String] :target_module_path (host['distmoduledir']/modules)
+        #                   Location where the module should be installed, will default
+        #                    to host['distmoduledir']/modules
+        # @option opts [Array] :ignore_list
+        # @option opts [String] :protocol
+        #                   Name of the underlying transfer method. Valid options are 'scp' or 'rsync'.
+        # @raise [ArgumentError] if not host is provided or module_name is not provided and can not be found in Modulefile
+        #
+        def copy_module_to(one_or_more_hosts, opts = {})
+          block_on one_or_more_hosts do |host|
+            opts = {:source => './',
+                    :target_module_path => host['distmoduledir'],
+                    :ignore_list => PUPPET_MODULE_INSTALL_IGNORE}.merge(opts)
+            ignore_list = build_ignore_list(opts)
+            target_module_dir = on( host, "echo #{opts[:target_module_path]}" ).stdout.chomp
+            source_path = File.expand_path( opts[:source] )
+            source_dir = File.dirname(source_path)
+            source_name = File.basename(source_path)
+            if opts.has_key?(:module_name)
+              module_name = opts[:module_name]
+            else
+              _, module_name = parse_for_modulename( source_path )
+            end
+
+            opts[:protocol] ||= 'scp'
+            case opts[:protocol]
+              when 'scp'
+                #move to the host
+                scp_to host, source_path, target_module_dir, {:ignore => ignore_list}
+                #rename to the selected module name, if not correct
+                cur_path = File.join(target_module_dir, source_name)
+                cur_path = File.join(target_module_dir, source_name)
+                new_path = File.join(target_module_dir, module_name)
+                if cur_path != new_path
+                  # NOTE: this will need to be updated to handle powershell only windows SUTs
+                  on host, "mv #{cur_path} #{new_path}"
+                end
+              when 'rsync'
+                rsync_to host, source, File.join(target_module_dir, module_name), {:ignore => ignore_list}
+              else
+                logger.debug "Unsupported transfer protocol, returning nil"
+                nil
+            end
+          end
+        end
+        alias :copy_root_module_to :copy_module_to
+
+        #Recursive method for finding the module root
+        # Assumes that a Modulefile exists
+        # @param [String] possible_module_directory
+        #                   will look for Modulefile and if none found go up one level and try again until root is reached
+        #
+        # @return [String,nil]
+        def parse_for_moduleroot(possible_module_directory)
+          if File.exists?("#{possible_module_directory}/Modulefile") || File.exists?("#{possible_module_directory}/metadata.json")
+            possible_module_directory
+          elsif possible_module_directory === '/'
+            logger.error "At root, can't parse for another directory"
+            nil
+          else
+            logger.debug "No Modulefile or metadata.json found at #{possible_module_directory}, moving up"
+            parse_for_moduleroot File.expand_path(File.join(possible_module_directory,'..'))
+          end
+        end
+
+        #Parse root directory of a module for module name
+        # Searches for metadata.json and then if none found, Modulefile and parses for the Name attribute
+        # @param [String] root_module_dir
+        # @return [String] module name
+        def parse_for_modulename(root_module_dir)
+          author_name, module_name = nil, nil
+          if File.exists?("#{root_module_dir}/metadata.json")
+            logger.debug "Attempting to parse Modulename from metadata.json"
+            module_json = JSON.parse(File.read "#{root_module_dir}/metadata.json")
+            if(module_json.has_key?('name'))
+              author_name, module_name = get_module_name(module_json['name'])
+            end
+          end
+          if !module_name && File.exists?("#{root_module_dir}/Modulefile")
+            logger.debug "Attempting to parse Modulename from Modulefile"
+            if /^name\s+'?(\w+-\w+)'?\s*$/i.match(File.read("#{root_module_dir}/Modulefile"))
+              author_name, module_name = get_module_name(Regexp.last_match[1])
+            end
+          end
+          if !module_name && !author_name
+            logger.debug "Unable to determine name, returning null"
+          end
+          return author_name, module_name
+        end
+
+        #Parse modulename from the pattern 'Auther-ModuleName'
+        #
+        # @param [String] author_module_name <Author>-<ModuleName> pattern
+        #
+        # @return [String,nil]
+        #
+        def get_module_name(author_module_name)
+          split_name = split_author_modulename(author_module_name)
+          if split_name
+            return split_name[:author], split_name[:module]
+          end
+        end
+
+        #Split the Author-Name into a hash
+        # @param [String] author_module_attr
+        #
+        # @return [Hash<Symbol,String>,nil] :author and :module symbols will be returned
+        #
+        def split_author_modulename(author_module_attr)
+          result = /(\w+)-(\w+)/.match(author_module_attr)
+          if result
+            {:author => result[1], :module => result[2]}
+          else
+            nil
+          end
+        end
+
+        # Build an array list of files/directories to ignore when pushing to remote host
+        # Automatically adds '..' and '.' to array.  If not opts of :ignore list is provided
+        # it will use the static variable PUPPET_MODULE_INSTALL_IGNORE
+        #
+        # @param opts [Hash]
+        # @option opts [Array] :ignore_list A list of files/directories to ignore
+        def build_ignore_list(opts = {})
+          ignore_list = opts[:ignore_list] || PUPPET_MODULE_INSTALL_IGNORE
+          if !ignore_list.kind_of?(Array) || ignore_list.nil?
+            raise ArgumentError "Ignore list must be an Array"
+          end
+          ignore_list << '.' unless ignore_list.include? '.'
+          ignore_list << '..' unless ignore_list.include? '..'
+          ignore_list
+        end
+
+      end
+    end
+
+  end
+end