cem_acpt 0.2.5 → 0.6.1

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

@@ -1,332 +0,0 @@
-# frozen_string_literal: true
-
-module CemAcpt::Platform::Gcp
-  require_relative 'cmd'
-  require_relative File.join(__dir__, '..', '..', 'logging.rb')
-
-  module Helper
-    def add_cmd(cmd_obj)
-      @cmd = cmd_obj
-    end
-
-    def cmd
-      @cmd ||= CemAcpt::Platform::Gcp::Cmd.new(out_format: 'json')
-    end
-
-    def cmd_flag_vars?(*vars)
-      vars.none? { |v| v.nil? || (v.empty? if v.respond_to?(:empty?)) }
-    end
-  end
-
-  # This class represents a GCP project
-  class Project
-    include Helper
-
-    def initialize(name: nil, zone: nil)
-      @name = name
-      @zone = zone
-    end
-
-    def name
-      @name ||= cmd.project_from_config
-    end
-
-    def zone
-      @zone ||= cmd.zone_from_config
-    end
-
-    def cmd_flag
-      "--project=#{name}"
-    end
-  end
-
-  # This class represents a GCP VM service account
-  class ServiceAccount
-    include Helper
-
-    attr_reader :name, :scopes
-
-    def initialize(name: nil, scopes: ['devstorage.read_only', 'logging.write', 'monitoring.write', 'servicecontrol', 'service.management.readonly', 'trace.append' ])
-      @name = name
-      @scopes = scopes.map { |s| "https://www.googleapis.com/auth/#{s}" }
-    end
-
-    def cmd_flag
-      "--service-account=#{name} --scopes=#{scopes.join(',')}" if cmd_flag_vars?(name, scopes)
-    end
-  end
-
-  # This class represents a GCP VM disk
-  class Disk
-    include Helper
-
-    attr_reader :project, :name, :size, :image_name
-
-    def initialize(project: nil, name: 'disk-1', image_name: '', size: 20, type: 'pd-standard')
-      @project = project
-      @name = name
-      @image_name = image_name
-      @size = size
-      @type = type
-    end
-
-    def cmd_flag
-      return unless cmd_flag_vars?(name, image, size, type)
-
-      '--create-disk=auto-delete=yes,boot=yes,' \
-      "device-name=#{name},image=#{image}," \
-      "mode=rw,size=#{size},type=#{type}"
-    end
-
-    def type
-      type_path(@type)
-    end
-
-    def image
-      @image ||= image_path(@image_name)
-    end
-
-    private
-
-    def image_path(image_str)
-      raise ArgumentError, 'image must be a non-empty string' unless image_str.is_a?(String) && !image_str.empty?
-
-      data = cmd.local_exec('compute images list', out_filter: "name ~ '#{image_str}$'").first
-      if data.nil? || data.empty?
-        data = cmd.local_exec('compute images list', out_filter: "family ~ '#{image_str}$'").first
-      end
-      raise "Image #{image_str} not found" unless data
-      raise "Image status invalid for image #{data['selfLink']}: #{data[status]}" unless data['status'] == 'READY'
-
-      data['selfLink'].split('v1/')[-1]
-    end
-
-    def type_path(type)
-      raise ArgumentError, 'type must be a non-empty string' unless type.is_a?(String) && !type.empty?
-
-      "projects/#{project.name}/zones/#{project.zone}/diskTypes/#{type}"
-    end
-  end
-
-  # This class represents a GCP VM network interface
-  class NetworkInterface
-    include Helper
-
-    attr_reader :tier, :subnetwork
-
-    def initialize(tier: 'STANDARD', subnetwork: 'default')
-      @tier = tier.upcase
-      @subnetwork = subnetwork
-    end
-
-    def cmd_flag
-      "--network-interface=network-tier=#{tier},subnet=#{subnetwork}" if cmd_flag_vars?(tier, subnetwork)
-    end
-  end
-
-  # This class represents GCP VM metadata
-  class Metadata
-    include Helper
-
-    def initialize(**data)
-      @data = data.transform_keys(&:to_s)
-    end
-
-    def data
-      format_data(@data)
-    end
-
-    def cmd_flag
-      return unless cmd_flag_vars?(data)
-
-      data_from_file = data.select { |k, _v| k == 'ssh-keys' }.map { |k, v| "#{k}=#{v}" }.join(',')
-      normalized_data = data.reject { |k, _v| k == 'ssh-keys' }.map { |k, v| "#{k}=#{v}" }.join(',')
-      cmd = []
-      cmd << "--metadata-from-file=#{data_from_file}" unless data_from_file.empty?
-      cmd << "--metadata=#{normalized_data}" unless normalized_data.empty?
-      cmd.join(' ')
-    end
-
-    private
-
-    def format_data(data)
-      default_data = { 'enable-oslogin' => 'TRUE' }
-      if data['ephemeral_ssh_key']
-        args = {
-          username: (data.dig('ephemeral_ssh_key', 'username') || cmd.user_name),
-        }
-        args[:lifetime] = data.dig('ephemeral_ssh_key', 'lifetime') if data.dig('ephemeral_ssh_key', 'lifetime')
-        args[:keydir] = data.dig('ephemeral_ssh_key', 'keydir') if data.dig('ephemeral_ssh_key', 'keydir')
-        priv_key_path, ssh_keys = ephemeral_ssh_key(**args)
-        default_data['priv_key_local_path'] = priv_key_path
-        default_data['ssh-keys'] = ssh_keys
-        data.delete('ephemeral_ssh_key')
-      end
-      default_data.merge(data)
-    end
-
-    def ephemeral_ssh_key(username: nil, lifetime: 2, keydir: '/tmp/acpt_ssh_keys')
-      raise ArgumentError, 'username must be a non-empty string' unless username.is_a?(String) && !username.empty?
-
-      keypath = File.join(keydir, SecureRandom.hex(10))
-      Dir.mkdir(keydir) unless Dir.exist?(keydir)
-      lifetime_in_seconds = (lifetime.to_i * 60 * 60)
-      iso8601_expiration = (Time.now.utc + lifetime_in_seconds).strftime('%Y-%m-%dT%H:%M:%S%z')
-      keygen_cmd = [
-        'ssh-keygen',
-        '-t ecdsa',
-        '-b 521',
-        "-C 'google-ssh {\"userName\":\"#{username}\",\"expireOn\":\"#{iso8601_expiration}\"}'",
-        "-f #{keypath}",
-        '-N ""',
-        '-q',
-      ].join(' ')
-      _, stderr, status = Open3.capture3(keygen_cmd)
-      raise stderr unless status.success?
-
-      File.write("#{keypath}.pub", "#{username}:#{File.read("#{keypath}.pub")}")
-      [keypath, "#{keypath}.pub"]
-    rescue StandardError => e
-      raise "Failed to generate ephemeral SSH key: #{e} #{e.backtrace}"
-    end
-  end
-
-  # This class represents a GCP VM. It is composed of various component classes.
-  class VM
-    include Helper
-    include CemAcpt::Logging
-
-    attr_accessor :name, :project, :service_account, :disk, :network_interface, :machine_type, :metadata
-    attr_reader :cmd
-
-    def initialize(name, components: {})
-      @name = name
-      @components = components
-      @machine_type = components[:machine_type]
-      @cmd = CemAcpt::Platform::Gcp::Cmd.new(
-        project: components[:project][:name],
-        zone: components[:project][:zone],
-        out_format: 'json',
-        local_port: components[:local_port],
-      )
-      @configured = false
-    end
-
-    def configure!
-      return @configured if @configured
-
-      @project = Project.new(**@components[:project])
-      @project.add_cmd(@cmd)
-      @service_account = @components.key?(:service_account) ? ServiceAccount.new(**@components[:service_account]) : nil
-      @disk = Disk.new(project: @project, **@components[:disk])
-      @disk.add_cmd(@cmd)
-      @network_interface = NetworkInterface.new(**@components[:network_interface])
-      @machine_type = @components[:machine_type]
-      @metadata = Metadata.new(**@components[:metadata])
-      @metadata.add_cmd(@cmd)
-      @configured = true
-    end
-
-    def info
-      describe_cmd = "compute instances describe #{name}"
-      logger.debug("Gathering info for VM #{name} with gcloud command: #{describe_cmd}")
-      data = @cmd.local_exec(describe_cmd, out_format: 'json')
-      opts = @cmd.ssh_opts(instance_name: name)
-      {
-        node_data: data,
-        transport: :ssh,
-        ssh_opts: opts,
-      }
-    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}"
-    end
-
-    def ready?
-      logger.debug("Checking if VM #{name} is ready")
-      instance_status = @cmd.local_exec('compute instances list', out_filter: "NAME = #{name}").first['status']
-      logger.debug("Instance #{name} status: #{instance_status}")
-      return false unless instance_status == 'RUNNING'
-
-      logger.debug("Checking instance #{name} SSH connectivity")
-      @cmd.ssh_ready?(name)
-    rescue StandardError, Exception
-      false
-    end
-
-    def destroy
-      @cmd.delete_instance(name)
-    end
-
-    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
-
-    # Determines whether the given instance name is a fully qualified
-    # hostname or not.
-    def hostname?(instance_name)
-      instance_name.include?('.')
-    end
-
-    # Validates a GCP instance name.
-    def validate_instance_name(instance_name)
-      if instance_name.nil? || !instance_name.is_a?(String) || instance_name.empty?
-        raise ArgumentError, 'Instance name must be a non-empty string'
-      end
-      raise ArgumentError, 'Instance name must be less than 253 characters' if instance_name.length > 253
-
-      return true unless hostname?(instance_name)
-
-      labels = instance_name.split('.')
-      labels.each do |label|
-        unless label.match?(%r{^[a-z]([-a-z0-9]*[a-z0-9])?$})
-          raise ArgumentError, "Instance name portion #{label} contains invalid characters"
-        end
-        raise ArgumentError, "Instance name portion #{label} is too long" if label.length > 63
-      end
-      true
-    end
-
-    def create_cmd
-      validate_instance_name(name)
-      if hostname?(name)
-        instance_name = name.split('.')[0]
-        hostname = name
-      else
-        instance_name = name
-        hostname = nil
-      end
-
-      cmd = [
-        'compute',
-        'instances',
-        'create',
-        instance_name,
-        '--async',
-        "--machine-type=#{machine_type}",
-        '--maintenance-policy=MIGRATE',
-        '--no-shielded-secure-boot',
-        '--shielded-vtpm',
-        '--shielded-integrity-monitoring',
-        '--reservation-affinity=any',
-        '--tags=acpt-test-node',
-      ]
-      [disk&.cmd_flag, network_interface&.cmd_flag, metadata&.cmd_flag, service_account&.cmd_flag].each do |flag|
-        cmd << flag unless flag.nil?
-      end
-      cmd << "--hostname=#{hostname}" unless hostname.nil?
-      cmd.join(' ')
-    end
-  end
-end

data/lib/cem_acpt/platform/vmpooler.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-# Currently a placeholder for future functionality
-module Platform
-  def node
-    logger.debug 'VMPooler node'
-  end
-
-  def provision
-    logger.debug 'VMPooler provision'
-  end
-
-  def destroy
-    logger.debug 'VMPooler destroy'
-  end
-
-  def ready?
-    logger.debug 'VMPooler ready?'
-  end
-
-  def install_puppet_module_package
-    logger.debug 'VMPooler install_puppet_module_package'
-  end
-end

data/lib/cem_acpt/rspec_utils.rb

@@ -1,242 +0,0 @@
-# frozen_string_literal: true
-
-require 'English'
-require 'open3'
-require 'pty'
-require 'shellwords'
-require_relative 'logging'
-
-module CemAcpt
-  # Module that provides methods and objects for running and managing RSpec
-  module RSpecUtils
-    class BundlerNotFoundError < StandardError; end
-    class RSpecNotFoundError < StandardError; end
-
-    # Holds and formats a RSpec command
-    class Command
-      include CemAcpt::LoggingAsync
-      attr_reader :debug, :format, :test_path, :use_bundler, :pty_pid
-
-      # @param opts [Hash] options hash for the RSpec command
-      # @option opts [String] :test_path The path (or glob path) to the test file(s) to run. If blank, runs all.
-      # @option opts [Hash] :format Format options for rspec where the key is the format (documentation, json, etc)
-      #   and the value is the out-file path. If you do not want to save the results of a format to a file, the
-      #   value should be `nil`.
-      # @option opts [Boolean] :debug True if RSpec should run in debug mode, false if not. Mutually exclusive with
-      #   `:quiet`. Default is `false`.
-      # @option opts [Boolean] :quiet True if no output should be logged from RSpec command, false if output should
-      #   be logged. Mutually exclusive with `:debug`. Default is `false`.
-      # @option opts [Boolean] :use_bundler Whether or not `bundle exec` should be used to run the RSpec command.
-      #   Default is `true`.
-      # @option opts [Boolean] :bundle_install Whether or not to run `bundle install` before the RSpec command
-      #   if `use_bundler` is `true`.
-      # @option opts [Boolean] :use_shell Whether or not to add `$SHELL` as a prefix to the command
-      # @option opts [Hash] :env Environment variables to prepend to the command
-      def initialize(opts = {})
-        @test_path = opts[:test_path]&.shellescape
-        @format = opts.fetch(:format, {})
-        @debug = opts.fetch(:debug, false)
-        @quiet = @debug ? false : opts.fetch(:quiet, false)
-        @use_bundler = opts.fetch(:use_bundler, false)
-        @bundle_install = opts.fetch(:bundle_install, false)
-        @env = opts.fetch(:env, {})
-        @pty_pid = nil
-        validate_and_set_bin_paths(opts)
-      end
-
-      # Sets debug mode to `true`
-      def set_debug
-        @debug = true
-        if @quiet
-          async_debug('Setting :quiet to false because :debug is now true.')
-          @quiet = false
-        end
-      end
-
-      # Sets debug mode to `false`
-      def unset_debug
-        @debug = false
-      end
-
-      def quiet
-        @quiet && !debug
-      end
-
-      # Adds a new format to the RSpec command
-      # @param fmt [String] The name of the format (i.e. "documentation", "json", etc.)
-      # @param out [String] If specified, saves the specified format to a file at this path
-      def with_format(fmt, out: nil)
-        @format[fmt.to_sym] = out
-      end
-
-      # Environment variables that will be used for the RSpec command
-      # @return [Hash] A Hash of environment variables with each key pair being: <var name> => <var value>
-      def env
-        @debug ? @env.merge({ 'RSPEC_DEBUG' => 'true' }) : @env
-      end
-
-      # Returns an array representation of the RSpec command
-      def to_a
-        cmd = cmd_base.dup
-        cmd << test_path if test_path
-        format.each do |fmt, out|
-          cmd += ['--format', fmt.to_s.shellescape]
-          cmd += ['--out', out.to_s.shellescape] if out
-        end
-        cmd.compact
-      end
-
-      # Returns a string representation of the RSpec command
-      def to_s
-        to_a.join(' ')
-      end
-
-      # Executes the RSpec command on the current machine
-      # @param pty [Boolean] If true, execute command in a PTY. If false, execute command directly.
-      # @param log_prefix [String] A prefix to add to log messages generated while the command is running.
-      def execute(pty: true, log_prefix: 'RSPEC')
-        if pty
-          execute_pty(log_prefix: log_prefix)
-        else
-          execute_no_pty(log_prefix: log_prefix)
-        end
-      end
-
-      # Executes the RSpec command in a psuedo-terminal (PTY). First, it spawns a process
-      # for $SHELL, sets environment variables `export_envs`, then calls the current RSpec
-      # command in the shell and exits with the last exit code `$?`. Output is read from the
-      # RSpec command in near real-time in a blocking manner unless the `:quiet` option has
-      # been specified.
-      # @param log_prefix [String] A prefix to add to the log messages that are output from
-      #   the RSpec command.
-      # @return [Integer] The exit code of the RSpec command
-      def execute_pty(log_prefix: 'RSPEC')
-        async_debug("Executing RSpec command '#{self}' in PTY...", log_prefix)
-        PTY.spawn(env, ENV['SHELL']) do |r, w, pid|
-          @pty_pid = pid
-          async_debug("Spawned RSpec PTY with PID #{@pty_pid}", log_prefix)
-          export_envs(w)
-          w.puts "#{self}; exit $?"
-          quiet ? wait_io(r) : read_io(r, log_prefix: log_prefix)
-        end
-        $CHILD_STATUS
-      end
-
-      # Executes the RSpec command using Open3.popen2e(). The output stream, which is both
-      # stderr and stdout, is read in real-time in a non-blocking manner.
-      # @param log_prefix [String] A prefix to add to the log messages that are output from
-      #   the RSpec command.
-      # @return [Integer] The exit code of the RSpec command
-      def execute_no_pty(log_prefix: 'RSPEC')
-        async_info("Executing RSpec command '#{self}' with Open3.popen2e()...", log_prefix)
-        exit_status = nil
-        Open3.popen2e(env, to_s) do |stdin, std_out_err, wait_thr|
-          stdin.close
-          quiet ? wait_io(std_out_err) : read_io(std_out_err, log_prefix: log_prefix)
-          exit_status = wait_thr.value
-        end
-        exit_status
-      end
-
-      # Kills the PTY process with `SIGKILL` if the process exists
-      def kill_pty
-        Process.kill('KILL', @pty_pid) unless @pty_pid.nil?
-      rescue Errno::ESRCH
-        true
-      end
-
-      private
-
-      # Detects if the current Ruby context is JRuby
-      def jruby?
-        File.basename(RbConfig.ruby) == 'jruby'
-      end
-
-      # The base RSpec command
-      def cmd_base
-        use_bundler ? cmd_base_bundler : cmd_base_rspec
-      end
-
-      # The base RSpec command if `:use_bundler` is `true`.
-      def cmd_base_bundler
-        base = [@bundle, 'exec', 'rspec']
-        base.unshift("#{@bundle} install;") if @bundle_install
-        base
-      end
-
-      # The base RSpec command if `:use_bundler` is `false`
-      def cmd_base_rspec
-        [@rspec]
-      end
-
-      # Puts export statements for each key-value pair in `env` to the given writer.
-      # Writer is the write pipe of a PTY session, or a similar IO object that can
-      # pass the statements to a shell.
-      # @param writer [IO] An IO object that supprts `puts` and can send statements to a shell
-      def export_envs(writer)
-        env.each do |key, val|
-          writer.puts "export #{key}=#{val}"
-        end
-      end
-
-      # Finds and sets the paths to the `bundle` and `rspec` binaries. The paths can
-      # be either passed in as options in the `opts` Hash or interrogated from the
-      # system.
-      # @param opts [Hash] The options hash
-      # @option opts [String] :bundle An absolute path on the system to the `bundle` binary.
-      # @option opts [String] :rspec An absolute path on the system to the `rspec` binary.
-      # @raise [CemAcpt::RSpecUtils::BundlerNotFoundError] if `@use_bundler` is true and
-      #   `bundle` binary is not found.
-      # @raise [CemAcpt::RSpecUtils::RSpecNotFoundError] if `rspec` binary is not found.
-      def validate_and_set_bin_paths(opts = {})
-        %i[bundle rspec].each do |bin|
-          bin_path = opts[bin] || `command -v #{bin}`.strip
-          bin_not_found(bin, bin_path) unless bin_path && File.exist?(bin_path)
-          instance_variable_set("@#{bin}", bin_path)
-        end
-      end
-
-      # Handles binary paths which are not found
-      # @param bin [Symbol] The binary that was not found, either :bundle or :rspec.
-      # @param bin_path [String] The path to the binary that was checked.
-      # @raise [CemAcpt::RSpecUtils::BundlerNotFoundError] if `@use_bundler` is true and
-      #   `bundle` binary is not found.
-      # @raise [CemAcpt::RSpecUtils::RSpecNotFoundError] if `rspec` binary is not found.
-      # @raise [RuntimeError] if `bin` is not :bundle or :rspec.
-      def bin_not_found(bin, bin_path)
-        msg_base = "#{bin} not found."
-        msg = bin_path.nil? ? "#{msg_base} Path is nil." : "#{msg_base} Path: #{bin_path}"
-        case bin
-        when :bundle
-          raise BundlerNotFoundError, msg if @use_bundler
-        when :rspec
-          raise RSpecNotFoundError, msg
-        else
-          raise "bin #{bin} not recognized!"
-        end
-      end
-
-      # Blocking wait on an IO stream. Wait stops once the IO stream has reached
-      # end of file.
-      # @param stdout [IO] An IO stream with output that can be read from.
-      def wait_io(stdout)
-        sleep(0.01) until stdout.eof?
-      end
-
-      # Reads and logs data from `stdout` in a near real-time, blocking manner.
-      # @param stdout [IO] An IO stream with output that can be read from.
-      # @param log_prefix [String] A string prefix that is added to log messages.
-      def read_io(stdout, log_prefix: 'RSPEC')
-        loop do
-          chunk = stdout.read_nonblock(4096).strip
-          async_info(chunk, log_prefix) unless chunk.nil? || chunk.empty?
-        rescue IO::WaitReadable
-          IO.select([stdout])
-          retry
-        rescue EOFError
-          break
-        end
-      end
-    end
-  end
-end