beaker-google 0.3.0 → 0.4.0

data/Gemfile

@@ -1,27 +1,24 @@
-source ENV['GEM_SOURCE'] || "https://rubygems.org"
+source ENV.fetch('GEM_SOURCE', 'https://rubygems.org')
 
 gemspec
 
-
-
 def location_for(place, fake_version = nil)
   if place =~ /^git:([^#]*)#(.*)/
-    [fake_version, { :git => $1, :branch => $2, :require => false }].compact
-  elsif place =~ /^file:\/\/(.*)/
-    ['>= 0', { :path => File.expand_path($1), :require => false }]
+    [fake_version, { git: Regexp.last_match(1), branch: Regexp.last_match(2), require: false }].compact
+  elsif place =~ %r{^file://(.*)}
+    ['>= 0', { path: File.expand_path(Regexp.last_match(1)), require: false }]
   else
-    [place, { :require => false }]
+    [place, { require: false }]
   end
 end
 
-
 # We don't put beaker in as a test dependency because we
 # don't want to create a transitive dependency
 group :acceptance_testing do
-  gem "beaker", *location_for(ENV['BEAKER_VERSION'] || '~> 4.0')
+  gem 'beaker', *location_for(ENV.fetch('BEAKER_VERSION', '~> 4.0'))
 end
 
 
-if File.exists? "#{__FILE__}.local"
-  eval(File.read("#{__FILE__}.local"), binding)
-end
+# if File.exists? "#{__FILE__}.local"
+#   eval(File.read("#{__FILE__}.local"), binding)
+# end

data/README.md

@@ -1,40 +1,69 @@
 # beaker-google
 
+[![License](https://img.shields.io/github/license/voxpupuli/beaker-google.svg)](https://github.com/voxpupuli/beaker-google/blob/master/LICENSE)
+[![Test](https://github.com/voxpupuli/beaker-google/actions/workflows/ci.yml/badge.svg)](https://github.com/voxpupuli/beaker-google/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/voxpupuli/beaker-google/branch/main/graph/badge.svg)](https://codecov.io/gh/voxpupuli/beaker-google)
+[![Release](https://github.com/voxpupuli/beaker-google/actions/workflows/release.yml/badge.svg)](https://github.com/voxpupuli/beaker-google/actions/workflows/release.yml)
+[![RubyGem Version](https://img.shields.io/gem/v/beaker-google.svg)](https://rubygems.org/gems/beaker-google)
+[![RubyGem Downloads](https://img.shields.io/gem/dt/beaker-google.svg)](https://rubygems.org/gems/beaker-google)
+[![Donated by Puppet Inc](https://img.shields.io/badge/donated%20by-Puppet%20Inc-fb7047.svg)](#transfer-notice)
+
 Beaker library to use the Google hypervisor
 
 # How to use this wizardry
 
-This is a gem that allows you to use hosts with [google compute](google_compute_engine.md) hypervisor with [Beaker](https://github.com/puppetlabs/beaker).
-
-See the [documentation](docs/manual.md) for the full manual.
+This is a gem that allows you to use hosts with [Google Compute](https://cloud.google.com/compute) hypervisor with [Beaker](https://github.com/voxpupuli/beaker).
 
 Beaker will automatically load the appropriate hypervisors for any given hosts file, so as long as your project dependencies are satisfied there's nothing else to do. No need to `require` this library in your tests.
 
-## With Beaker 3.x
-This gem is already included as [beaker dependency](https://github.com/puppetlabs/beaker/blob/master/beaker.gemspec)
-for you, so you don't need to do anything special to use this gem's
-functionality with Beaker.
-
-This library is included as a dependency of Beaker 3.x versions, so there's nothing to do.
-
 ## With Beaker 4.x
 
 As of Beaker 4.0, all hypervisor and DSL extension libraries have been removed and are no longer dependencies. In order to use a specific hypervisor or DSL extension library in your project, you will need to include them alongside Beaker in your Gemfile or project.gemspec. E.g.
 
-~~~ruby
+```ruby
 # Gemfile
 gem 'beaker', '~>4.0'
-gem 'beaker-aws'
+gem 'beaker-google'
 # project.gemspec
 s.add_runtime_dependency 'beaker', '~>4.0'
-s.add_runtime_dependency 'beaker-aws'
-~~~
+s.add_runtime_dependency 'beaker-google'
+```
+
+## Authentication
+
+You must be authenticated to Google Compute Engine to be able to use `beaker-google`. Authentication is attempted in two different ways, and the first that succeeds is used.
+
+- Using the environment variable [`GOOGLE_APPLICATION_CREDENTIALS`](https://cloud.google.com/docs/authentication/production#passing_variable), which points to a file containing the credentials for a GCP service account, created by `gcloud iam service-accounts keys create` (or equivalent).
+- Using [Application Default Credentials](https://cloud.google.com/docs/authentication/production).
+
+## Configuration
+
+The behavior of this library can be configured using either the beaker host configuration file, or environment variables.
+
+| configuration option | required         | default                          | description                                                                                                                                                                                                                                                                                   |
+| -------------------- | ---------------- | -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| gce_project          | true             |                                  | The ID of the Google GCP project to host resources.                                                                                                                                                                                                                                           |
+| gce_zone             | true             |                                  | The zone to place compute instances in. The region is calculated from the zone name.                                                                                                                                                                                                          |
+| gce_network          | false            | Default                          | The name of the network to attach to instances. If the project uses the default network, this and `gce_subnetwork` can be left empty.                                                                                                                                                         |
+| gce_subnetwork       | false            | Default                          | THe name of the subnetwork to attach to the instances network interface. If the Default network is not used, this must be supplied.                                                                                                                                                           |
+| gce_ssh_private_key  | false            | $HOME/.ssh/google_compute_engine | The file path of the private key to use to connect to instances. If using the key created by the gcloud tool, this can be left blank.                                                                                                                                                         |
+| gce_ssh_public_key   | false            | <gce_ssh_private_key>.pub        | The file path of the public key to upload to the instance. If left blank, attempt to use the file at `gce_ssh_private_key` with a `.pub` extension.                                                                                                                                           |
+| gce_machine_type     | false            | e2-standard-4                    | The machine type to use for the instance. If the `BEAKER_gce_machine_type` environment variable is set, it will be used for all hosts.                                                                                                                                                        |
+| volume_size          | false            | Source Image disk's size         | The size of the boot disk for the image. If unset, the disk will be the same size as the image's boot disk. Provided size must be equal to or larger than the image's disk size.                                                                                                              |
+| image                | true or `family` |                                  | The image to use for creating this instance. It can be either in the form `{project}/{image}` to use an image in a different project, or `{image}`, which will look for the image in `gce_project`.                                                                                           |
+| family               | true or `image`  |                                  | The image family to use for creating this instance. It can be either in the form `{project}/{family}` to use an image from a family in a different project, or `{family}`, which will look for the image family in `gce_project`. The latest non-deprecated image in the family will be used. |
+
+All the variables in the list can be set in the Beaker host configuration file, or the ones starting with `gce_` can be overridden by environment variables in the form `BEAKER_gce_...`. i.e. To override the `gce_machine_type` setting in the environment, set `BEAKER_gce_machine_type`.
+
+# Cleanup
+
+In cases where the beaker process is killed before finishing, it may leave resources in GCP. These resources will need to be manually deleted.
 
-In Beaker's next major version, the requirement for `beaker-google` will be
-pulled from that repo. When that happens, then the usage pattern will change.
-In order to use this then, you'll need to include `beaker-google` as a dependency
-right next to beaker itself.
+| Resource Type | Name Pattern        | Count                                       |
+| ------------- | ------------------- | ------------------------------------------- |
+| Firewall      | `beaker-<number>-*` | 1                                           |
+| Instance      | `beaker-*`          | One or more depending on test configuration |
 
 # Contributing
 
-Please refer to puppetlabs/beaker's [contributing](https://github.com/puppetlabs/beaker/blob/master/CONTRIBUTING.md) guide.
+Please refer to voxpupuli/beaker's [contributing](https://github.com/voxpupuli/beaker/blob/master/CONTRIBUTING.md) guide.

data/Rakefile

@@ -5,65 +5,61 @@ require 'rspec/core/rake_task'
 #   Documentation Tasks
 #
 ###########################################################
-DOCS_DAEMON = "yard server --reload --daemon --server thin"
+DOCS_DAEMON = 'yard server --reload --daemon --server thin'
 FOREGROUND_SERVER = 'bundle exec yard server --reload --verbose --server thin lib/beaker'
 
-def running?( cmdline )
+def running?(cmdline)
   ps = `ps -ef`
-  found = ps.lines.grep( /#{Regexp.quote( cmdline )}/ )
-  if found.length > 1
-    raise StandardError, "Found multiple YARD Servers. Don't know what to do."
-  end
+  found = ps.lines.grep(/#{Regexp.quote(cmdline)}/)
+  raise StandardError, "Found multiple YARD Servers. Don't know what to do." if found.length > 1
 
   yes = found.empty? ? false : true
-  return yes, found.first
+  [yes, found.first]
 end
 
-def pid_from( output )
+def pid_from(output)
   output.squeeze(' ').strip.split(' ')[1]
 end
 
 desc 'Start the documentation server in the foreground'
-task :docs => 'docs:clear' do
+task docs: 'docs:clear' do
   original_dir = Dir.pwd
-  Dir.chdir( File.expand_path(File.dirname(__FILE__)) )
+  Dir.chdir(__dir__)
   sh FOREGROUND_SERVER
-  Dir.chdir( original_dir )
+  Dir.chdir(original_dir)
 end
 
 namespace :docs do
-
   desc 'Clear the generated documentation cache'
   task :clear do
     original_dir = Dir.pwd
-    Dir.chdir( File.expand_path(File.dirname(__FILE__)) )
+    Dir.chdir(__dir__)
     sh 'rm -rf docs'
-    Dir.chdir( original_dir )
+    Dir.chdir(original_dir)
   end
 
   desc 'Generate static documentation'
-  task :gen => 'docs:clear' do
+  task gen: 'docs:clear' do
     original_dir = Dir.pwd
-    Dir.chdir( File.expand_path(File.dirname(__FILE__)) )
+    Dir.chdir(__dir__)
     output = `bundle exec yard doc`
     puts output
-    if output =~ /\[warn\]|\[error\]/
-      fail "Errors/Warnings during yard documentation generation"
-    end
-    Dir.chdir( original_dir )
+    raise 'Errors/Warnings during yard documentation generation' if output =~ /\[warn\]|\[error\]/
+
+    Dir.chdir(original_dir)
   end
 
   desc 'Run the documentation server in the background, alias `bg`'
-  task :background => 'docs:clear' do
-    yes, output = running?( DOCS_DAEMON )
+  task background: 'docs:clear' do
+    yes, output = running?(DOCS_DAEMON)
     if yes
-      puts "Not starting a new YARD Server..."
-      puts "Found one running with pid #{pid_from( output )}."
+      puts 'Not starting a new YARD Server...'
+      puts "Found one running with pid #{pid_from(output)}."
     else
       original_dir = Dir.pwd
-      Dir.chdir( File.expand_path(File.dirname(__FILE__)) )
+      Dir.chdir(__dir__)
       sh "bundle exec #{DOCS_DAEMON}"
-      Dir.chdir( original_dir )
+      Dir.chdir(original_dir)
     end
   end
 
@@ -71,37 +67,37 @@ namespace :docs do
 
   desc 'Check the status of the documentation server'
   task :status do
-    yes, output = running?( DOCS_DAEMON )
+    yes, output = running?(DOCS_DAEMON)
     if yes
-      pid = pid_from( output )
+      pid = pid_from(output)
       puts "Found a YARD Server running with pid #{pid}"
     else
-      puts "Could not find a running YARD Server."
+      puts 'Could not find a running YARD Server.'
     end
   end
 
-  desc "Stop a running YARD Server"
+  desc 'Stop a running YARD Server'
   task :stop do
-    yes, output = running?( DOCS_DAEMON )
+    yes, output = running?(DOCS_DAEMON)
     if yes
-      pid = pid_from( output )
+      pid = pid_from(output)
       puts "Found a YARD Server running with pid #{pid}"
       `kill #{pid}`
-      puts "Stopping..."
-      yes, output = running?( DOCS_DAEMON )
+      puts 'Stopping...'
+      yes, output = running?(DOCS_DAEMON)
       if yes
         `kill -9 #{pid}`
-        yes, output = running?( DOCS_DAEMON )
+        yes, output = running?(DOCS_DAEMON)
         if yes
-          puts "Could not Stop Server!"
+          puts 'Could not Stop Server!'
         else
-          puts "Server stopped."
+          puts 'Server stopped.'
         end
       else
-        puts "Server stopped."
+        puts 'Server stopped.'
       end
     else
-      puts "Could not find a running YARD Server"
+      puts 'Could not find a running YARD Server'
     end
   end
 end

data/beaker-google.gemspec

@@ -5,11 +5,11 @@ require 'beaker-google/version'
 Gem::Specification.new do |s|
   s.name        = "beaker-google"
   s.version     = BeakerGoogle::VERSION
-  s.authors     = ["Rishi Javia, Kevin Imber, Tony Vu"]
-  s.email       = ["rishi.javia@puppet.com, kevin.imber@puppet.com, tony.vu@puppet.com"]
-  s.homepage    = "https://github.com/puppetlabs/beaker-google"
+  s.authors     = ["Puppet", "Voxpupuli"]
+  s.email       = ["voxpupuli@groups.io"]
+  s.homepage    = "https://github.com/voxpupuli/beaker-google"
   s.summary     = %q{Beaker DSL Extension Helpers!}
-  s.description = %q{For use for the Beaker acceptance testing tool}
+  s.description = %q{Google Compute Engine support for the Beaker acceptance testing tool.}
   s.license     = 'Apache2'
 
   s.files         = `git ls-files`.split("\n")
@@ -17,16 +17,13 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
+  s.required_ruby_version = Gem::Requirement.new('>= 2.4')
+
   # Testing dependencies
   s.add_development_dependency 'rspec', '~> 3.0'
   s.add_development_dependency 'rspec-its'
-  # pin fakefs for Ruby < 2.3
-  if RUBY_VERSION < "2.3"
-    s.add_development_dependency 'fakefs', '~> 0.6', '< 0.14'
-  else
-    s.add_development_dependency 'fakefs', '~> 0.6'
-  end
-  s.add_development_dependency 'rake', '~> 10.1'
+  s.add_development_dependency 'fakefs', '~> 1.8'
+  s.add_development_dependency 'rake', '~> 13.0'
   s.add_development_dependency 'simplecov'
   s.add_development_dependency 'pry', '~> 0.10'
 
@@ -36,7 +33,8 @@ Gem::Specification.new do |s|
 
   # Run time dependencies
   s.add_runtime_dependency 'stringify-hash', '~> 0.0.0'
-  s.add_runtime_dependency 'google-api-client', '~> 0.8'
 
+  s.add_runtime_dependency 'google-apis-compute_v1', '~> 0.1'
+  s.add_runtime_dependency 'google-apis-oslogin_v1', '~> 0.1'
+  s.add_runtime_dependency 'googleauth', '~> 1.2'
 end
-

data/bin/beaker-google

@@ -4,7 +4,7 @@ require 'rubygems' unless defined?(Gem)
 require 'beaker-google'
 
 VERSION_STRING =
-"
+  "
                                  _ .--.
                                 ( `    )
         beaker-google         .-'      `--,
@@ -25,8 +25,6 @@ VERSION_STRING =
                      '=='
 "
 
-
-
 puts BeakerGoogle::VERSION
 
 exit 0

data/lib/beaker/hypervisor/google_compute.rb

@@ -1,37 +1,52 @@
 require 'time'
 
 module Beaker
-
   # Beaker support for the Google Compute Engine.
   class GoogleCompute < Beaker::Hypervisor
-
     SLEEPWAIT = 5
 
     # Hours before an instance is considered a zombie
     ZOMBIE = 3
 
     # Do some reasonable sleuthing on the SSH public key for GCE
-    def find_google_ssh_public_key
-      keyfile = ENV.fetch('BEAKER_gce_ssh_public_key', File.join(ENV['HOME'], '.ssh', 'google_compute_engine.pub'))
 
-      if @options[:gce_ssh_public_key] && !File.exist?(keyfile)
-        keyfile = @options[:gce_ssh_public_key]
-      end
-
-      raise("Could not find GCE Public SSH Key at '#{keyfile}'") unless File.exist?(keyfile)
+    ##
+    # Try to find the private ssh key file
+    #
+    # @return [String] The file path for the private key file
+    #
+    # @raise [Error] if the private key can not be found
+    def find_google_ssh_private_key
+      private_keyfile = ENV.fetch('BEAKER_gce_ssh_public_key',
+        File.join(ENV.fetch('HOME', nil), '.ssh', 'google_compute_engine'))
+      private_keyfile = @options[:gce_ssh_private_key] if @options[:gce_ssh_private_key] && !File.exist?(private_keyfile)
+      raise("Could not find GCE Private SSH key at '#{keyfile}'") unless File.exist?(private_keyfile)
+      @options[:gce_ssh_private_key] = private_keyfile
+      private_keyfile
+    end
 
-      return keyfile
+    ##
+    # Try to find the public key file based on the location of the private key or provided data
+    #
+    # @return [String] The file path for the public key file
+    #
+    # @raise [Error] if the public key can not be found
+    def find_google_ssh_public_key
+      private_keyfile = find_google_ssh_private_key
+      public_keyfile = private_keyfile << '.pub'
+      public_keyfile = @options[:gce_ssh_public_key] if @options[:gce_ssh_public_key] && !File.exist?(public_keyfile)
+      raise("Could not find GCE Public SSH key at '#{keyfile}'") unless File.exist?(public_keyfile)
+      @options[:gce_ssh_public_key] = public_keyfile
+      public_keyfile
     end
 
-    # Create the array of metaData, each member being a hash with a :key and a
-    # :value.  Sets :department, :project and :jenkins_build_url.
-    def format_metadata
-      [ {:key => :department, :value => @options[:department]},
-        {:key => :project, :value => @options[:project]},
-        {:key => :jenkins_build_url, :value => @options[:jenkins_build_url]},
-        {:key => :sshKeys, :value => "google_compute:#{File.read(find_google_ssh_public_key).strip}" }
-      ].delete_if { |member| member[:value].nil? or member[:value].empty?}
+    # IP is the only way we can be sure to connect
+    # TODO: This isn't being called
+    # rubocop:disable Lint/UnusedMethodArgument
+    def connection_preference(host)
+      [:ip]
     end
+    # rubocop:enable Lint/UnusedMethodArgument
 
     # Create a new instance of the Google Compute Engine hypervisor object
     #
@@ -60,6 +75,7 @@ module Beaker
     def initialize(google_hosts, options)
       require 'beaker/hypervisor/google_compute_helper'
 
+      super
       @options = options
       @logger = options[:logger]
       @hosts = google_hosts
@@ -70,67 +86,127 @@ module Beaker
     # Create and configure virtual machines in the Google Compute Engine,
     # including their associated disks and firewall rules
     def provision
-      attempts = @options[:timeout].to_i / SLEEPWAIT
       start = Time.now
-
       test_group_identifier = "beaker-#{start.to_i}-"
 
-      # get machineType resource, used by all instances
-      machineType = @gce_helper.get_machineType(start, attempts)
-
       # set firewall to open pe ports
-      network = @gce_helper.get_network(start, attempts)
+      network = @gce_helper.get_network
+
       @firewall = test_group_identifier + generate_host_name
-      @gce_helper.create_firewall(@firewall, network, start, attempts)
 
-      @logger.debug("Created Google Compute firewall #{@firewall}")
+      @gce_helper.create_firewall(@firewall, network)
 
+      @logger.debug("Created Google Compute firewall #{@firewall}")
 
       @hosts.each do |host|
+
+        machine_type_name = ENV.fetch('BEAKER_gce_machine_type', host['gce_machine_type'])
+        raise "Must provide a machine type name in 'gce_machine_type'." if machine_type_name.nil?
+        # Get the GCE machine type object for this host
+        machine_type = @gce_helper.get_machine_type(machine_type_name)
+        raise "Unable to find machine type named #{machine_type_name} in region #{@compute.default_zone}" if machine_type.nil?
+
+        # Find the image to use to create the new VM.
+        # Either `image` or `family` must be set in the configuration. Accepted formats
+        # for the image and family:
+        #   - {project}/{image}
+        #   - {project}/{family}
+        #   - {image}
+        #   - {family}
+        #
+        # If a {project} is not specified, default to the project provided in the
+        # BEAKER_gce_project environment variable
         if host[:image]
-          gplatform = host[:image]
-        elsif host[:platform]
-          gplatform = Platform.new(host[:platform])
+          image_selector = host[:image]
+          # Do we have a project name?
+          if %r{/}.match?(image_selector)
+            image_project, image_name = image_selector.split('/')[0..1]
+          else
+            image_project = @gce_helper.options[:gce_project]
+            image_name = image_selector
+          end
+          img = @gce_helper.get_image(image_project, image_name)
+          raise "Unable to find image #{image_name} from project #{image_project}" if img.nil?
+        elsif host[:family]
+          image_selector = host[:family]
+          # Do we have a project name?
+          if %r{/}.match?(image_selector)
+            image_project, family_name = image_selector.split('/')
+          else
+            image_project = @gce_helper.options[:gce_project]
+            family_name = image_selector
+          end
+          img = @gce_helper.get_latest_image_from_family(image_project, family_name)
+          raise "Unable to find image in family #{family_name} from project #{image_project}" if img.nil?
         else
-          raise('You must specify either :image or :platform, or both as necessary')
+          raise('You must specify either :image or :family')
         end
 
-        img = @gce_helper.get_latest_image(gplatform, start, attempts)
-
         unique_host_id = test_group_identifier + generate_host_name
 
-        host['diskname'] = unique_host_id
-        disk = @gce_helper.create_disk(host['diskname'], img, start, attempts)
-        @logger.debug("Created Google Compute disk for #{host.name}: #{host['diskname']}")
+        boot_size = host['volume_size'] || img.disk_size_gb
+
+        # The boot disk is created as part of the instance creation
+        # TODO: Allow creation of other disks
+        # disk = @gce_helper.create_disk(host["diskname"], img, size)
+        # @logger.debug("Created Google Compute disk for #{host.name}: #{host["diskname"]}")
 
         # create new host name
         host['vmhostname'] = unique_host_id
-        #add a new instance of the image
-        instance = @gce_helper.create_instance(host['vmhostname'], img, machineType, disk, start, attempts)
+
+        # add a new instance of the image
+        operation = @gce_helper.create_instance(host['vmhostname'], img, machine_type, boot_size)
+        unless operation.error.nil?
+          raise "Unable to create Google Compute Instance #{host.name}: [#{operation.error.errors[0].code}] #{operation.error.errors[0].message}"
+        end
         @logger.debug("Created Google Compute instance for #{host.name}: #{host['vmhostname']}")
+        instance = @gce_helper.get_instance(host['vmhostname'])
 
         # add metadata to instance, if there is any to set
-        mdata = format_metadata
-        unless mdata.empty?
-          @gce_helper.setMetadata_on_instance(host['vmhostname'], instance['metadata']['fingerprint'],
-                                              mdata,
-                                              start, attempts)
-          @logger.debug("Added tags to Google Compute instance #{host.name}: #{host['vmhostname']}")
-        end
+        # mdata = format_metadata
+        # TODO: Set a configuration option for this to allow disabeling oslogin
+        mdata = [
+          {
+            key: 'ssh-keys',
+            value: "google_compute:#{File.read(find_google_ssh_public_key).strip}"
+          },
+          # For now oslogin needs to be disabled as there's no way to log in as root and it would
+          # take too much work on beaker to add sudo support to everything
+          {
+            key: 'enable-oslogin',
+            value: 'FALSE'
+          },
+        ]
+        next if mdata.empty?
+        # Add the metadata to the host
+        @gce_helper.set_metadata_on_instance(host['vmhostname'], mdata)
+        @logger.debug("Added tags to Google Compute instance #{host.name}: #{host['vmhostname']}")
+
+        host['ip'] = instance.network_interfaces[0].access_configs[0].nat_ip
+
+        # Add the new host to the firewall
+        @gce_helper.add_firewall_tag(@firewall, host['vmhostname'])
+
+        if host['disable_root_ssh'] == true
+          @logger.info('Not enabling root ssh as disable_root_ssh is true')
+        else
 
-        # get ip for this host
-        host['ip'] = instance['networkInterfaces'][0]['accessConfigs'][0]['natIP']
+          # # configure ssh
+          default_user = host['user']
 
-        # configure ssh
-        default_user = host['user']
-        host['user'] = 'google_compute'
+          # TODO: Pull this out into a configuration option or something
+          host['user'] = 'google_compute'
 
-        copy_ssh_to_root(host, @options)
-        enable_root_login(host, @options)
-        host['user'] = default_user
+          # Set the ssh private key we need to use
+          host.options['ssh']['keys'] = [find_google_ssh_private_key]
 
-        # shut down connection, will reconnect on next exec
-        host.close
+          copy_ssh_to_root(host, @options)
+          enable_root_login(host, @options)
+          host['user'] = default_user
+
+          # shut down connection, will reconnect on next exec
+          host.close
+        end
 
         @logger.debug("Instance ready: #{host['vmhostname']} for #{host.name}}")
       end
@@ -138,70 +214,13 @@ module Beaker
 
     # Shutdown and destroy virtual machines in the Google Compute Engine,
     # including their associated disks and firewall rules
-    def cleanup()
-      attempts = @options[:timeout].to_i / SLEEPWAIT
-      start = Time.now
-
-      @gce_helper.delete_firewall(@firewall, start, attempts)
+    def cleanup
+      @gce_helper.delete_firewall(@firewall)
 
       @hosts.each do |host|
-        @gce_helper.delete_instance(host['vmhostname'], start, attempts)
+        # TODO: Delete any other disks attached during the instance creation
+        @gce_helper.delete_instance(host['vmhostname'])
         @logger.debug("Deleted Google Compute instance #{host['vmhostname']} for #{host.name}")
-        @gce_helper.delete_disk(host['diskname'], start, attempts)
-        @logger.debug("Deleted Google Compute disk #{host['diskname']} for #{host.name}")
-      end
-
-    end
-
-    # Shutdown and destroy Google Compute instances (including their associated
-    # disks and firewall rules) that have been alive longer than ZOMBIE hours.
-    def kill_zombies(max_age = ZOMBIE)
-      now = start = Time.now
-      attempts = @options[:timeout].to_i / SLEEPWAIT
-
-      # get rid of old instances
-      instances = @gce_helper.list_instances(start, attempts)
-      if instances
-        instances.each do |instance|
-          created = Time.parse(instance['creationTimestamp'])
-          alive = (now - created )/60/60
-          if alive >= max_age
-            #kill it with fire!
-            @logger.debug("Deleting zombie instance #{instance['name']}")
-            @gce_helper.delete_instance( instance['name'], start, attempts )
-          end
-        end
-      else
-        @logger.debug("No zombie instances found")
-      end
-
-      # get rid of old disks
-      disks = @gce_helper.list_disks(start, attempts)
-      if disks
-        disks.each do |disk|
-          created = Time.parse(disk['creationTimestamp'])
-          alive = (now - created )/60/60
-          if alive >= max_age
-
-            # kill it with fire!
-            @logger.debug("Deleting zombie disk #{disk['name']}")
-            @gce_helper.delete_disk( disk['name'], start, attempts )
-          end
-        end
-      else
-        @logger.debug("No zombie disks found")
-      end
-
-      # get rid of non-default firewalls
-      firewalls = @gce_helper.list_firewalls( start, attempts)
-
-      if firewalls && !firewalls.empty?
-        firewalls.each do |firewall|
-          @logger.debug("Deleting non-default firewall #{firewall['name']}")
-          @gce_helper.delete_firewall( firewall['name'], start, attempts )
-        end
-      else
-        @logger.debug("No zombie firewalls found")
       end
     end
   end