cem_win_spec 0.1.0

data/lib/cem_win_spec/win_exec/local_exec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'open3'
+require_relative 'base_exec'
+
+module CemWinSpec
+  module WinExec
+    # Class for executing local shell commands
+    class LocalExec < BaseExec
+      attr_reader :thread_results
+
+      def initialize(working_dir = nil)
+        @ran_in_thread = false
+        @thread_results = {}
+        super(working_dir)
+      end
+
+      def available?
+        true
+      end
+
+      def ran_in_thread?
+        @ran_in_thread
+      end
+
+      def any_threads?
+        @ran_in_thread && thread_group.list.any?
+      end
+
+      def join_threads
+        thread_group.list.each(&:join)
+      end
+
+      # Spawn a new process and detach it from the current process
+      # This is useful for running commands that should not block the current process
+      # and that you don't need stdout/stderr from.
+      # @param cmd [String] The command to execute
+      def bg_exec(cmd, *_args, **_kwargs)
+        puts_cmd(cmd)
+        Process.detach(spawn(cd_working_dir(cmd)))
+      end
+
+      # Execute a command in a new thread. This works by creating a new thread in a thread group
+      # and then executing the command in that thread. The thread group is used to keep track of
+      # all the threads that have been created and to join / exit / kill them all at once. The
+      # command results are stored in a hash with the command as the key and the results as the
+      # value. The results are stored as an array of [stdout, stderr, status] where status is a
+      # Process::Status object.
+      # @param cmd [String] The command to execute
+      # @return [Array] An array of [:threaded, cmd]
+      def thread_exec(cmd, *_args, **_kwargs)
+        @ran_in_thread = true
+        th = Thread.new do
+          puts_cmd(cmd)
+          so, se, st = Open3.capture3(cd_working_dir(cmd))
+          @thread_results[cmd] = [so, se, st]
+        end
+        thread_group.add th
+        :threaded
+      end
+
+      def exec(cmd, *_args, **_kwargs)
+        puts_cmd(cmd)
+        Open3.caputure3(cd_working_dir(cmd))
+      end
+
+      private
+
+      def thread_group
+        @thread_group ||= ThreadGroup.new
+      end
+    end
+  end
+end

data/lib/cem_win_spec/win_exec/output.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'winrm'
+require_relative '../logging'
+
+module CemWinSpec
+  module WinExec
+    # Wrapper class for WinRM::Output
+    class Output
+      include CemWinSpec::Logging
+
+      attr_reader :stdout, :stderr, :exitcode
+
+      def initialize(output, quiet: false, line_prefix: "  #$ ")
+        @raw_output = output
+        @quiet = quiet
+        @line_prefix = line_prefix
+        @pending_threaded = nil
+        set_vars_from_output(output)
+      end
+
+      def nil?
+        @raw_output.nil?
+      end
+
+      def success?
+        @exitcode&.zero?
+      end
+
+      def pending_threaded?
+        !@pending_threaded.nil?
+      end
+
+      def puts_combined
+        puts_stream(:stdout)
+        puts_stream(:stderr)
+      end
+
+      def puts_stream(stream_name)
+        return if @quiet || @raw_output.nil?
+        raise "Invalid stream: #{stream_name}" unless %i[stdout stderr].include?(stream_name)
+
+        stream = send(stream_name)
+        return if stream.nil? || stream.empty?
+
+        out_array = stream.split(%r{\n|\r\n}).map do |c|
+          chomped_c = c&.chomp
+          if chomped_c.nil? || chomped_c.strip.empty?
+            nil
+          else
+            format_output_string(chomped_c)
+          end
+        end
+        out_array.compact!
+        return if out_array.empty?
+        
+        logger.info "#{stream_name.to_s.upcase}:\n#{out_array.join("\n")}"
+      end
+
+      private
+
+      def format_output_string(str)
+        # Cut the number of spaces in half, replace tabs with double spaces
+        str.gsub!(/\s\s/, ' ')
+        str.gsub!(/\t/, '  ')
+        return "#{@line_prefix}#{str}" if str.length <= 115
+
+        str.scan(/.{1,115}/).map { |s| "#{@line_prefix}#{s}" }.join("\n")
+      end
+
+      def set_vars_from_output(out)
+        if out.is_a?(Array)
+          if out[0] == :threaded
+            @stdout = ''
+            @stderr = ''
+            @exitcode = 0
+            # Set pending threaded to the command we are waiting on
+            @pending_threaded = out[1]
+          elsif out.length == 3
+            @stdout = out[0]
+            @stderr = out[1]
+            @exitcode = out[2].to_i
+          else
+            raise "Invalid output array: #{out}"
+          end
+        elsif out.is_a? WinRM::Output
+          @stdout = out.stdout
+          @stderr = out.stderr
+          @exitcode = out.exitcode
+        elsif out.is_a? StandardError
+          @stdout = out.message
+          @stderr = out.backtrace.join("\n")
+          @exitcode = 1
+        elsif out.respond_to? :to_s
+          @stdout = out.to_s
+          @stderr = ''
+          @exitcode = 0
+        else
+          raise "Invalid output type: #{out.class}"
+        end
+      end
+    end
+  end
+end

data/lib/cem_win_spec/win_exec/winrm_exec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'winrm'
+require 'winrm-fs'
+require_relative 'base_exec'
+
+module CemWinSpec
+  module WinExec
+    # Class for executing PowerShell commands over WinRM
+    class WinRMExec < BaseExec
+      attr_reader :conn_opts
+
+      def initialize(conn_opts, working_dir = nil, quiet: false)
+        @conn_opts = conn_opts
+        @quiet = quiet
+        @conn = new_conn(@conn_opts.to_h)
+        super(working_dir)
+      end
+
+      def available?
+        @available
+      end
+
+      def exec(cmd, *_args, **_kwargs)
+        puts_cmd(cmd)
+        shell = nil
+        output = nil
+        begin
+          shell = conn.shell(:powershell)
+          output = shell.run(cd_working_dir(cmd))
+        rescue WinRM::WinRMAuthorizationError => e
+          @available = false
+          raise e
+        ensure
+          shell&.close
+        end
+        raise 'Something went wrong, no output from command' if output.nil?
+
+        output
+      end
+
+      def create_dir(path)
+        result = file_manager.create_dir(path)
+        raise "Failed to create directory #{path}" unless result
+
+        logger.info "Created directory #{path}"
+        result
+      end
+
+      def delete_file(path)
+        result = file_manager.delete(path)
+        raise "Failed to delete file #{path}" unless result
+
+        logger.info "Deleted file #{path}"
+        result
+      end
+
+      def file_exists?(path)
+        file_manager.exists?(path)
+      end
+
+      def temp_dir
+        file_manager.temp_dir
+      end
+
+      def upload(local_path, remote_path)
+        file_manager.upload(local_path, remote_path) do |bytes_copied, total_bytes, lpath, rpath|
+          logger.debug "Copied #{bytes_copied} of #{total_bytes} bytes from #{lpath} to #{rpath}"
+        end
+        logger.info "Uploaded #{local_path} to #{remote_path}"
+      end
+
+      private
+
+      attr_reader :conn
+
+      def new_conn(hash_opts)
+        logger.debug "Creating connection to #{hash_opts[:endpoint]}"
+        new_conn = WinRM::Connection.new(hash_opts)
+        new_conn.logger = logger
+        new_conn
+      end
+
+      def file_manager
+        @file_manager ||= WinRM::FS::FileManager.new(conn)
+      end
+    end
+  end
+end

data/lib/cem_win_spec/win_exec.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require 'digest'
+require_relative 'iap_tunnel'
+require_relative 'logging'
+require_relative 'module_archive_builder'
+require_relative 'win_exec/connection_opts'
+require_relative 'win_exec/local_exec'
+require_relative 'win_exec/winrm_exec'
+require_relative 'win_exec/output'
+
+module CemWinSpec
+  module WinExec
+    # Class for executing PowerShell commands over WinRM
+    class Exec
+      include CemWinSpec::Logging
+
+      attr_reader :title, :result, :reuse_tunnel, :ignore_exitcode
+
+      def initialize(title, local_exec, winrm_exec, iap_tunnel, ma_builder, rspec_test_cmds, &block)
+        @title = title
+        @local_exec = local_exec
+        @winrm_exec = winrm_exec
+        @iap_tunnel = iap_tunnel
+        @ma_builder = ma_builder
+        @rspec_test_cmds = rspec_test_cmds
+        @block = block
+        @reuse_tunnel = true
+        @ignore_exitcode = false
+        @spinner = nil
+        @result = nil
+      end
+
+      def reuse_tunnel=(value)
+        raise ArgumentError, 'reuse_tunnel must be a boolean' unless [true, false].include?(value)
+
+        @reuse_tunnel = value
+      end
+      alias reuse_tunnel? reuse_tunnel
+
+      def ignore_exitcode=(value)
+        raise ArgumentError, 'ignore_exitcode must be a boolean' unless [true, false].include?(value)
+
+        @ignore_exitcode = value
+      end
+      alias ignore_exitcode? ignore_exitcode
+  
+      def success?
+        @result.success? if @result.is_a?(Output)
+
+        false
+      end
+
+      def spinner=(value)
+        raise ArgumentError, 'spinner must implement #auto_spin and #stop methods' unless value.respond_to?(:auto_spin) && value.respond_to?(:stop)
+
+        @spinner = value
+      end
+
+      # Proxy method calls for methods that don't exist here to various other objects.
+      # This allows doing things like: `win_exec.remote_exec('Get-Process')` and
+      # calling the `exec` method on the `winrm_exec` object. This is done by
+      # checking method name prefixes and calling the corresponding method on the
+      # appropriate object. The prefix is removed from the method name before
+      # calling the method on the object. The supported prefixes are:
+      #   local_ - calls the method on the @local_exec object
+      #   remote_ - calls the method on the @winrm_exec object
+      #   rspec_ - calls the method on the @rspec_test_cmds object
+      #   module_archive_ - calls the method on the @ma_builder object
+      def method_missing(method, *args, **kwargs, &block)
+        if method.to_s.start_with?('local_') # proxy to local_exec
+          method = method.to_s.sub('local_', '').to_sym
+          @local_exec.send(method, *args, **kwargs, &block)
+        elsif method.to_s.start_with?('remote_') # proxy to winrm_exec
+          method = method.to_s.sub('remote_', '').to_sym
+          @winrm_exec.send(method, *args, **kwargs, &block)
+        elsif method.to_s.start_with?('rspec_') # proxy to rspec_test_cmds
+          method = method.to_s.sub('rspec_', '').to_sym
+          @rspec_test_cmds.send(method, *args, **kwargs, &block)
+        elsif method.to_s.start_with?('module_archive_') # proxy to ma_builder
+          method = method.to_s.sub('module_archive_', '').to_sym
+          @ma_builder.send(method, *args, **kwargs, &block)
+        else
+          super
+        end
+      end
+
+      # Proxy respond_to? for methods that don't exist here to various other objects.
+      # This allows doing things like: `win_exec.respond_to?(:remote_exec)` and
+      # checking if the `exec` method exists on the `winrm_exec` object. This is done by
+      # checking method name prefixes and calling the corresponding method on the
+      # appropriate object. The prefix is removed from the method name before
+      # calling the method on the object. The supported prefixes are:
+      #   local_ - calls the method on the @local_exec object
+      #   remote_ - calls the method on the @winrm_exec object
+      #   rspec_ - calls the method on the @rspec_test_cmds object
+      #   module_archive_ - calls the method on the @ma_builder object
+      def respond_to_missing?(method, include_private = false)
+        if method.to_s.start_with?('local_')
+          @local_exec.respond_to?(method.to_s.sub('local_', '').to_sym, include_private)
+        elsif method.to_s.start_with?('remote_')
+          @winrm_exec.respond_to?(method.to_s.sub('remote_', '').to_sym, include_private)
+        elsif method.to_s.start_with?('rspec_')
+          @rspec_test_cmds.respond_to?(method.to_s.sub('rspec_', '').to_sym, include_private)
+        elsif method.to_s.start_with?('module_archive_')
+          @ma_builder.respond_to?(method.to_s.sub('module_archive_', '').to_sym, include_private)
+        else
+          super
+        end
+      end
+  
+      def run(*args, **kwargs)
+        logger.info "Running #{@title}"
+        @spinner&.auto_spin
+        result = if reuse_tunnel?
+                   @iap_tunnel.start # ensure tunnel is running
+                   run_in_current_scope(*args, **kwargs)
+                 else
+                   @iap_tunnel.stop # ensure tunnel is stopped
+                   @iap_tunnel.with do # start tunnel for this block
+                     run_in_current_scope(*args, **kwargs)
+                   end
+                 end
+        @spinner&.stop
+        @result = Output.new(result)
+        return if @result.pending_threaded?
+
+        @result.puts_combined
+        unless @result.success? || ignore_exitcode?
+          raise "Command failed with exit code #{@result.exitcode}: #{@result.stdout}\n#{@result.stderr}"
+        end
+        @result
+      rescue StandardError => e
+        logger.error "Error running #{@title}: #{e.message[0..100]}"
+        @result = Output.new(e)
+        raise e unless ignore_exitcode?
+      end
+
+      private
+
+      def run_in_current_scope(*args, **kwargs)
+        instance_exec(*args, **kwargs, &@block)
+      end
+
+      def wrap_spinner
+        @spinner.auto_spin if @spinner
+        yield if block_given?
+      ensure
+        @spinner.stop if @spinner
+      end
+    end
+
+    # Factory class for creating a WinExec object
+    class Factory
+      include CemWinSpec::Logging
+
+      attr_reader :current_local_exec, :current_winrm_exec, :current_conn_opts
+
+      def initialize(iap_tunnel, ma_builder, rspec_test_cmds)
+        @iap_tunnel = iap_tunnel
+        @ma_builder = ma_builder
+        @rspec_test_cmds = rspec_test_cmds
+        @current_local_exec = LocalExec.new
+        @current_winrm_exec = nil
+        @current_conn_opts = nil
+      end
+
+      # Build a WinExec object
+      # @param title [String] Title of the WinExec object
+      # @param merge [Boolean] Merge the current connection options with the new options, if applicable
+      # @param host [String] Hostname or IP address of the remote host
+      # @param port [Integer] Port of the remote host
+      # @param user [String] Username for the remote host
+      # @param pass [String] Password for the remote host
+      # @param opts [Hash] Additional options for the WinRM connection
+      # @return [Exec] An Exec object
+      def build(title, merge: true, user: nil, pass: nil, working_dir: nil, **opts, &block)
+        logger.debug "Building Wexec object for #{title}"
+        build_conn_opts(merge: merge, user: user, pass: pass, **opts)
+        logger.debug 'Created ConnectionOpts'
+        wexec = Exec.new(title, @current_local_exec, get_winrm_exec(working_dir), @iap_tunnel, @ma_builder, @rspec_test_cmds, &block)
+        wexec.reuse_tunnel = opts[:reuse_tunnel] if opts.key?(:reuse_tunnel)
+        wexec.ignore_exitcode = opts[:ignore_exitcode] if opts.key?(:ignore_exitcode)
+        wexec.spinner = opts[:spinner] if opts.key?(:spinner)
+        logger.debug 'Created Wexec'
+        wexec
+      end
+
+      def local_threaded_results
+        logger.info 'Checking for deferred results...'
+        @current_local_exec.join_threads
+        @current_local_exec.threaded_results.each do |cmd, results|
+          logger.info "Deferred results for #{cmd}:"
+          Output.new(results).puts_combined
+        end
+      end
+
+      private
+
+      def build_conn_opts(merge: true, user: nil, pass: nil, **opts)
+        if @current_conn_opts.nil?
+          logger.debug 'Creating new ConnectionOpts object'
+          @current_conn_opts = ConnectionOpts.new(new_host: 'localhost', new_port: @iap_tunnel.port, user: user, pass: pass, **opts)
+          return @current_conn_opts
+        end
+        opts_digest = Digest::SHA256.hexdigest(['localhost', @iap_tunnel.port, user, pass, opts].join(':'))
+        if opts_digest != @current_conn_opts.digest
+          if merge
+            logger.debug 'Merging ConnectionOpts with new options'
+            @current_conn_opts = @current_conn_opts.merge(new_host: 'localhost', new_port: @iap_tunnel.port, user: user, pass: pass, **opts)
+          else
+            logger.debug 'Creating new ConnectionOpts object with new options'
+            @current_conn_opts = ConnectionOpts.new(new_host: 'localhost', new_port: @iap_tunnel.port, user: user, pass: pass, **opts)
+          end
+        else
+          logger.debug 'Returning existing ConnectionOpts object'
+        end
+        @current_conn_opts
+      end
+
+
+      def get_winrm_exec(working_dir = nil)
+        if @current_winrm_exec.nil? || @current_winrm_exec.conn_opts.digest != @current_conn_opts.digest
+          logger.debug 'Creating new WinRMExec object'
+          @current_winrm_exec = WinRMExec.new(@current_conn_opts)
+        end
+        logger.debug "Setting working directory to #{working_dir}" unless working_dir.nil?
+        @current_winrm_exec.working_dir = working_dir
+        logger.debug 'Returning WinRMExec object'
+        @current_winrm_exec
+      end
+    end
+  end
+end

data/lib/cem_win_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'tty-spinner'
+require_relative 'cem_win_spec/logging'
+require_relative 'cem_win_spec/test_runner'
+
+module CemWinSpec
+  class << self
+    include CemWinSpec::Logging
+  end
+
+  def self.signal_handler(runner)
+    Signal.trap('INT') do
+      puts 'Caught interrupt, killing tunnel and exiting'
+      runner.iap_tunnel.stop(wait: false, log: false)
+      exit 1
+    end
+    Signal.trap('TERM') do
+      puts 'Caught interrupt, killing tunnel and exiting'
+      runner.iap_tunnel.stop(wait: false, log: false)
+      exit 1
+    end
+  end
+
+  # Runs the tests
+  # @param options [Hash] Options for the test runner
+  # @option options [Boolean] :quiet (false) Whether to suppress output
+  # @option options [Boolean] :debug (false) Whether to enable debug output
+  # @option options [Boolean] :verbose (false) Whether to enable verbose output
+  # @option options [String] :log_level (nil) Explicitly set the log level
+  # @option options [String] :log_file (nil) Log output to file
+  # @option options [String] :log_format (nil) Set log format(text, json, github_action)
+  def self.run_tests(options = {})
+    raise 'Must be ran from the root of the project' unless File.exist?('Gemfile')
+
+    log_setup!(options)
+    logger.info 'Running tests'
+    logger.debug "Options: #{options}"
+    runner = TestRunner.new
+    logger.debug "Created TestRunner: #{runner}"
+    signal_handler(runner)
+    logger.debug 'Set up signal handler'
+    exitcode = 99
+    spinner = TTY::Spinner.new(format: :classic, interval: 1, hide_cursor: true, clear: true)
+    begin
+      runner.enable_long_paths.run
+      runner.enable_symlinks.run
+      working_dir_out = runner.create_working_dir.run
+      working_dir = working_dir_out&.stdout.chomp
+      logger.debug "Working dir: #{working_dir}"
+      module_dir = runner.upload_module(working_dir: working_dir).run&.stdout.chomp
+      logger.debug "Module dir: #{module_dir}"
+      runner.setup_ruby(operation_timeout: 300,
+                        receive_timeout: 310,
+                        working_dir: module_dir,
+                        reuse_tunnel: false,
+                        spinner: spinner).run
+      runner.rspec_prep(working_dir: module_dir, reuse_tunnel: false, spinner: spinner).run
+      spec_out = runner.rspec_tests_parallel(operation_timeout: 300,
+                                             receive_timeout: 310,
+                                             working_dir: module_dir,
+                                             ignore_exitcode: true,
+                                             reuse_tunnel: false,
+                                             spinner: spinner).run
+      # We currently don't have any local commands being run
+      # but we may in the future. If we do, we'll need to
+      # call local_threaded_results on the TestRunner
+      # runner.local_threaded_results
+      exitcode = spec_out&.exitcode
+      logger.info "Completed tests with exit code: #{exitcode}"
+    rescue StandardError => e
+      logger.fatal "Error: #{e.message}"
+      logger.debug e.backtrace.join("\n")
+      exitcode = 1
+    ensure
+      exit exitcode
+    end
+  end
+end

data/sig/cem_win_spec.rbs

@@ -0,0 +1,4 @@
+module CemWinSpec
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end