cem_acpt 0.7.2 → 0.8.0

data/lib/cem_acpt/test_runner.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
+require 'securerandom'
+require_relative 'action_result'
 require_relative 'goss'
 require_relative 'logging'
 require_relative 'platform'
 require_relative 'provision'
 require_relative 'test_data'
 require_relative 'utils'
+require_relative 'utils/winrm_runner'
 require_relative 'version'
 require_relative 'test_runner/log_formatter'
 
@@ -17,14 +20,16 @@ module CemAcpt
       include CemAcpt::Logging
 
       attr_reader :duration, :exit_code
+      attr_accessor :run_data # This is opened up mainly for windows use.
 
       def initialize(config)
         @config = config
         @run_data = {}
         @duration = 0
         @exit_code = 0
-        @results = nil
+        @results = []
         @http_statuses = []
+        @provisioned = false
       end
 
       def inspect
@@ -38,40 +43,66 @@ module CemAcpt
       def run
         @run_data = {}
         @start_time = Time.now
-        logger.with_ci_group("CemAcpt v#{CemAcpt::VERSION} run started at #{@start_time}") do
-          logger.info('CemAcpt') { "Using module directory: #{config.get('module_dir')}..." }
-          Dir.chdir(config.get('module_dir')) do
-            keep_terminal_alive
-            @run_data[:private_key], @run_data[:public_key], @run_data[:known_hosts] = new_ephemeral_ssh_keys
-            logger.info('CemAcpt') { 'Created ephemeral SSH key pair...' }
-            @run_data[:module_package_path] = build_module_package
-            logger.info('CemAcpt') { "Created module package: #{@run_data[:module_package_path]}..." }
-            @run_data[:test_data] = new_test_data
-            logger.info('CemAcpt') { 'Created test data...' }
-            logger.verbose('CemAcpt') { "Test data: #{@run_data[:test_data]}" }
-            @run_data[:nodes] = new_node_data
-            logger.info('CemAcpt') { 'Created node data...' }
-            logger.verbose('CemAcpt') { "Node data: #{@run_data[:nodes]}" }
-            @instance_names_ips = provision_test_nodes
-            logger.info('CemAcpt') { 'Provisioned test nodes...' }
-            logger.debug('CemAcpt') { "Instance names and IPs: #{@instance_names_ips}" }
-            @results = run_tests(@instance_names_ips.map { |_, v| v['ip'] },
-                                 config.get('actions.only'),
-                                 config.get('actions.except'))
+        module_dir = config.get('module_dir')
+        @old_dir = Dir.pwd
+        Dir.chdir(module_dir)
+        logger.start_ci_group("CemAcpt v#{CemAcpt::VERSION} run started at #{@start_time}")
+        logger.info('CemAcpt::TestRunner') { "Using module directory: #{module_dir}..." }
+        keep_terminal_alive
+        @run_data[:private_key], @run_data[:public_key], @run_data[:known_hosts] = new_ephemeral_ssh_keys
+        logger.info('CemAcpt::TestRunner') { 'Created ephemeral SSH key pair...' }
+        @run_data[:module_package_path] = build_module_package
+        logger.info('CemAcpt::TestRunner') { "Created module package: #{@run_data[:module_package_path]}..." }
+        @run_data[:test_data] = new_test_data
+        logger.info('CemAcpt::TestRunner') { 'Created test data...' }
+        logger.verbose('CemAcpt::TestRunner') { "Test data: #{@run_data[:test_data]}" }
+        @run_data[:nodes] = new_node_data
+        logger.info('CemAcpt::TestRunner') { 'Created node data...' }
+        logger.verbose('CemAcpt::TestRunner') { "Node data: #{@run_data[:nodes]}" }
+        @instance_names_ips = provision_test_nodes
+        logger.info('CemAcpt::TestRunner') { "Instance names and IPs class: #{@instance_names_ips.class}" }
+        @provisioned = true
+        logger.info('CemAcpt::TestRunner') { 'Provisioned test nodes...' }
+        logger.debug('CemAcpt::TestRunner') { "Instance names and IPs: #{@instance_names_ips}" }
+        # Verifying that we're running on windows nodes or not
+        if config.get('tests').first.include? 'windows'
+          logger.info('CemAcpt') { 'Running on windows nodes...' }
+          upload_module_to_bucket
+
+          @instance_names_ips.each do |k, v|
+            # Login_info here is basically a super charged version of a hash from
+            # instance_names_ips. It contains the username, password, and ip of the
+            # windows node, as well as the test name that will be run on that node.
+            login_info = CemAcpt::Utils.get_windows_login_info(k, v)
+            win_node = CemAcpt::Utils::WinRMRunner::WinNode.new(login_info, @run_data[:module_package_path].split('/').last)
+            win_node.run
           end
         end
+        @results = run_tests(@instance_names_ips.map { |_, v| v['ip'] },
+                              config.get('actions.only'),
+                              config.get('actions.except'))
+      rescue StandardError => e
+        logger.error('CemAcpt::TestRunner') { 'Run failed due to error...' }
+        @results << ActionResult.new(e)
       ensure
         clean_up
         process_test_results
+        Dir.chdir(@old_dir) if @old_dir
+        @results
       end
 
       def clean_up(trap_context = false)
+        logger.end_ci_group
         kill_keep_terminal_alive unless trap_context
+        cleanup_bucket # Clean up bucket if we're testing the cem_windows module
 
         return no_destroy if config.get('no_destroy_nodes')
 
         clean_ephemeral_ssh_keys
-        destroy_test_nodes
+        destroy_test_nodes if @provisioned && !@destroyed
+      rescue StandardError => e
+        logger.verbose('CemAcpt::TestRunner') { "Error cleaning up: #{e}" }
+        logger.verbose('CemAcpt::TestRunner') { e.backtrace.join("\n") }
       end
 
       private
@@ -93,31 +124,40 @@ module CemAcpt
 
       # @return [String] The path to the module package
       def build_module_package
-        CemAcpt::Utils::Puppet.build_module_package(config.get('module_dir'))
+        if config.get('tests').first.include? 'windows'
+          CemAcpt::Utils.package_win_module(config.get('module_dir'))
+        else
+          CemAcpt::Utils::Puppet.build_module_package(config.get('module_dir'))
+        end
       end
 
       # @return [Array<String>] The paths to the ssh private key, public key, and known hosts file
       def new_ephemeral_ssh_keys
         return [nil, nil, nil] if config.get('no_ephemeral_ssh_key')
 
+        logger.info('CemAcpt::TestRunner') { 'Creating ephemeral SSH keys...' }
         CemAcpt::Utils::SSH::Ephemeral.create
       end
 
       def clean_ephemeral_ssh_keys
         return if config.get('no_ephemeral_ssh_key') || config.get('no_destroy_nodes')
 
+        logger.info('CemAcpt::TestRunner') { 'Cleaning ephemeral SSH keys...' }
         CemAcpt::Utils::SSH::Ephemeral.clean
       end
 
       def new_test_data
+        logger.debug('CemAcpt::TestRunner') { 'Creating new test data...' }
         CemAcpt::TestData.acceptance_test_data(config)
       end
 
       def new_node_data
+        logger.debug('CemAcpt::TestRunner') { 'Creating new node data...' }
         CemAcpt::Platform.use(config.get('platform.name'), config, @run_data)
       end
 
       def provision_test_nodes
+        logger.info('CemAcpt::TestRunner') { 'Provisioning test nodes...' }
         @provisioner = CemAcpt::Provision.new_provisioner(config, @run_data)
         @provisioner.provision
       end
@@ -125,62 +165,121 @@ module CemAcpt
       def destroy_test_nodes
         return no_destroy if config.get('no_destroy_nodes')
 
-        logger.with_ci_group("CemAcpt v#{CemAcpt::VERSION} run finished at #{Time.now}") { @provisioner&.destroy }
+        logger.info('CemAcpt::TestRunner') { 'Destroying test nodes...' }
+        logger.start_ci_group("CemAcpt v#{CemAcpt::VERSION} run finished at #{Time.now}")
+        @provisioner&.destroy
+        @destroyed = true
+      ensure
+        logger.end_ci_group
       end
 
       def no_destroy
-        logger.warn('CemAcpt') { 'Not destroying test nodes...' }
-        logger.with_ci_group("CemAcpt v#{CemAcpt::VERSION} run finished at #{Time.now}") do
-          @provisioner&.show
-          logger.info('CemAcpt') { "Test SSH Keys:\n  Private Key: #{@run_data[:private_key]}\n  Public Key:#{@run_data[:public_key]}" }
-        end
+        logger.warn('CemAcpt::TestRunner') { 'Not destroying test nodes...' }
+        logger.start_ci_group("CemAcpt v#{CemAcpt::VERSION} run finished at #{Time.now}")
+        @provisioner&.show
+        logger.info('CemAcpt') { "Test SSH Keys:\n  Private Key: #{@run_data[:private_key]}\n  Public Key:#{@run_data[:public_key]}" }
+      ensure
+        logger.end_ci_group
       end
 
       def run_tests(hosts, only_actions, except_actions)
-        only_actions = [] if only_actions.nil?
-        except_actions = [] if except_actions.nil?
-        CemAcpt::Goss::Api.run_actions_async(hosts, only: only_actions, except: except_actions)
-      end
-
-      def result_log_formatter
-        @result_log_formatter ||= LogFormatter::GossActionResponse.new(config, @instance_names_ips)
+        logger.info('CemAcpt::TestRunner') { 'Running tests...' }
+        logger.verbose('CemAcpt::TestRunner') { "Hosts: #{hosts}" }
+        logger.verbose('CemAcpt::TestRunner') { "Only actions: #{only_actions}" }
+        logger.verbose('CemAcpt::TestRunner') { "Except actions: #{except_actions}" }
+        api_results = CemAcpt::Goss::Api.run_actions_async(hosts,
+                                                           only: only_actions || [],
+                                                           except: except_actions || [])
+        res = []
+        api_results.close unless api_results.closed?
+        while (r = api_results.pop)
+          res << ActionResult.new(r)
+        end
+        res
       end
 
       def process_test_results
-        if @results.nil?
-          logger.error('CemAcpt') { 'No test results to process' }
+        if @results.nil? || @results.empty?
+          logger.error('CemAcpt::TestRunner') { 'No test results to process' }
           @exit_code = 1
         else
+          logger.info('CemAcpt::TestRunner') { "Processing #{@results.size} test result(s)..." }
           until @results.empty?
             result = @results.pop
             @http_statuses << result.http_status
             log_test_result(result)
           end
           if @http_statuses.empty?
-            logger.error('CemAcpt') { 'No test results to process' }
+            logger.error('CemAcpt::TestRunner') { 'No test results to process' }
             @exit_code = 1
           else
-            @exit_code = @http_statuses.any? { |s| s.to_i != 200 } ? 1 : 0
+            @exit_code = (@http_statuses.any? { |s| s.to_i != 200 }) ? 1 : 0
           end
         end
         @duration = Time.now - @start_time
-        logger.info('CemAcpt') { "Test suite finished after ~#{duration.round} seconds." }
+        logger.info('CemAcpt::TestRunner') { "Test suite finished after ~#{duration.round} seconds." }
       end
 
       def log_test_result(result)
-        logger.with_ci_group("Test results for #{result_log_formatter.test_name(result)}") do
-          logger.info(result_log_formatter.summary(result))
-          formatted_results = result_log_formatter.results(result)
-          formatted_results.each do |r|
-            if r.start_with?('Passed:')
-              logger.verbose { r }
-            elsif r.start_with?('Skipped:')
-              logger.info { r }
-            else
-              logger.error { r }
-            end
+        result_log_formatter = LogFormatter.new_formatter(result, config, @instance_names_ips)
+        logger.start_ci_group("Test results for #{result_log_formatter.test_name(result)}")
+        return log_error_test_result(result_log_formatter, result) if result.error?
+
+        logger.info(result_log_formatter.summary(result))
+        formatted_results = result_log_formatter.results(result)
+        formatted_results.each do |r|
+          if r.start_with?('Passed:')
+            logger.verbose { r }
+          elsif r.start_with?('Skipped:')
+            logger.info { r }
+          else
+            logger.error { r }
           end
         end
+      ensure
+        logger.end_ci_group
+      end
+
+      def log_error_test_result(formatter, result)
+        logger.fatal { formatter.results(result).join("\n") }
+      end
+
+      # Upload the cem_windows module to the bucket if we're testing the cem_windows module
+      # This should only be done once per cem_acpt run. It's important to update the module_package_path
+      # in the run_data to reflect the new module path if we do end up changing the module name
+      def upload_module_to_bucket
+        curr_module_path = @run_data[:module_package_path].split('/')[0..-2].join('/')
+        curr_module_name = @run_data[:module_package_path].split('/')[-1]
+
+        logger.debug('CemAcpt') { 'Checking if there duplicate cem_windows module in the bucket already...' }
+        # Checking if the module already exists in the bucket. Gcloud will return an empty string if the module
+        # doesn't exist in the bucket.
+        attempts = 0
+        until `gcloud storage ls gs://win_cem_acpt/#{curr_module_name}`.empty? do
+          raise "Failed to rename duplicate module in GCloud" if attempts >= 3
+
+          logger.debug('CemAcpt') { 'Duplicate cem_windows module found. Renaming cem_windows module...' }
+          # Rename the cem_windows module
+          curr_module_name = SecureRandom.uuid << curr_module_name
+          `mv #{@run_data[:module_package_path]} #{curr_module_path}/#{curr_module_name}`
+          # update the module_package_path in the run_data
+          @run_data[:module_package_path] = File.join(curr_module_path, curr_module_name)
+          attempts += 1
+        end
+        # Upload the module from the local host to the bucket
+        logger.info('CemAcpt') { 'Transporting cem_windows module...' }
+        gcloud_cmd = `gcloud storage cp #{@run_data[:module_package_path]} gs://win_cem_acpt`
+        logger.debug('CemAcpt') { "Uploaded cem_windows module to bucket: #{gcloud_cmd}" }
+      end
+
+      # We have to clean up our gcp bucket after we're done testing. This will limit the duplicated
+      # modules existing in the bucket.
+      def cleanup_bucket
+        # Cleanup the module from the bucket
+        cleanup_cmd = `gcloud storage rm gs://win_cem_acpt/#{@run_data[:module_package_path].split('/')[-1]}`
+        logger.debug('CemAcpt') { "Removed module from bucket: #{cleanup_cmd}" }
+      rescue StandardError
+        logger.info('CemAcpt') { 'No module to clean up in the bucket. You might not be running test for cem_windows' }
       end
     end
   end

data/lib/cem_acpt/utils/ssh.rb

@@ -31,7 +31,7 @@ module CemAcpt
         def create(key_name, **options)
           delete(key_name) # Delete existing keys with same name
           cmd = new_keygen_cmd(key_name, **options)
-          logger.debug("Creating SSH key with command: #{cmd}")
+          logger.debug('CemAcpt::Utils::SSH::Keygen') { "Creating SSH key with command: #{cmd}" }
           _stdout, stderr, status = Open3.capture3(cmd)
           raise "Failed to create SSH key! #{stderr}" unless status.success?
 
@@ -42,7 +42,7 @@ module CemAcpt
           priv_key = key_path(key_name)
           pub_key = key_path(key_name, public_key: true)
           if ::File.file?(priv_key)
-            logger.debug("Deleting private key: #{priv_key}")
+            logger.debug('CemAcpt::Utils::SSH::Keygen') { "Deleting private key: #{priv_key}" }
             ::File.delete(priv_key)
           end
           if ::File.file?(pub_key)

data/lib/cem_acpt/utils/terminal.rb

@@ -1,14 +1,11 @@
 # frozen_string_literal: true
 
-require 'concurrent-ruby'
-
 module CemAcpt
   module Utils
     # Terminal-related utilities
     module Terminal
       def self.keep_terminal_alive
-        executor = Concurrent::SingleThreadExecutor.new
-        executor.post do
+        Thread.new do
           loop do
             $stdout.print(".\r")
             sleep(1)
@@ -20,7 +17,6 @@ module CemAcpt
             sleep(1)
           end
         end
-        executor
       end
     end
   end

data/lib/cem_acpt/utils/winrm_runner.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'winrm'
+require_relative '../logging'
+
+module CemAcpt
+  module Utils
+    module WinRMRunner
+      class WinRMExecutionError < StandardError; end
+
+      # A wrapper class for executing commands on a windows node
+      # Provides error handling and logging on each command being executed
+      class RunnerWrapper
+        include CemAcpt::Logging
+
+        def initialize(shell)
+          @shell = shell
+        end
+
+        def run(command)
+          output = @shell.run(command) do |stdout, stderr|
+            puts stdout
+            puts stderr
+          end
+
+          # At any point, if the exit code is not 0, we will raise an error and stop the test
+          # Because if one command fails, it will effect the rest of the test.
+          if output.exitcode != 0
+            raise WinRMExecutionError, "Command #{command} failed with exit code #{output.exitcode}. Error: #{output.stderr}"
+          end
+        end
+      end
+
+      # A class for setting up windows nodes for testing
+      # Applies puppet manifest on nodes and installs the cem_windows module
+      class WinNode
+        include CemAcpt::Logging
+
+        attr_reader :mod_name
+
+        def initialize(login_info, mod_name)
+          @login_info = login_info
+          @mod_name = mod_name
+        end
+
+        def run_winrm
+          logger.info('CemAcpt') { 'Setting up Windows nodes for test...' }
+
+          cem_windows_mod_dir = "C:\\ProgramData\\PuppetLabs\\code\\environments\\production\\modules\\cem_windows"
+
+          @login_info.each do |node_name, node_info|
+            username = node_info['username']
+            password = node_info['password']
+            test_name = node_info['test_name']
+            ip = node_info['ip']
+
+            opts = {
+              endpoint: "https://#{ip}:5986/wsman",
+              user: username,
+              password: password,
+              transport: :ssl,
+              no_ssl_peer_verification: true,
+              retry_limit: 5,
+              retry_delay: 20,
+            }
+
+            conn = WinRM::Connection.new(opts)
+            conn.shell(:powershell) do |shell|
+              # Instantiate the wrapper class
+              winrm_runner = RunnerWrapper.new(shell)
+              # The below steps for enabling long paths, installing Puppet and make cem_acpt directory will be a part of making the custom image.
+              # Enable long paths
+              logger.debug('CemAcpt') { 'Enabling long paths...' }
+              winrm_runner.run('Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem" -Name "LongPathsEnabled" -Value 1')
+              # Download Puppet and Install it
+              logger.info('CemAcpt') { 'Downloading and installing Puppet...' }
+              winrm_runner.run('Invoke-WebRequest -URI http://downloads.puppetlabs.com/windows/puppet7/puppet-agent-7.25.0-x64.msi -OutFile "C:\puppet-agent-7.25.0-x64.msi"')
+              winrm_runner.run("Start-process msiexec.exe -Wait -ArgumentList '/I C:\\puppet-agent-7.25.0-x64.msi PUPPET_AGENT_STARTUP_MODE=Disabled /qn /norestart'")
+              # Create our cem_acpt parent directory
+              logger.debug('CemAcpt') { 'Creating cem_acpt directory and downloading necessary files...' }
+              winrm_runner.run("mkdir C:\\cem_acpt")
+              # Download the cem_windows module from the bucket to cem_acpt directory
+              winrm_runner.run("gcloud storage cp gs://win_cem_acpt/#{@mod_name} C:\\cem_acpt")
+              # Install the cem_windows module
+              logger.info('CemAcpt') { 'Installing cem_windows module...' }
+              winrm_runner.run("Start-Process -FilePath 'C:\\Program Files\\Puppet Labs\\Puppet\\bin\\puppet.bat' -ArgumentList 'module install C:\\cem_acpt\\#{@mod_name}' -Wait -NoNewWindow")
+              # Download Goss and set it to alpha mode since it's on alpha for windows
+              logger.info('CemAcpt') { 'Downloading Goss...' }
+              winrm_runner.run("Invoke-WebRequest -URI https://github.com/goss-org/goss/releases/download/v0.3.23/goss-alpha-windows-amd64.exe -OutFile 'C:\\goss.exe'")
+              # Since we already installed the cem_windows module, we can unpack it to get the goss.yaml and the manifest.pp in spec/acceptance dir
+              # Due to the pain in the ass of trying to parse a string that is yaml dumped in ruby through powershell, I'm just gonna create the yaml
+              # in the cem_windows module itself and then move them to the directory at C:/cem_acpt for ease of access and use. The location for these two
+              # files will be at spec/files
+              winrm_runner.run("Move-Item -Path #{cem_windows_mod_dir}\\spec\\files\\puppet_idempotent.yaml -Destination C:\\cem_acpt")
+              winrm_runner.run("Move-Item -Path #{cem_windows_mod_dir}\\spec\\files\\puppet_noop.yaml -Destination C:\\cem_acpt")
+              # Grab the goss.yaml and the manifest.pp from the cem_windows module using the test_name from run_data and move to top level of C:/cem_acpt/
+              winrm_runner.run("Move-Item -Path #{cem_windows_mod_dir}\\spec\\acceptance\\#{test_name}\\goss.yaml -Destination C:\\cem_acpt")
+              winrm_runner.run("Move-Item -Path #{cem_windows_mod_dir}\\spec\\acceptance\\#{test_name}\\manifest.pp -Destination C:\\cem_acpt")
+              # Open up firewall ports
+              logger.debug('CemAcpt') { 'Opening up firewall ports...' }
+              winrm_runner.run('netsh advfirewall firewall add rule name="Goss in" dir=in action=allow protocol=TCP localport=8080')
+              winrm_runner.run('netsh advfirewall firewall add rule name="Idempotent in" dir=in action=allow protocol=TCP localport=8081')
+              winrm_runner.run('netsh advfirewall firewall add rule name="Noop in" dir=in action=allow protocol=TCP localport=8082')
+              winrm_runner.run('netsh advfirewall firewall add rule name="Goss out" dir=out action=allow protocol=TCP localport=8080')
+              winrm_runner.run('netsh advfirewall firewall add rule name="Idempotent out" dir=out action=allow protocol=TCP localport=8081')
+              winrm_runner.run('netsh advfirewall firewall add rule name="Noop out" dir=out action=allow protocol=TCP localport=8082')
+              logger.info('CemAcpt') { 'Setting up NSSM and starting Goss services...' }
+              # Download NSSM into cem_acpt directory
+              # NSSM is a tool that allows us to create services on windows without having to create a Windows service project.
+              # NSSM works with almost any executable. In our case, it will work with goss.exe
+              winrm_runner.run("Invoke-WebRequest -URI http://nssm.cc/ci/nssm-2.24-101-g897c7ad.zip -OutFile 'C:\\cem_acpt\\nssm-2.24.zip'")
+              # Extract NSSM into cem_acpt directory
+              winrm_runner.run("Expand-Archive -Path C:\\cem_acpt\\nssm-2.24.zip -DestinationPath C:\\cem_acpt")
+              winrm_runner.run("Rename-Item -Path C:\\cem_acpt\\nssm-2.24-101-g897c7ad -NewName nssm-2.24")
+              # Install NSSM Goss server and start it
+              winrm_runner.run('C:\\cem_acpt\\nssm-2.24\\win64\\nssm.exe install goss-server C:\\goss.exe')
+              winrm_runner.run('C:\\cem_acpt\\nssm-2.24\\win64\\nssm.exe set goss-server AppStdout C:\\cem_acpt\\goss-server.log')
+              winrm_runner.run('C:\\cem_acpt\\nssm-2.24\\win64\\nssm.exe set goss-server AppStderr C:\\cem_acpt\\goss-server-stderr.log')
+              winrm_runner.run('C:\\cem_acpt\\nssm-2.24\\win64\\nssm.exe set goss-server AppParameters "--use-alpha=1 -g C:\\cem_acpt\\goss.yaml serve -f json --endpoint /acpt --cache 10m"')
+              # There is a slight issue with starting through nssm, if the process took a bit too long, it will send an error but the process will still be running.
+              # winrm_runner.run(shell, 'C:\\cem_acpt\\nssm-2.24\\win64\\nssm.exe start goss-server')
+              winrm_runner.run('$GossServer= Get-Service "goss-server"')
+              winrm_runner.run('$GossServer.Start()')
+              winrm_runner.run('$WaitForGossServer = New-TimeSpan -Seconds 5')
+              winrm_runner.run('$GossServer.WaitForStatus([System.ServiceProcess.ServiceControllerStatus]::Running, $WaitForGossServer)')
+              # Install NSSM Idempotent server and start it
+              winrm_runner.run('C:\\cem_acpt\\nssm-2.24\\win64\\nssm.exe install idempotent-server C:\\goss.exe')
+              winrm_runner.run('C:\\cem_acpt\\nssm-2.24\\win64\\nssm.exe set idempotent-server AppStdout C:\\cem_acpt\\idempotent-server.log')
+              winrm_runner.run('C:\\cem_acpt\\nssm-2.24\\win64\\nssm.exe set idempotent-server AppStderr C:\\cem_acpt\\idempotent-server-stderr.log')
+              winrm_runner.run('C:\\cem_acpt\\nssm-2.24\\win64\\nssm.exe set idempotent-server AppParameters "--use-alpha=1 -g C:\\cem_acpt\\puppet_idempotent.yaml serve -f json -l :8081 --endpoint /idempotent --cache 10m"')
+              # winrm_runner.run(shell, 'C:\\cem_acpt\\nssm-2.24\\win64\\nssm.exe start idempotent-server')
+              winrm_runner.run('$IdmServer= Get-Service "idempotent-server"')
+              winrm_runner.run('$IdmServer.Start()')
+              winrm_runner.run('$WaitForIdmServer = New-TimeSpan -Seconds 5')
+              winrm_runner.run('$IdmServer.WaitForStatus([System.ServiceProcess.ServiceControllerStatus]::Running, $WaitForIdmServer)')
+              # Install NSSM Noop server and start it
+              winrm_runner.run('C:\\cem_acpt\\nssm-2.24\\win64\\nssm.exe install noop-server C:\\goss.exe')
+              winrm_runner.run('C:\\cem_acpt\\nssm-2.24\\win64\\nssm.exe set noop-server AppStdout C:\\cem_acpt\\noop-server.log')
+              winrm_runner.run('C:\\cem_acpt\\nssm-2.24\\win64\\nssm.exe set noop-server AppStderr C:\\cem_acpt\\noop-server-stderr.log')
+              winrm_runner.run('C:\\cem_acpt\\nssm-2.24\\win64\\nssm.exe set noop-server AppParameters "--use-alpha=1 -g C:\\cem_acpt\\puppet_noop.yaml serve -f json -l :8082 --endpoint /noop --cache 10m"')
+              # winrm_runner.run(shell, 'C:\\cem_acpt\\nssm-2.24\\win64\\nssm.exe start noop-server')
+              winrm_runner.run('$NoopServer= Get-Service "noop-server"')
+              winrm_runner.run('$NoopServer.Start()')
+              winrm_runner.run('$WaitForNoopServer = New-TimeSpan -Seconds 5')
+              winrm_runner.run('$NoopServer.WaitForStatus([System.ServiceProcess.ServiceControllerStatus]::Running, $WaitForNoopServer)')
+              # Run puppet apply
+              logger.info('CemAcpt') { 'Running puppet apply...' }
+              winrm_runner.run("Start-Process -FilePath 'C:\\Program Files\\Puppet Labs\\Puppet\\bin\\puppet.bat' -ArgumentList 'apply --verbose C:\\cem_acpt\\manifest.pp' -Wait -NoNewWindow -PassThru")
+              logger.info('CemAcpt') { 'Puppet apply finished...' }
+            end
+          end
+        end
+
+        def run
+          run_winrm
+        end
+      end
+    end
+  end
+end

data/lib/cem_acpt/utils.rb

@@ -3,8 +3,48 @@
 require_relative 'utils/puppet'
 require_relative 'utils/ssh'
 require_relative 'utils/terminal'
+require_relative 'logging'
 
 module CemAcpt
   # Utility methods and modules for CemAcpt.
-  module Utils; end
+  module Utils
+    class << self
+      include CemAcpt::Logging
+
+      def package_win_module(module_dir)
+        # Path to the package file
+        package_file = File.join(module_dir, 'puppetlabs-cem_windows.tar.gz')
+
+        # Remove the old package file if it exists
+        FileUtils.rm_f(package_file)
+        `cd #{module_dir} && touch puppetlabs-cem_windows.tar.gz && tar -czf puppetlabs-cem_windows.tar.gz --exclude=puppetlabs-cem_windows.tar.gz *`
+        logger.info('CemAcpt') { "Windows module packaged at #{package_file}" }
+        return package_file
+      end
+
+      def reset_password_readiness_polling(instance_name)
+        result = %x(echo Y | gcloud compute reset-windows-password #{instance_name} --zone=us-west1-b)
+        while result.empty?
+          logger.info('CemAcpt') { "Waiting for instance #{instance_name} to be ready for password reset..." }
+          sleep 10
+          result = %x(echo Y | gcloud compute reset-windows-password #{instance_name} --zone=us-west1-b)
+        end
+        return result
+      end
+
+      def get_windows_login_info(instance_name, hash_of_instance)
+        password_and_username = {}
+        password_and_username[instance_name] = {}
+        info = reset_password_readiness_polling(instance_name).split(/\r?\n/)[1..2]
+        info.each do |line|
+          key_val = line.split(' ')
+          password_and_username[instance_name][key_val[0].strip.delete(':')] = key_val[1].strip
+        end
+
+        password_and_username[instance_name]['ip'] = hash_of_instance['ip']
+        password_and_username[instance_name]['test_name'] = hash_of_instance['test_name']
+        password_and_username
+      end
+    end
+  end
 end

data/lib/cem_acpt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CemAcpt
-  VERSION = '0.7.2'
+  VERSION = '0.8.0'
 end