beaker 2.27.0 → 2.28.0

data/docs/hosts/README.md

@@ -0,0 +1,8 @@
+# The Hosts Directory
+
+This directory contains docs explaining any peculiarities or details of a particular
+OS's host implementation.
+
+If you don't see a file here for an OS, then it's either not yet documented
+(feel free to help us out here!), or it should conform to our normal host 
+abstraction assumptions.

data/docs/hosts/eos.md

@@ -0,0 +1,30 @@
+# EOS - Arista
+
+EOS is the network device OS from Arista. You can get more details from their
+[product page](https://www.arista.com/en/products/eos).
+
+# Supported Hypervisors
+
+EOS has only been developed and tested as a
+[vmpooler](https://github.com/puppetlabs/vmpooler) host.
+
+This doesn't mean that it can't be used in another hypervisor, but that
+Beaker doesn't specifically deal with the details of that hypervisor in creating
+EOS hosts, if there is anything specific to EOS that will need to be done in
+provisioning steps.
+
+# Supported Installation Methods
+
+## Puppet Enterprise
+
+`install_pe` should "just work".
+
+## Open Source
+
+In order to install a puppet-agent against an EOS host, you'll have to use the
+[`install_puppet_agent_dev_repo_on`](blob/master/lib/beaker/dsl/install_utils/foss_utils.rb#L1085)
+method.
+
+It reaches out to the EOS-specific host code for any information that it needs.
+You can check out [these methods](blob/master/lib/beaker/host/eos.rb) if you
+need more information about this.

data/docs/hypervisors/README.md

@@ -0,0 +1,8 @@
+# The Hypervisors Directory
+
+This directory contains docs explaining any peculiarities or details of a particular
+hypervisor's implementation.
+
+If you don't see a file here for a hypervisor, then it's either not yet documented
+(feel free to help us out here!), or it should conform to our normal hypervisor
+assumptions.

data/docs/hypervisors/aws.md

@@ -0,0 +1,143 @@
+# Amazon Web Services - Elastic Compute Cloud (EC2)
+
+EC2 is a "web service that provides resizable compute capacity in the cloud."
+
+[EC2 site](https://aws.amazon.com/ec2/).
+
+# Getting Started
+
+### Requirements
+
+- Get EC2 access from your IT dept, particularly your `aws_access_key_id` & `aws_secret_access_key`.
+- put these values into your [~/.fog file](http://fog.io/about/getting_started.html).
+
+### Setup Amazon Image Config
+
+The Amazon Image Config file in Beaker is the file that specifies which Amazon
+Machine Image (AMI) should be used for a host and which EC2 region that host
+should be generated into.
+
+The text in this file follows this form:
+
+    AMI:
+      <host-vmname-value>:
+        :image:
+          :<type>: <ami-id>
+          :<type>: <ami-id>
+        :region: <region-id>
+      <host-vmname-value>:
+        ...
+
+The `host-vmname-value` is an ID used to reference one of these particular AMI
+definitions. It is applied to a host via the `vmname` key in the hosts file.
+
+The `type` variable is an arbitrary key that you can use to specify the different
+types of that host platform that you can be testing with. Note that this value
+will be grabbed automatically via the value for the host's `snapshot` key.
+For example, we tend to use `:pe` and `:foss` for these values.
+
+The `ami-id` variable is the AMI ID as specified by Amazon. You can see the AMI
+ID pattern in EC2's
+[Find a Linux AMI]
+(http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/finding-an-ami.html)
+page, particularly in the "using the Images page" section's step 7. For some
+examples of AMI IDs, check out their
+[Amazon Linux AMI page](https://aws.amazon.com/amazon-linux-ami/).
+
+The `region-id` variable represents the EC2 region ID from AWS. For reference,
+checkout EC2's 
+[Regions and Availability Zones page]
+(http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html).
+An example of a region ID is `eu-west-1` for the Ireland data center.
+
+This file is by default located at `config/image_templates/ec2.yaml`. This is a
+relative path from Beaker's execution location, and can be overridden using the
+`:ec2_yaml` key in a CONFIG section of a host file if required.
+
+### Create a Hosts File to Use
+
+An EC2 hosts file looks like a typical hosts file, except that there are a
+number of required properties that need to be added to every host in order for
+the AWS hypervisor to provision hosts properly.  They come in this form:
+
+    <hostname>:
+      <usual stuff, roles, etc>
+      vmname: <host-vmname-value>
+      hypervisor: ec2
+      snapshot: <type>
+      amisize: <ami-size>
+
+The `host-vmname-value` references the ID created in the Amazon Image Config file
+above.  If not provided, Beaker will try to name an AMI Config using the host's
+platform string.
+
+The `type` references the type variable in the Amazon Image Config file as well,
+so this key picks out the particular AMI ID from the set available for this type
+of host platform.
+
+The `ami-size` variable refers to
+[instance types](https://aws.amazon.com/ec2/instance-types/) by their model name.
+Some examples of these values are "m3.large", "c4.xlarge", and "r3.8xlarge". The
+default value if this key is not provided used by Beaker is "m1.small".
+      
+
+# AWS Keys
+
+For any particular Beaker run, a new EC2 ssh key with a name of the form
+
+    Beaker-<username>-<sanitized_hostname>-<aws_keyname_modifier>-<readable_timestamp>
+
+will be created at the beginning of the run, & cleaned up at the end of the run.
+
+Everything up to `aws_keyname_modifier` will be the same if run from the same
+user on the same machine no matter when it's run. This means that if you're
+running from a CI system, all of these values will usually be the same, depending
+on your setup.
+
+`aws_keyname_modifier` will by default be a 10 digit random number string.
+`readable_timestamp`'s most fine grained unit is nanoseconds. Between the two of
+these, every Beaker run will generate a unique ssh key name.
+
+These keys are deleted automatically as a part of the cleanup process at the end
+of a Beaker run.
+
+# Zombie Killing
+
+If an EC2 host stays around after a Beaker run, we refer to it as a zombie :).
+Normal Beaker execution should not create zombies, but a common use case that
+can result in zombies is using the `--preserve-hosts` options.
+
+If you would like to be sure that you're not running up your EC2 bill via any
+leftover preserved hosts in your EC2 system, we recommend creating a zombie
+killing Beaker job.
+
+To setup a zombie killing job, you'll need a Beaker test that kills all the
+zombies (referred to later as `kill.rb`):
+
+    ec2 = AwsSdk.new( [], options )
+    ec2.kill_zombies( 0 )
+
+Refer to the
+[Rubydoc for the `kill_zombies` method]
+(http://www.rubydoc.info/github/puppetlabs/beaker/Beaker/AwsSdk#kill_zombies-instance_method)
+to learn more about it's
+parameters. Running this should be as simple as this:
+
+    # beaker --tests kill.rb
+
+Note that the second argument is tested as a regex against key names, so you
+could use the key pattern described above to wipeout machines that match a
+pattern such as "Beaker-johnsmith", and it will catch all keys for the "johnsmith"
+user.
+
+### How Do I Find Out My Key Prefix?
+
+In order to find out your key pattern as used by Beaker, just kick off a Beaker
+run to generate an EC2 host. When you do this, you should see lines that look
+like so:
+
+    aws-sdk: Launch instance
+    aws-sdk: Ensure key pair exists, create if not
+    [AWS EC2 200 0.142666 0 retries] describe_key_pairs(:filters=>[{:name=>"key-name",:values=>["Beaker-johnsmith-Johns-Ubuntu-2-local"]}])
+
+The values string in that line is what you're looking for.

data/docs/vSphere-Support.md

@@ -0,0 +1,46 @@
+The harness can use vms and snapshots that live within vSphere as well.
+To do this create a `~/.fog` file with your vSphere credentials:
+
+### example .fog file ###
+
+    :default:
+      :vsphere_server: 'vsphere.example.com'
+      :vsphere_username: 'joe'
+      :vsphere_password: 'MyP@$$w0rd'
+      :vmpooler_token: 'randomtokentext'
+
+The vmpooler_token can be used with https://github.com/puppetlabs/vmpooler. Users with Puppet Labs credentials can follow directions for getting and using tokens at https://confluence.puppetlabs.com/display/QE/Generating+and+using+vmpooler+tokens.
+
+These follow the conventions used by Cloud Provisioner and Fog.
+
+There are two possible `hypervisor` hypervisor-types to use for vSphere testing, `vsphere` and `vcloud`.
+
+### `hypervisor: vsphere`
+This option locates an existing static VM, optionally reverts it to a pre-existing snapshot, and runs tests on it.
+
+### `hypervisor: vcloud`
+This option clones a new VM from a pre-existing template, runs tests on the newly-provisioned clone, then deletes the clone once testing completes.
+
+The `vcloud` option requires a slightly-modified test configuration file, specifying both the target template as well as three additional parameters in the 'CONFIG' section ('datastore', 'resourcepool', and 'folder').
+
+#### example vcloud hosts file ###
+    HOSTS:
+      master-vm:
+        roles:
+          - master
+          - agent
+          - dashboard
+        platform: ubuntu-10.04-amd64
+        template: ubuntu-1004-x86_64
+        hypervisor: vcloud
+      agent-vm:
+        roles:
+          - agent
+        platform: ubuntu-10.04-i386
+        template: ubuntu-1004-i386
+        hypervisor: vcloud
+    CONFIG:
+      consoleport: 443
+      datastore: instance0
+      resourcepool: Delivery/Quality Assurance/FOSS/Dynamic
+      folder: delivery/Quality Assurance/FOSS/Dynamic

data/lib/beaker/dsl/helpers/host_helpers.rb

@@ -396,7 +396,6 @@ module Beaker
           on host, "curl --tlsv1 %s" % cmd, opts, &block
         end
 
-
         def curl_with_retries(desc, host, url, desired_exit_codes, max_retries = 60, retry_interval = 1)
           opts = {
             :desired_exit_codes => desired_exit_codes,
@@ -423,6 +422,8 @@ module Beaker
         # @option opts [Float] :retry_interval (1) number of seconds
         #   that we'll wait between tries
         # @option opts [Boolean] :verbose (false)
+        #
+        # @return [Result] Result object of the last command execution
         def retry_on(host, command, opts = {}, &block)
           option_exit_codes     = opts[:desired_exit_codes]
           option_max_retries    = opts[:max_retries].to_i
@@ -529,7 +530,6 @@ module Beaker
         # @param [String] val The string to 'echo' on the host(s)
         # @return [String, Array<String> The echo'ed value(s) returned by the host(s)
         def echo_on hosts, val
-          #val = val.gsub(/"/, "\"").gsub(/\(/, "\(")
           block_on hosts do |host|
             if host.is_powershell?
               host.exec(Command.new("echo #{val}")).stdout.chomp
@@ -538,8 +538,6 @@ module Beaker
             end
           end
         end
-
-
       end
     end
   end

data/lib/beaker/dsl/helpers/puppet_helpers.rb

@@ -300,8 +300,18 @@ module Beaker
           new_conf
         end
 
+        # Restarts the named puppet service
+        #
+        # @param [Host] host Host the service runs on
+        # @param [String] service Name of the service to restart
+        # @param [Fixnum] curl_retries Number of times to retry the restart command
+        # @param [Fixnum] port Port to check status at
+        #
+        # @return [Result] Result of last status check
         # @!visibility private
-        def bounce_service host, service, curl_retries = 120
+        def bounce_service host, service, curl_retries = nil, port = nil
+          curl_retries = 120 if curl_retries.nil?
+          port = options[:puppetserver_port] if port.nil?
           if host.graceful_restarts?
             apachectl_path = host.is_pe? ? "#{host['puppetsbindir']}/apache2ctl" : 'apache2ctl'
             host.exec(Command.new("#{apachectl_path} graceful"))
@@ -309,7 +319,7 @@ module Beaker
             host.exec puppet_resource('service', service, 'ensure=stopped')
             host.exec puppet_resource('service', service, 'ensure=running')
           end
-          curl_with_retries(" #{service} ", host, "https://localhost:8140", [35, 60], curl_retries)
+          curl_with_retries(" #{service} ", host, "https://localhost:#{port}", [35, 60], curl_retries)
         end
 
         # Runs 'puppet apply' on a remote host, piping manifest through stdin
@@ -382,8 +392,8 @@ module Beaker
         #                      by the caller; this can be used for additional
         #                      validation, etc.
         #
-        # @return [Array<Result>, Result] An array of results, or a result object.
-        #   Check {#run_block_on} for more details on this.
+        # @return [Array<Result>, Result, nil] An array of results, a result object,
+        #   or nil. Check {#run_block_on} for more details on this.
         def apply_manifest_on(host, manifest, opts = {}, &block)
           block_on host do | host |
             on_options = {}
@@ -596,21 +606,45 @@ module Beaker
           stub_forge_on(default, forge_host)
         end
 
-        def sleep_until_puppetdb_started(host)
-          curl_with_retries("start puppetdb", host, "http://localhost:8080", 0, 120)
+        # Waits until a successful curl check has happened against puppetdb
+        #
+        # @param [Host] host Host puppetdb is on
+        # @param [Fixnum] nonssl_port Port to make the HTTP status check over
+        # @param [Fixnum] ssl_port Port to make the HTTPS status check over
+        #
+        # @return [Result] Result of the last HTTPS status check
+        def sleep_until_puppetdb_started(host, nonssl_port = nil, ssl_port = nil)
+          nonssl_port = options[:puppetdb_port_nonssl] if nonssl_port.nil?
+          ssl_port = options[:puppetdb_port_ssl] if ssl_port.nil?
+          curl_with_retries("start puppetdb", host, "http://localhost:#{nonssl_port}", 0, 120)
           curl_with_retries("start puppetdb (ssl)",
-                            host, "https://#{host.node_name}:8081", [35, 60])
+                            host, "https://#{host.node_name}:#{ssl_port}", [35, 60])
         end
 
-        def sleep_until_puppetserver_started(host)
+        # Waits until a successful curl check has happened against puppetserver
+        #
+        # @param [Host] host Host puppetserver is on
+        # @param [Fixnum] port Port to make the HTTPS status check over
+        #
+        # @return [Result] Result of the last HTTPS status check
+        def sleep_until_puppetserver_started(host, port = nil)
+          port = options[:puppetserver_port] if port.nil?
           curl_with_retries("start puppetserver (ssl)",
-                            host, "https://#{host.node_name}:8140", [35, 60])
+                            host, "https://#{host.node_name}:#{port}", [35, 60])
         end
 
-        def sleep_until_nc_started(host)
+        # Waits until a successful curl check has happaned against node classifier
+        #
+        # @param [Host] host Host node classifier is on
+        # @param [Fixnum] port Port to make the HTTPS status check over
+        #
+        # @return [Result] Result of the last HTTPS status check
+        def sleep_until_nc_started(host, port = nil)
+          port = options[:nodeclassifier_port] if port.nil?
           curl_with_retries("start nodeclassifier (ssl)",
-                            host, "https://#{host.node_name}:4433", [35, 60])
+                            host, "https://#{host.node_name}:#{port}", [35, 60])
         end
+
         #stops the puppet agent running on the host
         # @param [Host, Array<Host>, String, Symbol] agent    One or more hosts to act upon,
         #                            or a role (String or Symbol) that identifies one or more hosts.

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

@@ -289,7 +289,7 @@ module Beaker
               host[:version] = opts[:version]
 
               # Certain install paths may not create the config dirs/files needed
-              on host, "mkdir -p #{host['puppetpath']}" unless host[:type] =~ /aio/
+              host.mkdir_p host['puppetpath'] unless host[:type] =~ /aio/
               on host, "echo '' >> #{host.puppet['hiera_config']}"
             end
           end
@@ -592,7 +592,7 @@ module Beaker
           block_on hosts do |host|
             link = "#{opts[:win_download_url]}/#{host['dist']}.msi"
             if not link_exists?( link )
-              raise "Puppet #{version} at #{link} does not exist!"
+              raise "Puppet MSI at #{link} does not exist!"
             end
 
 
@@ -861,11 +861,10 @@ module Beaker
             case variant
             when /^(fedora|el|centos)$/
               variant = (($1 == 'centos') ? 'el' : $1)
+              remote = "%s/puppetlabs-release%s-%s-%s.noarch.rpm" % [opts[:release_yum_repo_url],
+		                                                       repo_name, variant, version]
 
-              rpm = "puppetlabs-release%s-%s-%s.noarch.rpm" % [repo_name, variant, version]
-              remote = URI.join( opts[:release_yum_repo_url], rpm )
-
-              on host, "rpm --replacepkgs -ivh #{remote}"
+	      host.install_package_with_rpm(remote, '--replacepkgs', {:package_proxy => opts[:package_proxy]})
 
             when /^(debian|ubuntu|cumulus)$/
               deb = "puppetlabs-release%s-%s.deb" % [repo_name, codename]
@@ -1107,6 +1106,10 @@ module Beaker
             onhost_copy_base = opts[:copy_dir_external]
 
             case variant
+            when /^eos/
+              release_path_end, release_file = host.get_puppet_agent_package_info(
+                opts[:puppet_collection], opts[:puppet_agent_version] )
+              release_path << release_path_end
             when /^(fedora|el|centos|sles)$/
               variant = ((variant == 'centos') ? 'el' : variant)
               release_path << "#{variant}/#{version}/#{opts[:puppet_collection]}/#{arch}"
@@ -1193,29 +1196,22 @@ module Beaker
               raise "No repository installation step for #{variant} yet..."
             end
 
-            onhost_copied_file = File.join(onhost_copy_base, release_file)
-            fetch_http_file( release_path, release_file, copy_dir_local)
-            scp_to host, File.join(copy_dir_local, release_file), onhost_copy_base
+            if host['platform'] =~ /eos/
+              host.get_remote_file( "#{release_path}/#{release_file}" )
+            else
+              onhost_copied_file = File.join(onhost_copy_base, release_file)
+              fetch_http_file( release_path, release_file, copy_dir_local)
+              scp_to host, File.join(copy_dir_local, release_file), onhost_copy_base
+            end
 
             case variant
+            when /^eos/
+              host.install_from_file( release_file )
             when /^(fedora|el|centos|sles)$/
               on host, "rpm -ivh #{onhost_copied_file}"
             when /^(aix)$/
               # NOTE: AIX does not support repo management. This block assumes
               # that the desired rpm has been mirrored to the 'repos' location.
-              #
-              # NOTE: tar is a dependency for puppet packages on AIX. So,
-              # we install it prior to the 'repo' file.
-              tar_pkg_path = "ftp://ftp.software.ibm.com/aix/freeSoftware/aixtoolbox/RPMS/ppc/tar"
-              if version == "5.3" then
-                tar_pkg_file = "tar-1.14-2.aix5.1.ppc.rpm"
-              else
-                tar_pkg_file = "tar-1.22-1.aix6.1.ppc.rpm"
-              end
-              fetch_http_file( tar_pkg_path, tar_pkg_file, copy_dir_local)
-              scp_to host, File.join(copy_dir_local, tar_pkg_file), onhost_copy_base
-              onhost_copied_tar_file = File.join(onhost_copy_base, tar_pkg_file)
-              on host, "rpm -ivh #{onhost_copied_tar_file}"
 
               # install the repo file
               on host, "rpm -ivh #{onhost_copied_file}"
@@ -1403,9 +1399,10 @@ NOASK
             cmdline_args = ''
             # query packages
             case host[:platform]
+            when /cumulus/
+              pkgs = on(host, "dpkg-query -l  | awk '{print $2}' | grep -E '(^pe-|puppet)'", :acceptable_exit_codes => [0,1]).stdout.chomp.split(/\n+/)
             when /aix/
               pkgs = on(host, "rpm -qa  | grep -E '(^pe-|puppet)'", :acceptable_exit_codes => [0,1]).stdout.chomp.split(/\n+/)
-              pkgs.concat on(host, "rpm -q tar", :acceptable_exit_codes => [0,1]).stdout.chomp.split(/\n+/)
             when /solaris-10/
               cmdline_args = '-a noask'
               pkgs = on(host, "pkginfo | egrep '(^pe-|puppet)' | cut -f2 -d ' '", :acceptable_exit_codes => [0,1]).stdout.chomp.split(/\n+/)