cem_acpt 0.1.0 → 0.2.2

data/lib/cem_acpt/logging.rb

@@ -5,8 +5,55 @@ require 'logger'
 module CemAcpt
   # Logging for CemAcpt
   module Logging
+    LEVEL_MAP = {
+      'debug' => Logger::DEBUG,
+      'info' => Logger::INFO,
+      'warn' => Logger::WARN,
+      'error' => Logger::ERROR,
+      'fatal' => Logger::FATAL,
+      'unknown' => Logger::UNKNOWN,
+    }
+
+    # Delegator class for when you want to log to multiple devices
+    # at the same time, such as STDOUT and a file.
+    # @param loggers [::Logger] one or more instances of Logger
+    class MultiLogger
+      def initialize(*loggers)
+        @loggers = loggers
+      end
+
+      def method_missing(m, *args, &block)
+        if @loggers.all? { |l| l.respond_to?(m) }
+          @loggers.map { |l| l.send(m, *args, &block) }
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(m, include_private = false)
+        @loggers.all? { |l| l.respond_to?(m) } || super
+      end
+    end
+
     class << self
-      attr_writer :logger
+      def new_logger(*logdevs, **configs)
+        new_configs = current_log_config.merge(configs.reject { |_, v| v.nil? })
+        if new_configs.key?(:level) && !LEVEL_MAP.values.include?(new_configs[:level])
+          new_configs[:level] = LEVEL_MAP[new_configs[:level].downcase]
+        end
+        loggers = logdevs.map do |dev|
+          logdev = dev.is_a?(String) ? $stdout : dev
+          logger = Logger.new(
+            logdev,
+            new_configs[:shift_age],
+            new_configs[:shift_size],
+            **new_configs.reject { |k, _| %i[logdev shift_age shift_size].include?(k) },
+          )
+          logger.reopen(dev) if dev.is_a?(String)
+          logger
+        end
+        @logger = CemAcpt::Logging::MultiLogger.new(*loggers)
+      end
 
       # Exposes a logger instance. Will either use the currently set logger or
       # create a new one.
@@ -29,22 +76,9 @@ module CemAcpt
       # Shortcut method to set logger.level
       # @param level [String] the log level to set
       def new_log_level(level)
-        case level.downcase
-        when 'debug'
-          @logger.level = Logger::DEBUG
-        when 'info'
-          @logger.level = Logger::INFO
-        when 'warn'
-          @logger.level = Logger::WARN
-        when 'error'
-          @logger.level = Logger::ERROR
-        when 'fatal'
-          @logger.level = Logger::FATAL
-        when 'unknown'
-          @logger.level = Logger::UNKNOWN
-        else
-          raise "Cannot set log level #{level}: invalid level"
-        end
+        raise ArgumentError, 'Log level not recognized' unless LEVEL_MAP[level.downcase]
+
+        @logger.level = LEVEL_MAP[level.downcase]
       end
 
       # Shows the current log format style if set, or the default if not.
@@ -64,7 +98,7 @@ module CemAcpt
           @current_log_format = :json
           proc do |severity, datetime, progname, msg|
             {
-              timestamp: datetime.iso8601(3),
+              timestamp: datetime,
               progname: progname,
               severity: severity,
               message: msg,
@@ -75,10 +109,22 @@ module CemAcpt
           proc do |severity, _datetime, _progname, msg|
             "#{severity} - #{msg}\n"
           end
+        when :github_action
+          @current_log_format = :github_action
+          sev_map = {
+            'DEBUG' => '::debug::',
+            'INFO' => '::notice::',
+            'WARN' => '::warning::',
+            'ERROR' => '::error::',
+            'FATAL' => '::error::',
+          }
+          proc do |severity, _datetime, _progname, msg|
+            "#{sev_map[severity]}{#{msg}}\n"
+          end
         else
           @current_log_format = :file
           proc do |severity, datetime, _progname, msg|
-            "[#{datetime.iso8601(3)}] #{severity}: #{msg}\n"
+            "[#{datetime}] #{severity}: #{msg}\n"
           end
         end
       end
@@ -143,6 +189,10 @@ module CemAcpt
     # Provides class method wrappers for logging methods
     def self.included(base)
       class << base
+        def new_logger(*logdevs, **configs)
+          CemAcpt::Logging.new_logger(*logdevs, **configs)
+        end
+
         def logger
           CemAcpt::Logging.logger
         end
@@ -155,6 +205,14 @@ module CemAcpt
           CemAcpt::Logging.new_log_level(level)
         end
 
+        def current_log_format
+          CemAcpt::Logging.current_log_format
+        end
+
+        def new_log_formatter(f)
+          CemAcpt::Logging.new_log_formatter(f)
+        end
+
         def current_log_config
           CemAcpt::Logging.current_log_config
         end
@@ -165,6 +223,10 @@ module CemAcpt
       end
     end
 
+    def new_logger(*logdevs, **configs)
+      CemAcpt::Logging.new_logger(*logdevs, **configs)
+    end
+
     # Exposes the logger instance
     def logger
       CemAcpt::Logging.logger
@@ -180,6 +242,14 @@ module CemAcpt
       CemAcpt::Logging.new_log_level(level)
     end
 
+    def current_log_format
+      CemAcpt::Logging.current_log_format
+    end
+
+    def new_log_formatter(f)
+      CemAcpt::Logging.new_log_formatter(f)
+    end
+
     # Exposes the current log config
     def current_log_config
       CemAcpt::Logging.current_log_config
@@ -190,4 +260,92 @@ module CemAcpt
       CemAcpt::Logging.new_log_config(logdev: logdev, shift_age: shift_age, shift_size: shift_size, level: level, formatter: formatter, datetime_format: datetime_format)
     end
   end
+
+  module LoggingAsync
+    require 'concurrent-ruby'
+
+    class << self
+      def log_write_thread
+        @log_write_thread ||= Concurrent::SingleThreadExecutor.new
+      end
+
+      def async_debug(message, prefix = nil)
+        msg = prefix.nil? || prefix.empty? ? message : "#{prefix} #{message}"
+        CemAcpt::Logging.logger.debug(msg)
+      end
+
+      def async_info(message, prefix = nil)
+        msg = prefix.nil? || prefix.empty? ? message : "#{prefix} #{message}"
+        CemAcpt::Logging.logger.info(msg)
+      end
+
+      def async_warn(message, prefix = nil)
+        msg = prefix.nil? || prefix.empty? ? message : "#{prefix} #{message}"
+        CemAcpt::Logging.logger.warn(msg)
+      end
+
+      def async_error(message, prefix = nil)
+        msg = prefix.nil? || prefix.empty? ? message : "#{prefix} #{message}"
+        CemAcpt::Logging.logger.error(msg)
+      end
+
+      def async_fatal(message, prefix = nil)
+        msg = prefix.nil? || prefix.empty? ? message : "#{prefix} #{message}"
+        CemAcpt::Logging.logger.fatal(msg)
+      end
+    end
+
+    # Provides class method wrappers for logging methods
+    def self.included(base)
+      class << base
+        def log_write_thread
+          CemAcpt::LoggingAsync.log_write_thread
+        end
+
+        def async_debug(message, prefix = nil)
+          CemAcpt::LoggingAsync.async_debug(message, prefix)
+        end
+
+        def async_info(message, prefix = nil)
+          CemAcpt::LoggingAsync.async_info(message, prefix)
+        end
+
+        def async_warn(message, prefix = nil)
+          CemAcpt::LoggingAsync.async_warn(message, prefix)
+        end
+
+        def async_error(message, prefix = nil)
+          CemAcpt::LoggingAsync.async_error(message, prefix)
+        end
+
+        def async_fatal(message, prefix = nil)
+          CemAcpt::LoggingAsync.async_fatal(message, prefix)
+        end
+      end
+    end
+
+    def log_write_thread
+      CemAcpt::LoggingAsync.log_write_thread
+    end
+
+    def async_debug(message, prefix = nil)
+      CemAcpt::LoggingAsync.async_debug(message, prefix)
+    end
+
+    def async_info(message, prefix = nil)
+      CemAcpt::LoggingAsync.async_info(message, prefix)
+    end
+
+    def async_warn(message, prefix = nil)
+      CemAcpt::LoggingAsync.async_warn(message, prefix)
+    end
+
+    def async_error(message, prefix = nil)
+      CemAcpt::LoggingAsync.async_error(message, prefix)
+    end
+
+    def async_fatal(message, prefix = nil)
+      CemAcpt::LoggingAsync.async_fatal(message, prefix)
+    end
+  end
 end

data/lib/cem_acpt/platform/base/cmd.rb

@@ -3,11 +3,17 @@
 module CemAcpt::Platform
   require_relative File.join(__dir__, '..', '..', 'logging.rb')
 
+  class CmdError < StandardError; end
+
   # Base class for command providers. Provides an API for subclasses to implement.
   class CmdBase
     include CemAcpt::Logging
 
-    def initialize(*args, **kwargs); end
+    attr_reader :env
+
+    def initialize(*_args, env: {}, **_kwargs)
+      @env = env
+    end
 
     def local_exec(*_args, **_kwargs)
       raise NotImplementedError, '#local_exec must be implemented by a subclass'
@@ -56,7 +62,7 @@ module CemAcpt::Platform
           return output
         rescue StandardError => e
           last_error = e
-          sleep(5)
+          sleep(10)
         end
       end
       raise last_error

data/lib/cem_acpt/platform/gcp/cmd.rb

@@ -1,19 +1,18 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'open3'
-require_relative File.join(__dir__, '..', 'base', 'cmd.rb')
-
 module CemAcpt::Platform::Gcp
+  require 'json'
+  require 'open3'
+  require_relative File.join(__dir__, '..', 'base', 'cmd.rb')
+
   # This class provides methods to run gcloud commands. It allows for default values to be
   # set for the project, zone, and user and can also find these values from the local config.
   # Additionally, this class provides a way to run SSH commands against GCP VMs using IAP.
   class Cmd < CemAcpt::Platform::CmdBase
-    def initialize(project: nil, zone: nil, out_format: nil, filter: nil, user_name: nil, local_port: nil)
-      super
+    def initialize(project: nil, zone: nil, out_format: nil, filter: nil, user_name: nil, local_port: nil, ssh_key: nil)
+      super(env: { 'CLOUDSDK_PYTHON_SITEPACKAGES' => '1' })
       require 'net/ssh'
       require 'net/ssh/proxy/command'
-      require 'net/scp'
 
       @project = project unless project.nil?
       @zone = zone unless zone.nil?
@@ -21,8 +20,9 @@ module CemAcpt::Platform::Gcp
       @default_filter = filter
       @user_name = user_name
       @local_port = local_port
-      raise 'gcloud command not available' unless gcloud?
-      raise 'gcloud is not authenticated' unless authenticated?
+      @ssh_key = ssh_key
+      raise CemAcpt::Platform::CmdError, 'gcloud command not available' unless gcloud?
+      raise CemAcpt::Platform::CmdError, 'gcloud is not authenticated' unless authenticated?
     end
 
     # Returns either the project name passed in during object initialization
@@ -40,25 +40,37 @@ module CemAcpt::Platform::Gcp
     # Returns either the user name passed in during object initialization
     # or queries the current active, authenticated user from gcloud and returns the name.
     def user_name
-      @user_name ||= authenticated_user_name&.chomp
+      @user_name ||= authenticated_user_name
     end
 
     # Returns the format string passed in during object initialization or
     # the default format string.
     def format(out_format = nil)
-      out_format&.chomp || @default_out_format&.chomp
+      out_format&.chomp || @default_out_format
     end
 
     # Returns the filter string passed in during object initialization or
     # the default filter string.
     def filter(out_filter = nil)
-      out_filter&.chomp || @default_filter&.chomp
+      out_filter&.chomp || @default_filter
     end
 
     def local_port
       @local_port ||= rand(49_512..65_535)
     end
 
+    def ssh_key
+      return @ssh_key unless @ssh_key.nil?
+
+      if File.exist?(File.join([ENV['HOME'], '.ssh', 'acpt_test_key']))
+        @ssh_key = File.join([ENV['HOME'], '.ssh', 'acpt_test_key'])
+      else
+        logger.debug("Test SSH key not found at #{File.join([ENV['HOME'], '.ssh', 'acpt_test_key'])}, using default")
+        @ssh_key = File.join([ENV['HOME'], '.ssh', 'google_compute_engine'])
+      end
+      @ssh_key
+    end
+
     # Returns a formatted hash of ssh options to be used with Net::SSH.start.
     # If you pass in a GCP VM instance name, this method will configure the
     # IAP tunnel ProxyCommand to use. If you pass in an opts hash, it will
@@ -74,21 +86,19 @@ module CemAcpt::Platform::Gcp
 
     # Runs `gcloud` commands locally.
     def local_exec(command, out_format: 'json', out_filter: nil, project_flag: true)
-      cmd_parts = ['gcloud', command]
-      cmd_parts << "--project=#{project.chomp}" unless !project_flag || project.nil?
-      cmd_parts << "--format=#{format(out_format)}" if format(out_format)
-      cmd_parts << "--filter=\"#{filter(out_filter)}\"" if filter(out_filter)
-      final_command = cmd_parts.join(' ')
-      stdout, stderr, status = Open3.capture3(final_command)
+      final_command = format_gcloud_command(command, out_format: out_format, out_filter: out_filter, project_flag: project_flag)
+      stdout, stderr, status = Open3.capture3(env, final_command)
       raise "gcloud command '#{final_command}' failed: #{stderr}" unless status.success?
 
-      begin
-        return ::JSON.parse(stdout) if format(out_format) == 'json'
-      rescue ::JSON::ParserError
-        return stdout
+      if format(out_format) == 'json'
+        begin
+          ::JSON.parse(stdout)
+        rescue ::JSON::ParserError
+          stdout.chomp
+        end
+      else
+        stdout.chomp
       end
-
-      stdout
     end
 
     # Stops a GCP VM instance.
@@ -112,7 +122,9 @@ module CemAcpt::Platform::Gcp
     # on the given CGP VM via SSH. Using `ssh` does not invoke the gcloud command
     # and is dependent on the system's SSH configuration.
     def ssh(instance_name, cmd, ignore_command_errors: false, use_proxy_command: true, opts: {})
-      Net::SSH.start(instance_name, user_name, ssh_opts(instance_name: instance_name, use_proxy_command: use_proxy_command, opts: opts)) do |ssh|
+      Net::SSH.start(instance_name, user_name,
+                     ssh_opts(instance_name: instance_name, use_proxy_command: use_proxy_command, opts: opts)) do |ssh|
+        logger.debug("Running SSH command '#{cmd}' on instance '#{instance_name}'")
         result = ssh.exec!(cmd)
         if result.exitstatus != 0 && !ignore_command_errors
           abridged_cmd = cmd.length > 100 ? "#{cmd[0..100]}..." : cmd
@@ -126,29 +138,45 @@ module CemAcpt::Platform::Gcp
     def scp_upload(instance_name, local, remote, use_proxy_command: true, scp_opts: {}, opts: {})
       raise "Local file #{local} does not exist" unless File.exist?(local)
 
-      hostname = use_proxy_command ? vm_alias(instance_name) : instance_name
-      Net::SCP.start(hostname, user_name, ssh_opts(instance_name: instance_name, use_proxy_command: use_proxy_command, opts: opts)) do |scp|
-        scp.upload(local, remote, scp_opts).wait
-      end
+      cmd = [
+        'compute',
+        'scp',
+      ]
+      cmd << '--strict-host-key-checking=no'
+      cmd << "--tunnel-through-iap" if use_proxy_command
+      cmd << "--recurse" if scp_opts[:recurse]
+      cmd << "#{local} #{instance_name}:#{remote}"
+      local_exec(cmd.join(' '), out_format: 'json')
     end
 
     # Downloads a file from the specified VM.
     def scp_download(instance_name, remote, local, use_proxy_command: true, scp_opts: {}, opts: {})
       raise "Local file #{local} does not exist" unless File.exist?(local)
 
-      hostname = use_proxy_command ? vm_alias(instance_name) : instance_name
-      Net::SCP.start(hostname, user_name, ssh_opts(instance_name: instance_name, use_proxy_command: use_proxy_command, opts: opts)) do |scp|
-        scp.download(remote, local, scp_opts).wait
-      end
+      cmd = [
+        'compute',
+        'scp',
+      ]
+      cmd << '--strict-host-key-checking=no'
+      cmd << '--tunnel-through-iap' if use_proxy_command
+      cmd << '--recurse' if scp_opts[:recurse]
+      cmd << "#{instance_name}:#{remote} #{local}"
+      local_exec(cmd.join(' '), out_format: 'json')
     end
 
-    def ssh_ready?(instance_name, timeout = 300, opts: {})
-      with_timed_retry(timeout) do
-        logger.debug("Testing SSH connection to #{instance_name}")
-        Net::SSH.start(instance_name, user_name, ssh_opts(instance_name: instance_name, opts: opts)) do |_|
-          true
-        end
-      end
+    def ssh_ready?(instance_name, opts: {})
+      ssh_options = ssh_opts(instance_name: instance_name, opts: opts)
+      logger.debug("Testing SSH connection to #{instance_name} with options #{ssh_options}")
+      gcloud_ssh(instance_name, 'echo "SSH is ready"')
+      logger.debug('Removing ecdsa & ed25519 host keys from config due to bug in jruby-openssl')
+      gcloud_ssh(instance_name, 'sudo sed -E -i "s;HostKey /etc/ssh/ssh_host_(ecdsa|ed25519)_key;;g" /etc/ssh/sshd_config')
+      logger.debug('Restarting SSH service')
+      gcloud_ssh(instance_name, 'sudo systemctl restart sshd', ignore_command_errors: true)
+      logger.info("SSH connection to #{instance_name} is ready")
+      true
+    rescue StandardError => e
+      logger.debug("SSH connection to #{instance_name} failed: #{e}")
+      false
     end
 
     # This function spawns a background thread to run a GCP IAP tunnel, run the given
@@ -160,9 +188,7 @@ module CemAcpt::Platform::Gcp
     # @param instance_name [String] The name of the GCP VM instance to connect to.
     # @param instance_port [Integer] The port to connect to on the GCP VM instance.
     # @param disable_connection_check [Boolean] If true, the connection check will be disabled.
-    def with_iap_tunnel(instance_name, instance_port = 22, disable_connection_check: false)
-      return unless block_given?
-
+    def with_iap_tunnel(instance_name, instance_port = 22, disable_connection_check: false, &block)
       cmd = [
         'compute start-iap-tunnel',
         "#{instance_name} #{instance_port}",
@@ -174,16 +200,12 @@ module CemAcpt::Platform::Gcp
         port: local_port,
         forward_agent: false,
       }
+      final_cmd = format_gcloud_command(cmd.join(' '), out_format: nil, project_flag: false)
+      tunnel_pid = Process.spawn(env, final_cmd)
       begin
-        thread = Thread.new do
-          local_exec(cmd.join(' '))
-        end
-        yield ssh_opts(use_proxy_command: false, opts: tunnel_ssh_opts)
-        thread.exit
-      rescue IOError
-        # Ignore errors when killing the thread.
+        block.call(ssh_opts(use_proxy_command: false, opts: tunnel_ssh_opts))
       ensure
-        thread.exit
+        Process.kill('TERM', tunnel_pid)
       end
     end
 
@@ -205,47 +227,62 @@ module CemAcpt::Platform::Gcp
         instance_name,
         command.join(' '),
         ignore_command_errors: true,
-        use_proxy_command: false,
         opts: ssh_opts,
       )
     end
 
     def apply_manifest(instance_name, manifest, opts = {})
-      require 'tempfile'
-
-      temp_manifest = Tempfile.new('acpt_manifest')
-      temp_manifest.write(manifest)
-      temp_manifest.close
-      begin
-        scp_upload(
-          instance_name,
-          temp_manifest.path,
-          '/tmp/acpt_manifest.pp',
-          opts: opts[:ssh_opts],
-        )
-      ensure
-        temp_manifest.unlink
+      unless opts[:apply][:no_upload]
+        with_temp_manifest_file(manifest) do |tf|
+          upload_temp_manifest(instance_name, tf.path, remote_path: '/tmp/acpt_manifest.pp', opts: opts)
+        end
       end
-      apply_cmd = [
-        'sudo -n -u root -i',
-        "#{opts[:puppet_path]} apply /tmp/acpt_manifest.pp"
-      ]
+      apply_cmd = [opts[:puppet_path], 'apply', '/tmp/acpt_manifest.pp']
       apply_cmd << '--trace' if opts[:apply][:trace]
       apply_cmd << "--hiera_config=#{opts[:apply][:hiera_config]}" if opts[:apply][:hiera_config]
       apply_cmd << '--debug' if opts[:apply][:debug]
       apply_cmd << '--noop' if opts[:apply][:noop]
       apply_cmd << '--detailed-exitcodes' if opts[:apply][:detailed_exitcodes]
 
-      ssh(
+      run_shell(
         instance_name,
         apply_cmd.join(' '),
-        ignore_command_errors: true,
-        opts: opts[:ssh_opts]
+        opts
       )
     end
 
     private
 
+    def format_gcloud_command(command, out_format: 'json', out_filter: nil, project_flag: true)
+      cmd_parts = ['gcloud', command]
+      cmd_parts << "--project=#{project.chomp}" unless !project_flag || project.nil?
+      cmd_parts << "--format=#{format(out_format)}" if format(out_format)
+      cmd_parts << "--filter=\"#{filter(out_filter)}\"" if filter(out_filter)
+      cmd_parts.join(' ')
+    end
+
+    def with_temp_manifest_file(manifest, file_name: 'acpt_manifest')
+      require 'tempfile'
+      tf = Tempfile.new(file_name)
+      tf.write(manifest)
+      tf.close
+      begin
+        yield tf
+      ensure
+        tf.unlink
+      end
+    end
+
+    def upload_temp_manifest(instance_name, local_path, remote_path: '/tmp/acpt_manifest.pp', opts: {})
+      scp_upload(instance_name, local_path, remote_path, opts: opts[:ssh_opts]) unless opts[:apply][:no_upload]
+    end
+
+    def gcloud_ssh(instance_name, command, ignore_command_errors: false)
+      local_exec("compute ssh --ssh-key-file #{ssh_key} --tunnel-through-iap #{instance_name} --command='#{command}'")
+    rescue StandardError => e
+      raise e unless ignore_command_errors
+    end
+
     def vm_alias(vm)
       "compute.#{vm_describe(vm)['id']}"
     end
@@ -253,21 +290,24 @@ module CemAcpt::Platform::Gcp
     # Default options for Net::SSH
     def default_ssh_opts
       {
-        verify_host_key: :accept_new_or_local_tunnel,
-        keys: [File.join(ENV['HOME'], '.ssh', 'google_compute_engine')],
-        keys_only: true,
-        config: false,
+        auth_methods: ['publickey'],
         check_host_ip: false,
+        compression: true,
+        config: false,
+        keys: [ssh_key],
+        keys_only: true,
+        kex: ['diffie-hellman-group-exchange-sha256'], # ecdh algos cause jruby to shit the bed
         non_interactive: true,
         port: 22,
         user: user_name,
-        user_known_hosts_file: File.join(ENV['HOME'], '.ssh', 'google_compute_known_hosts'),
+        user_known_hosts_file: File.join(ENV['HOME'], '.ssh', 'acpt_test_known_hosts'),
+        verify_host_key: :never,
       }
     end
 
     # Returns a Proxy::Command object to use for the SSH option ProxyCommand.
     # This works in the same way that `gcloud compute ssh --tunnel-through-iap` does.
-    def proxy_command(instance_name, port: 22, quiet: true, verbosity: nil)
+    def proxy_command(instance_name, port: 22, quiet: true, verbosity: 'debug')
       proxy_command = [
         'gcloud compute start-iap-tunnel',
         "#{instance_name} #{port}",
@@ -275,7 +315,7 @@ module CemAcpt::Platform::Gcp
         "--project=#{project}",
         "--zone=#{zone}",
       ]
-      proxy_command << '--no-user-output-enabled --quiet' if quiet
+      #proxy_command << '--no-user-output-enabled --quiet' if quiet
       proxy_command << "--verbosity=#{verbosity}" unless quiet || verbosity.nil? || verbosity.empty?
       Net::SSH::Proxy::Command.new(proxy_command.join(' '))
     end
@@ -307,7 +347,7 @@ module CemAcpt::Platform::Gcp
 
       raise 'failed to find authenticated user name' unless uname
 
-      uname.split(%r{[^a-zA-Z0-9_]}).join('_')
+      uname.gsub(/[^a-zA-Z0-9_]/, '_')
     end
   end
 end

data/lib/cem_acpt/platform/gcp/compute.rb

@@ -240,6 +240,9 @@ module CemAcpt::Platform::Gcp
     end
 
     def create
+      # Add the test ssh key to os-login
+      logger.debug("Adding test SSH key to os-login for #{name}")
+      @cmd.local_exec("compute os-login ssh-keys add --key-file #{@cmd.ssh_key}.pub --project #{project.name} --ttl 4h")
       @cmd.local_exec(create_cmd)
     rescue StandardError => e
       raise "Failed to create VM #{name} with command #{create_cmd}: #{e}"
@@ -253,7 +256,7 @@ module CemAcpt::Platform::Gcp
 
       logger.debug("Checking instance #{name} SSH connectivity")
       @cmd.ssh_ready?(name)
-    rescue StandardError
+    rescue StandardError, Exception
       false
     end
 
@@ -263,7 +266,9 @@ module CemAcpt::Platform::Gcp
 
     def install_puppet_module_package(module_pkg_path, remote_path, puppet_path)
       @cmd.scp_upload(@name, module_pkg_path, remote_path)
+      logger.info("Uploaded module package #{module_pkg_path} to #{remote_path} on #{@name}")
       @cmd.ssh(@name, "sudo #{puppet_path} module install #{remote_path}")
+      logger.info("Installed module package #{remote_path} on #{@name}")
     end
 
     private

data/lib/cem_acpt/platform/gcp.rb

@@ -39,7 +39,7 @@ module Platform
   # If necessary, can pass information into the block to be used in the test suite.
   def run_tests(&block)
     logger.debug("Running tests for #{node_name}...")
-    block.call
+    block.call @instance.cmd.env
   end
 
   # Uploads and installs a Puppet module package on the GCP instance.
@@ -70,7 +70,7 @@ module Platform
     # @param opts [Hash] options to pass to the apply command
     # @return [String] the output of the apply command
     def apply_manifest(instance_name, manifest, opts = {})
-      CemAcpt::Platform::Gcp::Cmd.new(out_format: 'json').apply_manifest(instance_name, manifest, opts)
+      command_provider.apply_manifest(instance_name, manifest, opts)
     end
 
     # Runs a shell command on the given instance
@@ -79,7 +79,7 @@ module Platform
     # @param opts [Hash] options to pass to the run_shell command
     # @return [String] the output of the run_shell command
     def run_shell(instance_name, cmd, opts = {})
-      CemAcpt::Platform::Gcp::Cmd.new(out_format: 'json').run_shell(instance_name, cmd, opts)
+      command_provider.run_shell(instance_name, cmd, opts)
     end
   end
 end