ruby-pwsh 0.7.2 → 0.10.0

data/lib/puppet/provider/dsc_base_provider/invoke_dsc_resource_functions.ps1

@@ -51,8 +51,10 @@ Function ConvertTo-CanonicalResult {
               $Value = 'Present'
           }
           else {
-              if ($Value -is [string] -or $value -is [string[]]) {
-                  $Value = $Value
+              if ([string]::IsNullOrEmpty($value)) {
+                  # While PowerShell can happily treat empty strings as valid for returning
+                  # an undefined enum, Puppet expects undefined values to be nil.
+                  $Value = $null
               }
 
               if ($Value.Count -eq 1 -and $Property.Definition -match '\\[\\]') {
@@ -113,7 +115,7 @@ Function ConvertTo-CanonicalResult {
       }
 
       if ($Property.Definition -match 'InstanceArray') {
-          if ($Value.Count -lt 2) { $Value = @($Value) }
+          If ($Value.GetType().Name -notmatch '\[\]') { $Value = @($Value) }
       }
 
       $ResultObject.$PropertyName = $Value

data/lib/puppet/provider/dsc_base_provider/invoke_dsc_resource_postscript.ps1

@@ -3,6 +3,12 @@ Try {
 } catch {
   $Response.errormessage   = $_.Exception.Message
   return ($Response | ConvertTo-Json -Compress)
+} Finally {
+  If (![string]::IsNullOrEmpty($UnmungedPSModulePath)) {
+    # Reset the PSModulePath
+    [System.Environment]::SetEnvironmentVariable('PSModulePath', $UnmungedPSModulePath, [System.EnvironmentVariableTarget]::Machine)
+    $env:PSModulePath = [System.Environment]::GetEnvironmentVariable('PSModulePath', 'machine')
+  }
 }
 
 # keep the switch for when Test passes back changed properties

data/lib/pwsh.rb

@@ -136,14 +136,14 @@ module Pwsh
       stdin, @stdout, @stderr, @ps_process = Open3.popen3("#{native_cmd} #{ps_args.join(' ')}")
       stdin.close
 
-      # Puppet.debug "#{Time.now} #{cmd} is running as pid: #{@ps_process[:pid]}"
+      # TODO: Log a debug for "#{Time.now} #{cmd} is running as pid: #{@ps_process[:pid]}"
 
       # Wait up to 180 seconds in 0.2 second intervals to be able to open the pipe.
       # If the pipe_timeout is ever specified as less than the sleep interval it will
       # never try to connect to a pipe and error out as if a timeout occurred.
       sleep_interval = 0.2
       (pipe_timeout / sleep_interval).to_int.times do
-        begin
+        begin # rubocop:disable Style/RedundantBegin
           @pipe = if Pwsh::Util.on_windows?
                     # Pipe is opened in binary mode and must always <- always what??
                     File.open(pipe_path, 'r+b')
@@ -157,7 +157,7 @@ module Pwsh
       end
       if @pipe.nil?
         # Tear down and kill the process if unable to connect to the pipe; failure to do so
-        # results in zombie processes being left after the puppet run. We discovered that
+        # results in zombie processes being left after a caller run. We discovered that
         # closing @ps_process via .kill instead of using this method actually kills the
         # watcher and leaves an orphaned process behind. Failing to close stdout and stderr
         # also leaves clutter behind, so explicitly close those too.
@@ -166,7 +166,8 @@ module Pwsh
         Process.kill('KILL', @ps_process[:pid]) if @ps_process.alive?
         raise "Failure waiting for PowerShell process #{@ps_process[:pid]} to start pipe server"
       end
-      # Puppet.debug "#{Time.now} PowerShell initialization complete for pid: #{@ps_process[:pid]}"
+
+      # TODO: Log a debug for "#{Time.now} PowerShell initialization complete for pid: #{@ps_process[:pid]}"
 
       at_exit { exit }
     end
@@ -211,42 +212,13 @@ module Pwsh
       out
     end
 
-    # TODO: Is this needed in the code manager? When brought into the module, should this be
-    #       added as helper code leveraging this gem?
-    # Executes PowerShell code using the settings from a populated Puppet Exec Resource Type
-    # def execute_resource(powershell_code, working_dir, timeout_ms, environment)
-    #   working_dir = resource[:cwd]
-    #   if (!working_dir.nil?)
-    #     fail "Working directory '#{working_dir}' does not exist" unless File.directory?(working_dir)
-    #   end
-    #   timeout_ms = resource[:timeout].nil? ? nil : resource[:timeout] * 1000
-    #   environment_variables = resource[:environment].nil? ? [] : resource[:environment]
-
-    #   result = execute(powershell_code, timeout_ms, working_dir, environment_variables)
-
-    #   stdout     = result[:stdout]
-    #   native_out = result[:native_out]
-    #   stderr     = result[:stderr]
-    #   exit_code  = result[:exit_code]
-
-    #   # unless stderr.nil?
-    #   #   stderr.each { |e| Puppet.debug "STDERR: #{e.chop}" unless e.empty? }
-    #   # end
-
-    #   # Puppet.debug "STDERR: #{result[:errormessage]}" unless result[:errormessage].nil?
-
-    #   output = Puppet::Util::Execution::ProcessOutput.new(stdout.to_s + native_out.to_s, exit_code)
-
-    #   return output, output
-    # end
-
     # Tear down the instance of the manager, shutting down the pipe and process.
     #
     # @return nil
     def exit
       @usable = false
 
-      # Puppet.debug "Pwsh exiting..."
+      # TODO: Log a debug for "Pwsh exiting..."
 
       # Ask PowerShell pipe server to shutdown if its still running
       # rather than expecting the pipe.close to terminate it
@@ -313,27 +285,26 @@ module Pwsh
             env_name = Regexp.last_match(1)
             value    = Regexp.last_match(2)
             if environment.include?(env_name) || environment.include?(env_name.to_sym)
-              # Puppet.warning("Overriding environment setting '#{env_name}' with '#{value}'")
+              # TODO: log a warning for "Overriding environment setting '#{env_name}' with '#{value}'"
             end
             environment[env_name] = value
           else # rubocop:disable Style/EmptyElse
-            # TODO: Implement logging
-            # Puppet.warning("Cannot understand environment setting #{setting.inspect}")
+            # TODO: log a warning for "Cannot understand environment setting #{setting.inspect}"
           end
         end
       end
       # Convert the Ruby Hashtable into PowerShell syntax
-      exec_environment_variables = '@{'
+      additional_environment_variables = '@{'
       unless environment.empty?
         environment.each do |name, value|
           # PowerShell escapes single quotes inside a single quoted string by just adding
           # another single quote i.e. a value of foo'bar turns into 'foo''bar' when single quoted.
           ps_name  = name.gsub('\'', '\'\'')
           ps_value = value.gsub('\'', '\'\'')
-          exec_environment_variables += " '#{ps_name}' = '#{ps_value}';"
+          additional_environment_variables += " '#{ps_name}' = '#{ps_value}';"
         end
       end
-      exec_environment_variables += '}'
+      additional_environment_variables += '}'
 
       # PS Side expects Invoke-PowerShellUserCode is always the return value here
       # TODO: Refactor to use <<~ as soon as we can :sob:
@@ -344,7 +315,7 @@ $params = @{
 '@
   TimeoutMilliseconds      = #{timeout_ms}
   WorkingDirectory         = "#{working_dir}"
-  ExecEnvironmentVariables = #{exec_environment_variables}
+  AdditionalEnvironmentVariables = #{additional_environment_variables}
 }
 
 Invoke-PowerShellUserCode @params
@@ -391,12 +362,15 @@ Invoke-PowerShellUserCode @params
 
       # If we're on Windows, try the default installation locations as a last resort.
       # https://docs.microsoft.com/en-us/powershell/scripting/install/installing-powershell-core-on-windows?view=powershell-6#msi
+      # https://docs.microsoft.com/en-us/powershell/scripting/install/installing-powershell-core-on-windows?view=powershell-7.1
       if Pwsh::Util.on_windows?
-        # TODO: What about PS 7? or 8?
+        # TODO: What about PS 8?
         # TODO: Need to check on French/Turkish windows if ENV['PROGRAMFILES'] parses UTF8 names correctly
         # TODO: Need to ensure ENV['PROGRAMFILES'] is case insensitive, i.e. ENV['PROGRAMFiles'] should also resolve on Windows
         search_paths += ";#{ENV['PROGRAMFILES']}\\PowerShell\\6" \
-                        ";#{ENV['PROGRAMFILES(X86)']}\\PowerShell\\6"
+                        ";#{ENV['PROGRAMFILES(X86)']}\\PowerShell\\6" \
+                        ";#{ENV['PROGRAMFILES']}\\PowerShell\\7" \
+                        ";#{ENV['PROGRAMFILES(X86)']}\\PowerShell\\7"
       end
       raise 'No paths discovered to search for Powershell!' if search_paths.split(File::PATH_SEPARATOR).empty?
 
@@ -543,7 +517,7 @@ Invoke-PowerShellUserCode @params
     def read_from_pipe(pipe, timeout = 0.1, &_block)
       if self.class.readable?(pipe, timeout)
         l = pipe.readpartial(4096)
-        # Puppet.debug "#{Time.now} PIPE> #{l}"
+        # TODO: Log a debug for "#{Time.now} PIPE> #{l}"
         # Since readpartial may return a nil at EOF, skip returning that value
         yield l unless l.nil?
       end
@@ -601,7 +575,7 @@ Invoke-PowerShellUserCode @params
         buffer
       end
 
-      # Puppet.debug "Waited #{Time.now - start_time} total seconds."
+      # TODO: Log a debug for "Waited #{Time.now - start_time} total seconds."
 
       # Block until sysread has completed or errors
       begin

data/lib/pwsh/version.rb

@@ -2,5 +2,5 @@
 
 module Pwsh
   # The version of the ruby-pwsh gem
-  VERSION = '0.7.2'
+  VERSION = '0.10.0'
 end

data/lib/templates/RubyPwsh.cs

@@ -0,0 +1,302 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Globalization;
+using System.IO;
+using System.Management.Automation;
+using System.Management.Automation.Host;
+using System.Security;
+using System.Text;
+using System.Threading;
+
+namespace RubyPwsh
+{
+  public class RubyPwshPSHostRawUserInterface : PSHostRawUserInterface
+  {
+    public RubyPwshPSHostRawUserInterface()
+    {
+      buffersize      = new Size(120, 120);
+      backgroundcolor = ConsoleColor.Black;
+      foregroundcolor = ConsoleColor.White;
+      cursorposition  = new Coordinates(0, 0);
+      cursorsize      = 1;
+    }
+
+    private ConsoleColor backgroundcolor;
+    public override ConsoleColor BackgroundColor
+    {
+      get { return backgroundcolor; }
+      set { backgroundcolor = value; }
+    }
+
+    private Size buffersize;
+    public override Size BufferSize
+    {
+      get { return buffersize; }
+      set { buffersize = value; }
+    }
+
+    private Coordinates cursorposition;
+    public override Coordinates CursorPosition
+    {
+      get { return cursorposition; }
+      set { cursorposition = value; }
+    }
+
+    private int cursorsize;
+    public override int CursorSize
+    {
+      get { return cursorsize; }
+      set { cursorsize = value; }
+    }
+
+    private ConsoleColor foregroundcolor;
+    public override ConsoleColor ForegroundColor
+    {
+      get { return foregroundcolor; }
+      set { foregroundcolor = value; }
+    }
+
+    private Coordinates windowposition;
+    public override Coordinates WindowPosition
+    {
+      get { return windowposition; }
+      set { windowposition = value; }
+    }
+
+    private Size windowsize;
+    public override Size WindowSize
+    {
+      get { return windowsize; }
+      set { windowsize = value; }
+    }
+
+    private string windowtitle;
+    public override string WindowTitle
+    {
+      get { return windowtitle; }
+      set { windowtitle = value; }
+    }
+
+    public override bool KeyAvailable
+    {
+        get { return false; }
+    }
+
+    public override Size MaxPhysicalWindowSize
+    {
+        get { return new Size(165, 66); }
+    }
+
+    public override Size MaxWindowSize
+    {
+        get { return new Size(165, 66); }
+    }
+
+    public override void FlushInputBuffer()
+    {
+      throw new NotImplementedException();
+    }
+
+    public override BufferCell[,] GetBufferContents(Rectangle rectangle)
+    {
+      throw new NotImplementedException();
+    }
+
+    public override KeyInfo ReadKey(ReadKeyOptions options)
+    {
+      throw new NotImplementedException();
+    }
+
+    public override void ScrollBufferContents(Rectangle source, Coordinates destination, Rectangle clip, BufferCell fill)
+    {
+      throw new NotImplementedException();
+    }
+
+    public override void SetBufferContents(Rectangle rectangle, BufferCell fill)
+    {
+      throw new NotImplementedException();
+    }
+
+    public override void SetBufferContents(Coordinates origin, BufferCell[,] contents)
+    {
+      throw new NotImplementedException();
+    }
+  }
+
+  public class RubyPwshPSHostUserInterface : PSHostUserInterface
+  {
+    private RubyPwshPSHostRawUserInterface _rawui;
+    private StringBuilder _sb;
+    private StringWriter _errWriter;
+    private StringWriter _outWriter;
+
+    public RubyPwshPSHostUserInterface()
+    {
+      _sb = new StringBuilder();
+      _errWriter = new StringWriter(new StringBuilder());
+      // NOTE: StringWriter / StringBuilder are not technically thread-safe
+      // but PowerShell Write-XXX cmdlets and System.Console.Out.WriteXXX
+      // should not be executed concurrently within PowerShell, so should be safe
+      _outWriter = new StringWriter(_sb);
+    }
+
+    public override PSHostRawUserInterface RawUI
+    {
+      get
+      {
+        if ( _rawui == null){
+          _rawui = new RubyPwshPSHostRawUserInterface();
+        }
+        return _rawui;
+      }
+    }
+
+    public void ResetConsoleStreams()
+    {
+      System.Console.SetError(_errWriter);
+      System.Console.SetOut(_outWriter);
+    }
+
+    public override void Write(ConsoleColor foregroundColor, ConsoleColor backgroundColor, string value)
+    {
+      _sb.Append(value);
+    }
+
+    public override void Write(string value)
+    {
+      _sb.Append(value);
+    }
+
+    public override void WriteDebugLine(string message)
+    {
+      _sb.AppendLine("DEBUG: " + message);
+    }
+
+    public override void WriteErrorLine(string value)
+    {
+      _sb.AppendLine(value);
+    }
+
+    public override void WriteLine(string value)
+    {
+      _sb.AppendLine(value);
+    }
+
+    public override void WriteVerboseLine(string message)
+    {
+      _sb.AppendLine("VERBOSE: " + message);
+    }
+
+    public override void WriteWarningLine(string message)
+    {
+      _sb.AppendLine("WARNING: " + message);
+    }
+
+    public override void WriteProgress(long sourceId, ProgressRecord record)
+    {
+    }
+
+    public string Output
+    {
+      get
+      {
+        _outWriter.Flush();
+        string text = _outWriter.GetStringBuilder().ToString();
+        _outWriter.GetStringBuilder().Length = 0; // Only .NET 4+ has .Clear()
+        return text;
+      }
+    }
+
+    public string StdErr
+    {
+      get
+      {
+        _errWriter.Flush();
+        string text = _errWriter.GetStringBuilder().ToString();
+        _errWriter.GetStringBuilder().Length = 0; // Only .NET 4+ has .Clear()
+        return text;
+      }
+    }
+
+    public override Dictionary<string, PSObject> Prompt(string caption, string message, Collection<FieldDescription> descriptions)
+    {
+      throw new NotImplementedException();
+    }
+
+    public override int PromptForChoice(string caption, string message, Collection<ChoiceDescription> choices, int defaultChoice)
+    {
+      throw new NotImplementedException();
+    }
+
+    public override PSCredential PromptForCredential(string caption, string message, string userName, string targetName)
+    {
+      throw new NotImplementedException();
+    }
+
+    public override PSCredential PromptForCredential(string caption, string message, string userName, string targetName, PSCredentialTypes allowedCredentialTypes, PSCredentialUIOptions options)
+    {
+      throw new NotImplementedException();
+    }
+
+    public override string ReadLine()
+    {
+      throw new NotImplementedException();
+    }
+
+    public override SecureString ReadLineAsSecureString()
+    {
+      throw new NotImplementedException();
+    }
+  }
+
+  public class RubyPwshPSHost : PSHost
+  {
+    private Guid _hostId = Guid.NewGuid();
+    private bool shouldExit;
+    private int exitCode;
+
+    private readonly RubyPwshPSHostUserInterface _ui = new RubyPwshPSHostUserInterface();
+
+    public RubyPwshPSHost () {}
+
+    public bool ShouldExit { get { return this.shouldExit; } }
+    public int ExitCode { get { return this.exitCode; } }
+    public void ResetExitStatus()
+    {
+      this.exitCode = 0;
+      this.shouldExit = false;
+    }
+    public void ResetConsoleStreams()
+    {
+      _ui.ResetConsoleStreams();
+    }
+
+    public override Guid InstanceId { get { return _hostId; } }
+    public override string Name { get { return "RubyPwshPSHost"; } }
+    public override Version Version { get { return new Version(1, 1); } }
+    public override PSHostUserInterface UI
+    {
+      get { return _ui; }
+    }
+    public override CultureInfo CurrentCulture
+    {
+        get { return Thread.CurrentThread.CurrentCulture; }
+    }
+    public override CultureInfo CurrentUICulture
+    {
+        get { return Thread.CurrentThread.CurrentUICulture; }
+    }
+
+    public override void EnterNestedPrompt() { throw new NotImplementedException(); }
+    public override void ExitNestedPrompt() { throw new NotImplementedException(); }
+    public override void NotifyBeginApplication() { return; }
+    public override void NotifyEndApplication() { return; }
+
+    public override void SetShouldExit(int exitCode)
+    {
+      this.shouldExit = true;
+      this.exitCode = exitCode;
+    }
+  }
+}