beaker 1.9.1 → 1.10.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YjM4YTIwYzFlZjZlNWZhODY4MWE3ODdiOTVhNzU5ZGEwOTI5MTE2Ng==
+    YmMxMzJlYWRhZjA1M2U5OWUxMGRhZWQ0NWU1Njg2MjA2OGUzNDRkOA==
   data.tar.gz: !binary |-
-    ZTg1Y2Y1NzMzZTE2YjY4OWY3MTE5MDc5NTZjZGMyNWYzZWQyNmFhNg==
+    MzBiMjE4MGVmM2YyOTBiNmUzNzcwNGJhMWYyNTMzYzA0YmI1YzMzMQ==
 SHA512:
   metadata.gz: !binary |-
-    NWZkNWFlZTUxMTdhYWZjNDM3MTJjM2M2MTliNzI2MWVmN2MzN2ZkMzQwYzY5
-    NTM2N2ZmYjZmZWFlMzgxOWJkMmMzNzIyOTgyNTMyMGU3MmRiYjNkOTI0NjI5
-    MTI3MGY2Zjc0YjkwMTc1YmE0OTgxM2YwNWNmYmE3ZmE4OWEwZTY=
+    YzIyOWQ2MGVkNzk2MWZkZTY2NmQ4YzY1NmRjMGI4ZGMxMzEwNjc2YmI1NWFk
+    MjEzY2NhYjdhNjI0MjNjMDIwN2U4MDk5YzEwY2NhNDk2NTg0NWIxMmY4OTFj
+    YTI2MThkNGExNjVmYjIwNmU4OGY5YjQ5NDA0MTY4ZGE1OGI3NGE=
   data.tar.gz: !binary |-
-    OTRhZjk0ODYxZDI2ZWNmZGFiMjVkNTUzNGFhN2I0M2FmMTIwMTVkYjQ0NDJm
-    YmI4MzFhY2I0MzFkNTQyYjYzODA2OTg3MzNhNmQ2MDRjNzI5YTdjZWM3ZTMx
-    OGQwYzlmMjY4OTQwZDg3NGI5Y2M0ZGEwNjZhNDNlNjNhZGZiMWE=
+    YmE3OGU1MGIzMmRjMmM1MGM3MTcwMjdmODM5MzYyYzQ0ZWQyMWQ5N2E4YjQ3
+    NDE2MzQ1YmU0ZDIxOWEwYTAxZDliOTBkOTEwMTQ2ZDJmMTQyNmQ3ZTI3MWU5
+    YWQ1YWE3N2QwYmMyYTRkZjQwMjk2MGJlMGZjMjA4ODVjODEzMDQ=

data/.simplecov

@@ -9,6 +9,7 @@ SimpleCov.configure do
     files = %w(cli.rb logger.rb options_parsing.rb test_config.rb utils/)
     files.any? {|f| file.filename =~ Regexp.new( Regexp.quote(f) ) }
   end
+  add_group 'Hypervisors', '/hypervisor'
 end
 
 SimpleCov.start if ENV['COVERAGE']

data/beaker.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   # Testing dependencies
+  s.add_development_dependency 'minitest', '~> 4.0'
   s.add_development_dependency 'rspec', '~> 2.14.0'
   s.add_development_dependency 'fakefs', '0.4'
   s.add_development_dependency 'rake', '~> 10.1.0'
@@ -39,6 +40,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'blimpy', '~> 0.6'
   s.add_runtime_dependency 'fission', '~> 0.4'
   s.add_runtime_dependency 'google-api-client', '~> 0.6.4'
+  s.add_runtime_dependency 'aws-sdk', '~> 1.38'
 
   # These are transitive dependencies that we include or pin to because...
   # Ruby 1.8 compatibility

data/lib/beaker/dsl/helpers.rb

@@ -472,8 +472,8 @@ module Beaker
           backup_file = backup_the_file(host, host['puppetpath'], testdir, 'puppet.conf')
           lay_down_new_puppet_conf host, conf_opts, testdir
 
-          if host.is_pe?
-            bounce_service( host, 'pe-httpd' )
+          if host['puppetservice']
+            bounce_service( host, host['puppetservice'] )
           else
             puppet_master_started = start_puppet_from_source_on!( host, cmdline_args )
           end
@@ -488,8 +488,8 @@ module Beaker
           begin
             restore_puppet_conf_from_backup( host, backup_file )
 
-            if host.is_pe?
-              bounce_service( host, 'pe-httpd' )
+            if host['puppetservice']
+              bounce_service( host, host['puppetservice'] )
             else
               if puppet_master_started
                 stop_puppet_from_source_on( host )
@@ -631,7 +631,10 @@ module Beaker
         # Any reason to not
         # host.exec puppet_resource( 'service', service, 'ensure=stopped' )
         # host.exec puppet_resource( 'service', service, 'ensure=running' )
-        host.exec( Command.new( "/etc/init.d/#{service} restart" ) )
+        host.exec( Command.new( "#{host['service-prefix']}#{service} restart" ) )
+        if host['service-wait']
+          curl_with_retries(" #{service} ", host, "http://localhost:8140", [0, 52], 120)
+        end
       end
 
       # Blocks until the port is open on the host specified, returns false
@@ -690,6 +693,11 @@ module Beaker
       #                         if `puppet --apply` indicates there were no
       #                         failure during its execution.
       #
+      # @option opts [Boolean]  :future_parser (false) This option enables
+      #                         the future parser option that is available 
+      #                         from Puppet verion 3.2
+      #                         By default it will use the 'current' parser.
+      #
       # @param [Block] block This method will yield to a block of code passed
       #                      by the caller; this can be used for additional
       #                      validation, etc.
@@ -707,6 +715,7 @@ module Beaker
         args = ["--verbose"]
         args << "--parseonly" if opts[:parseonly]
         args << "--trace" if opts[:trace]
+        args << "--parser future" if opts[:future_parser]
 
         # From puppet help:
         # "... an exit code of '2' means there were changes, an exit code of
@@ -872,7 +881,7 @@ module Beaker
       end
 
       def curl_with_retries(desc, host, url, desired_exit_codes, max_retries = 60, retry_interval = 1)
-        retry_command(desc, host, "curl #{url}", desired_exit_codes, max_retries, retry_interval)
+        retry_command(desc, host, "curl -m 1 #{url}", desired_exit_codes, max_retries, retry_interval)
       end
 
       def retry_command(desc, host, command, desired_exit_codes = 0, max_retries = 60, retry_interval = 1)

data/lib/beaker/dsl/install_utils.rb

@@ -454,7 +454,7 @@ module Beaker
             end
             on host, 'curl -O http://apt.puppetlabs.com/puppetlabs-release-$(lsb_release -c -s).deb'
             on host, 'dpkg -i puppetlabs-release-$(lsb_release -c -s).deb'
-            on host, 'apt-get -y -f -m update'
+            on host, 'apt-get update'
             on host, 'apt-get install -y puppet'
           else
             raise "install_puppet() called for unsupported platform '#{host['platform']}' on '#{host.name}'"

data/lib/beaker/host.rb

@@ -92,8 +92,9 @@ module Beaker
       end
     end
 
+    # Return the preferred method to reach the host, will use IP is available and then default to {#hostname}.
     def reachable_name
-      self['ip'] || self['vmhostname'] || name
+      self['ip'] || hostname
     end
 
     # Returning our PuppetConfigReader here allows users of the Host
@@ -116,11 +117,19 @@ module Beaker
       @defaults.has_key?(k)
     end
 
+    # The {#hostname} of this host.
     def to_str
-      @defaults['vmhostname'] || @name
+      hostname
     end
 
+    # The {#hostname} of this host.
     def to_s
+      hostname
+    end
+
+    # Return the public name of the particular host, which may be different then the name of the host provided in
+    # the configuration file as some provisioners create random, unique hostnames.
+    def hostname
       @defaults['vmhostname'] || @name
     end
 
@@ -140,6 +149,16 @@ module Beaker
       end
     end
 
+    #Determine the ip address of this host
+    def get_ip
+      @logger.warn("Uh oh, this should be handled by sub-classes but hasn't been")
+    end
+
+    #Return the ip address of this host
+    def ip
+      self[:ip] ||= get_ip
+    end
+
     def connection
       @connection ||= SshConnection.connect( reachable_name,
                                              self['user'],

data/lib/beaker/host/aix/exec.rb

@@ -0,0 +1,7 @@
+module Aix::Exec
+  include Beaker::CommandFactory
+
+  def get_ip
+    execute("ifconfig -a inet| awk '/broadcast/ {print $2}' | cut -d/ -f1 | head -1").strip
+  end
+end

data/lib/beaker/host/unix.rb

@@ -22,6 +22,9 @@ module Unix
       h.merge({
         'user'          => 'root',
         'group'         => 'pe-puppet',
+        'service-wait'  => false,
+        'service-prefix'=> '/etc/init.d/', 
+        'puppetservice' => 'pe-httpd',
         'puppetpath'    => '/etc/puppetlabs/puppet',
         'puppetbin'     => '/opt/puppet/bin/puppet',
         'puppetbindir'  => '/opt/puppet/bin',
@@ -39,6 +42,7 @@ module Unix
       h.merge({
         'user'              => 'root',
         'group'             => 'puppet',
+        'service-wait'      => false,
         'puppetpath'        => '/etc/puppet',
         'puppetvardir'      => '/var/lib/puppet',
         'puppetbin'         => '/usr/bin/puppet',

data/lib/beaker/host/unix/exec.rb

@@ -12,4 +12,12 @@ module Unix::Exec
   def path
     '/bin:/usr/bin'
   end
+
+  def get_ip
+    if self['platform'].include? 'solaris'
+      execute("ifconfig -a inet| awk '/broadcast/ {print $2}' | cut -d/ -f1 | head -1").strip
+    else
+      execute("ip a|awk '/global/{print$2}' | cut -d/ -f1 | head -1").strip
+    end
+  end
 end

data/lib/beaker/host/windows.rb

@@ -22,6 +22,8 @@ module Windows
       h.merge({
         'user'          => 'Administrator',
         'group'         => 'Administrators',
+        'service-wait'  => false,
+        'puppetservice' => 'pe-httpd',
         'puppetpath'    => '`cygpath -smF 35`/PuppetLabs/puppet/etc',
         'puppetvardir'  => '`cygpath -smF 35`/PuppetLabs/puppet/var',
         #if an x86 Program Files dir exists then use it, default to just Program Files

data/lib/beaker/host/windows/exec.rb

@@ -15,4 +15,15 @@ module Windows::Exec
   def path
     'c:/windows/system32;c:/windows'
   end
+
+  def get_ip
+    ip = execute("ipconfig | grep -i 'IP Address' | cut -d: -f2 | head -1").strip
+    if ip == ''
+      ip = execute("ipconfig | grep -i 'IPv4 Address' | cut -d: -f2 | head -1").strip
+    end
+    if ip == ''
+      ip = execute("ipconfig | grep -i 'IPv6 Address' | cut -d: -f2 | head -1").strip
+    end
+    ip
+  end
 end

data/lib/beaker/host_prebuilt_steps.rb

@@ -199,7 +199,7 @@ module Beaker
         host.map { |h| apt_get_update(h) }
       else
         if host[:platform] =~ /(ubuntu)|(debian)/ 
-          host.exec(Command.new("apt-get -y -f -m update"))
+          host.exec(Command.new("apt-get update"))
         end
       end
     end
@@ -302,8 +302,9 @@ module Beaker
 
     #Determine the ip address of the provided host 
     # @param [Host] host the host to act upon
+    # @deprecated use {Host#get_ip}
     def get_ip(host)
-      host.exec(Command.new("ip a|awk '/global/{print$2}' | cut -d/ -f1 | head -1")).stdout.chomp
+      host.get_ip
     end
 
     #Append the provided string to the /etc/hosts file of the provided host
@@ -378,11 +379,11 @@ module Beaker
       if host.is_a? Array
         host.map { |h| copy_ssh_to_root(h, opts) }
       else
-        if host['platform'] =~ /centos/
+        if host['platform'] =~ /centos|el-|redhat|fedora/
           @logger.debug("Disabling se_linux on #{host.name}")
           host.exec(Command.new("sudo su -c \"setenforce 0\""), {:pty => true})
         else
-          @logger.warn("Attempting to disable SELinux on non-centos platform: #{host.name}: #{host['platform']}")
+          @logger.warn("Attempting to disable SELinux on non-supported platform: #{host.name}: #{host['platform']}")
         end
       end
     end
@@ -396,11 +397,11 @@ module Beaker
       if host.is_a? Array
         host.map { |h| copy_ssh_to_root(h, opts) }
       else
-        if host['platform'] =~ /centos/
+        if host['platform'] =~ /centos|el-|redhat|fedora/
           logger.debug("Disabling iptables on #{host.name}")
           host.exec(Command.new("sudo su -c \"/etc/init.d/iptables stop\""), {:pty => true})
         else
-          logger.warn("Attempting to disable iptables on non-centos platform: #{host.name}: #{host['platform']}")
+          logger.warn("Attempting to disable iptables on non-supported platform: #{host.name}: #{host['platform']}")
         end
       end
     end

data/lib/beaker/hypervisor.rb

@@ -34,6 +34,8 @@ module Beaker
           Beaker::Fusion
         when /blimpy/
           Beaker::Blimper
+        when /ec2/
+          Beaker::AwsSdk
         when /vcloud/
           if options['pooling_api']
             Beaker::VcloudPooled
@@ -89,7 +91,9 @@ module Beaker
 
     #Default validation steps to be run for a given hypervisor
     def validate
-      validate_host(@hosts, @options)
+      if @options[:validate] 
+        validate_host(@hosts, @options)
+      end
     end
 
     #Generate a random straing composted of letter and numbers
@@ -100,7 +104,7 @@ module Beaker
   end
 end
 
-%w( vsphere_helper vagrant fusion blimper vsphere vcloud vcloud_pooled aixer solaris google_compute_helper google_compute).each do |lib|
+%w( vsphere_helper vagrant fusion blimper aws_sdk vsphere vcloud vcloud_pooled aixer solaris google_compute_helper google_compute).each do |lib|
   begin
     require "hypervisor/#{lib}"
   rescue LoadError

data/lib/beaker/hypervisor/aws_sdk.rb

@@ -0,0 +1,389 @@
+require 'aws/ec2'
+require 'set'
+require 'zlib'
+require 'beaker/hypervisor/ec2_helper'
+
+module Beaker
+  # This is an alternate EC2 driver that implements direct API access using
+  # Amazon's AWS-SDK library: http://aws.amazon.com/documentation/sdkforruby/
+  #
+  # It is built for full control, to reduce any other layers beyond the pure
+  # vendor API.
+  class AwsSdk < Beaker::Hypervisor
+    # Initialize AwsSdk hypervisor driver
+    #
+    # @param [Array<Beaker::Host>] hosts Array of Beaker::Host objects
+    # @param [Hash<String, String>] options Options hash
+    def initialize(hosts, options)
+      @hosts = hosts
+      @options = options
+      @logger = options[:logger]
+
+      # Get fog credentials from the local .fog file
+      creds = load_fog_credentials(@options[:dot_fog])
+
+      config = {
+        :access_key_id => creds[:access_key],
+        :secret_access_key => creds[:secret_key],
+        :logger => Logger.new($stdout),
+        :log_level => :debug,
+        :log_formatter => AWS::Core::LogFormatter.colored,
+        :max_retries => 12,
+      }
+      AWS.config(config)
+
+      @ec2 = AWS::EC2.new()
+    end
+
+    # Provision all hosts on EC2 using the AWS::EC2 API
+    #
+    # @return [void]
+    def provision
+      start_time = Time.now
+
+      # Perform the main launch work
+      launch_all_nodes()
+
+      # Wait for each node to reach status :running
+      wait_for_status(:running)
+
+      # Grab the ip addresses and dns from EC2 for each instance to use for ssh
+      populate_dns()
+
+      # Set the hostname for each box
+      set_hostnames()
+
+      # Configure /etc/hosts on each host
+      configure_hosts()
+
+      @logger.notify("aws-sdk: Provisioning complete in #{Time.now - start_time} seconds")
+
+      nil #void
+    end
+
+    # Cleanup all earlier provisioned hosts on EC2 using the AWS::EC2 library
+    #
+    # It goes without saying, but a #cleanup does nothing without a #provision
+    # method call first.
+    #
+    # @return [void]
+    def cleanup
+      @logger.notify("aws-sdk: Cleanup, iterating across all hosts and terminating them")
+      @hosts.each do |host|
+        # This was set previously during provisioning
+        instance = host['instance']
+
+        # Only attempt a terminate if the instance actually is set by provision
+        # and the instance actually 'exists'.
+        if !instance.nil? and instance.exists?
+          instance.terminate
+        end
+      end
+
+      nil #void
+    end
+
+    # Launch all nodes
+    #
+    # This is where the main launching work occurs for each node. Here we take
+    # care of feeding the information from the image required into the config
+    # for the new host, we perform the launch operation and ensure that the
+    # instance is properly tagged for identification.
+    #
+    # @return [void]
+    # @api private
+    def launch_all_nodes
+      # Load the ec2_yaml spec file
+      ami_spec = YAML.load_file(@options[:ec2_yaml])["AMI"]
+
+      # Iterate across all hosts and launch them, adding tags along the way
+      @logger.notify("aws-sdk: Iterate across all hosts in configuration and launch them")
+      @hosts.each do |host|
+        amitype = host['vmname'] || host['platform']
+        amisize = host['amisize'] || 'm1.small'
+
+        # Use snapshot provided for this host
+        image_type = host['snapshot']
+        if not image_type
+          raise RuntimeError, "No snapshot/image_type provided for EC2 provisioning"
+        end
+        ami = ami_spec[amitype]
+        ami_region = ami[:region]
+
+        # Main region object for ec2 operations
+        region = @ec2.regions[ami_region]
+
+        # Grab image object
+        image_id = ami[:image][image_type.to_sym]
+        @logger.notify("aws-sdk: Checking image #{image_id} exists and getting its root device")
+        image = region.images[image_id]
+        if image.nil? and not image.exists?
+          raise RuntimeError, "Image not found: #{image_id}"
+        end
+
+        # Transform the images block_device_mappings output into a format
+        # ready for a create.
+        orig_bdm = image.block_device_mappings()
+        @logger.notify("aws-sdk: Image block_device_mappings: #{orig_bdm.to_hash}")
+        block_device_mappings = []
+        orig_bdm.each do |device_name, rest|
+          block_device_mappings << {
+            :device_name => device_name,
+            :ebs => {
+              # This is required to override the images default for
+              # delete_on_termination, forcing all volumes to be deleted once the
+              # instance is terminated.
+              :delete_on_termination => true,
+            }
+          }
+        end
+
+        # Launch the node, filling in the blanks from previous work.
+        @logger.notify("aws-sdk: Launch instance")
+        config = {
+          :count => 1,
+          :image_id => image_id,
+          :monitoring_enabled => true,
+          :key_pair => ensure_key_pair(region),
+          :security_groups => [ensure_group(region, Beaker::EC2Helper.amiports(host['roles']))],
+          :instance_type => amisize,
+          :disable_api_termination => false,
+          :instance_initiated_shutdown_behavior => "terminate",
+          :block_device_mappings => block_device_mappings,
+        }
+        instance = region.instances.create(config)
+
+        # Persist the instance object for this host, so later it can be
+        # manipulated by 'cleanup' for example.
+        host['instance'] = instance
+
+        # Define tags for the instance
+        @logger.notify("aws-sdk: Add tags")
+        instance.add_tag("jenkins_build_url", :value => @options[:jenkins_build_url])
+        instance.add_tag("Name", :value => host.name)
+        instance.add_tag("department", :value => @options[:department])
+        instance.add_tag("project", :value => @options[:project])
+
+        @logger.notify("aws-sdk: Launched #{host.name} (#{amitype}:#{amisize}) using snapshot/image_type #{image_type}")
+      end
+
+      nil
+    end
+
+    # Waits until all boxes reach the desired status
+    #
+    # @param status [Symbol] EC2 state to wait for, :running :stopped etc.
+    # @return [void]
+    # @api private
+    def wait_for_status(status)
+      # Wait for each node to reach status :running
+      @logger.notify("aws-sdk: Now wait for all hosts to reach state #{status}")
+      @hosts.each do |host|
+        instance = host['instance']
+        name = host.name
+
+        @logger.notify("aws-sdk: Wait for status #{status} for node #{name}")
+
+        # Here we keep waiting for the machine state to reach ':running' with an
+        # exponential backoff for each poll.
+        # TODO: should probably be a in a shared method somewhere
+        for tries in 1..10
+          if instance.status == status
+            # Always sleep, so the next command won't cause a throttle
+            backoff_sleep(tries)
+            break
+          elsif tries == 10
+            raise "Instance never reached state #{status}"
+          end
+          backoff_sleep(tries)
+        end
+
+        # Set the IP to be the dns_name of the host, yes I know its not an IP.
+        host['ip'] = instance.dns_name
+      end
+    end
+
+    # Populate the hosts IP address and vmhostname entry from the EC2 dns_name
+    #
+    # @return [void]
+    # @api private
+    def populate_dns
+      # Obtain the IP addresses and dns_name for each host
+      @hosts.each do |host|
+        instance = host['instance']
+        host['vmhostname'] = instance.dns_name
+        host['ip'] = instance.ip_address
+        host['private_ip'] = instance.private_ip_address
+        @logger.notify("aws-sdk: name: #{host.name} vmhostname: #{host['vmhostname']} ip: #{host['ip']} private_ip: #{host['private_ip']}")
+      end
+
+      nil
+    end
+
+    # Configure /etc/hosts for each node
+    #
+    # @return [void]
+    # @api private
+    def configure_hosts
+      base = "127.0.0.1\tlocalhost localhost.localdomain\n"
+      @hosts.each do |host|
+        hn = host.hostname
+        etc_hosts = base + "#{host['private_ip']}\t#{hn} #{hn.split(".")[0]}\n"
+        set_etc_hosts(host, etc_hosts)
+      end
+    end
+
+    # Set the hostname of all instances to be the hostname defined in the
+    # beaker configuration.
+    #
+    # @return [void]
+    # @api private
+    def set_hostnames
+      @hosts.each do |host|
+        host.exec(Command.new("hostname #{host['vmhostname']}"))
+      end
+    end
+
+    # Calculates and waits a back-off period based on the number of tries
+    #
+    # Logs each backupoff time and retry value to the console.
+    #
+    # @param tries [Number] number of tries to calculate back-off period
+    # @return [void]
+    # @api private
+    def backoff_sleep(tries)
+      # Exponential with some randomization
+      sleep_time = 2 ** tries
+      @logger.notify("aws-sdk: Sleeping #{sleep_time} seconds for attempt #{tries}.")
+      sleep sleep_time
+      nil
+    end
+
+    # Retrieve the public key locally from the executing users ~/.ssh directory
+    #
+    # @return [String] contents of public key
+    # @api private
+    def public_key
+      filename = File.expand_path('~/.ssh/id_rsa.pub')
+      unless File.exists? filename
+        filename = File.expand_path('~/.ssh/id_dsa.pub')
+        unless File.exists? filename
+          raise RuntimeError, 'Expected either ~/.ssh/id_rsa.pub or ~/.ssh/id_dsa.pub but found neither'
+        end
+      end
+
+      File.read(filename)
+    end
+
+    # Generate a reusable key name from the local hosts hostname
+    #
+    # @return [String] safe key name for current host
+    # @api private
+    def key_name
+      safe_hostname = Socket.gethostname.gsub('.', '-')
+      "Beaker-#{local_user}-#{safe_hostname}"
+    end
+
+    # Returns the local user running this tool
+    #
+    # @return [String] username of local user
+    # @api private
+    def local_user
+      ENV['USER']
+    end
+
+    # Returns the KeyPair for this host, creating it if needed
+    #
+    # @param region [AWS::EC2::Region] region to create the key pair in
+    # @return [AWS::EC2::KeyPair] created key_pair
+    # @api private
+    def ensure_key_pair(region)
+      @logger.notify("aws-sdk: Ensure key pair exists, create if not")
+      key_pairs = region.key_pairs
+      pair_name = key_name()
+      kp = key_pairs[pair_name]
+      unless kp.exists?
+        ssh_string = public_key()
+        kp = key_pairs.import(pair_name, ssh_string)
+      end
+
+      kp
+    end
+
+    # Return a reproducable security group identifier based on input ports
+    #
+    # @param ports [Array<Number>] array of port numbers
+    # @return [String] group identifier
+    # @api private
+    def group_id(ports)
+      if ports.nil? or ports.empty?
+        raise ArgumentError, "Ports list cannot be nil or empty"
+      end
+
+      unless ports.is_a? Set
+        ports = Set.new(ports)
+      end
+
+      # Lolwut, #hash is inconsistent between ruby processes
+      "Beaker-#{Zlib.crc32(ports.inspect)}"
+    end
+
+    # Return an existing group, or create new one
+    #
+    # @param region [AWS::EC2::Region] the AWS region control object
+    # @param ports [Array<Number>] an array of port numbers
+    # @return [AWS::EC2::SecurityGroup] created security group
+    # @api private
+    def ensure_group(region, ports)
+      @logger.notify("aws-sdk: Ensure security group exists for ports #{ports.to_s}, create if not")
+      name = group_id(ports)
+
+      group = region.security_groups.filter('group-name', name).first
+
+      if group.nil?
+        group = create_group(region, ports)
+      end
+
+      group
+    end
+
+    # Create a new security group
+    #
+    # @param region [AWS::EC2::Region] the AWS region control object
+    # @param ports [Array<Number>] an array of port numbers
+    # @return [AWS::EC2::SecurityGroup] created security group
+    # @api private
+    def create_group(region, ports)
+      name = group_id(ports)
+      @logger.notify("aws-sdk: Creating group #{name} for ports #{ports.to_s}")
+      group = region.security_groups.create(name,
+                                            :description => "Custom Beaker security group for #{ports.to_a}")
+
+      unless ports.is_a? Set
+        ports = Set.new(ports)
+      end
+
+      ports.each do |port|
+        group.authorize_ingress(:tcp, port)
+      end
+
+      group
+    end
+
+    # Return a hash containing the fog credentials for EC2
+    #
+    # @param dot_fog [String] dot fog path
+    # @return [Hash<Symbol, String>] ec2 credentials
+    # @api private
+    def load_fog_credentials(dot_fog = '.fog')
+      fog = YAML.load_file( dot_fog )
+
+      default = fog[:default]
+
+      creds = {}
+      creds[:access_key] = default[:aws_access_key_id]
+      creds[:secret_key] = default[:aws_secret_access_key]
+      creds
+    end
+  end
+end