right_link 5.9.0

data/lib/chef/windows/powershell_host.rb

@@ -0,0 +1,285 @@
+#
+# Copyright (c) 2010-2011 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module RightScale
+
+  # This class is responsible for managing a Powershell process instance
+  # It allows running Powershell scripts in the associated instance and will
+  # log the script output.
+  class PowershellHost
+    # Start the Powershell process synchronously
+    # Set the instance variable :active to true once Powershell was
+    # successfully started
+    #
+    # === Parameters
+    # options[:node]:: Chef @node object
+    # options[:provider_name]:: Associated Chef powershell provider name
+    def initialize(options = {})
+      Log.debug(format_log_message("Initializing"))
+      @node             = options[:node]
+      @provider_name    = options[:provider_name]
+      @pipe_name        = "#{@provider_name}_#{Time.now.strftime("%Y-%m-%d-%H%M%S")}"
+
+      @response_mutex = Mutex.new
+      @response_event = ConditionVariable.new
+
+      Log.debug(format_log_message("Starting pipe server"))
+      @pipe_server = RightScale::Windows::PowershellPipeServer.new(:pipe_name => @pipe_name) do |kind, payload|
+        case kind
+          when :is_ready then
+            query
+          when :respond then
+            respond(payload)
+        end
+      end
+
+      unless @pipe_server.start
+        @pipe_server = nil
+        return
+      end
+
+      Log.debug(format_log_message("Starting chef node server"))
+      RightScale::Windows::ChefNodeServer.instance.start(:node => @node)
+
+      Log.debug(format_log_message("Starting host"))
+      start_powershell_process
+
+      Log.debug(format_log_message("Initialized"))
+    end
+
+    def format_log_message(message)
+      "[PowershellHost #{@pipe_name}] - #{message}"
+    end
+
+    # Run Powershell script in associated Powershell process
+    # Log stdout and stderr to Chef logger
+    #
+    # === Argument
+    # script_path(String):: Full path to Powershell script to be run
+    #
+    # === Return
+    # res[exit_code](Number):: The exit code of the script that was run. nil if no exit status was available.
+    #
+    # === Raise
+    # RightScale::Exceptions:ApplicationError:: If Powershell process is not running (i.e. :active is false)
+    def run(script_path)
+      Log.debug(format_log_message("Running #{script_path}"))
+      res = run_command("&\"#{script_path}\"")
+      Log.debug(format_log_message("Finished #{script_path}"))
+      res
+    end
+
+    # Terminate associated Powershell process
+    # :run cannot be called after :terminate
+    # This method is idempotent
+    #
+    # === Return
+    # true:: Always return true
+    def terminate
+      Log.debug(format_log_message("Terminate requested"))
+      res = run_command("break")
+      Log.debug(format_log_message("Terminate signal sent"))
+
+      true
+    end
+
+    protected
+
+    # Is the Powershell process running?
+    #
+    # === Return
+    # true:: If the associated Powershell process is running
+    # false:: Otherwise
+    def active
+      !!@pipe_server
+    end
+
+    # Query whether there is a command to execute
+    # Also signal waiting Chef thread if a command executed
+    #
+    # === Return
+    # true:: If there is a command to execute
+    # false:: Otherwise
+    def query
+      @response_mutex.synchronize do
+        if @sent_command
+          Log.debug(format_log_message("Completed last command"))
+          @sent_command = false
+          @response_event.signal
+        end
+      end
+      return !!@pending_command
+    end
+
+    # Respond to pipe server request
+    # Send pending command
+    #
+    # === Return
+    # res(String):: Command to execute
+    def respond(payload)
+      if @last_command.nil?
+        Log.debug(format_log_message("Processing first command #{@pending_command}"))
+        # this is the first command to be requested, send the command
+        @last_command = @pending_command
+        res = @pending_command
+        @pending_command = ""
+      else
+        # this is the second time around, grab the results of the last command, and send a no-op
+        # the run_loop script will exit if an exception was thrown, and continue if the last
+        # command did not throw
+        @exit_code = payload[RightScale::Windows::PowershellPipeServer::LAST_EXIT_CODE_KEY]
+        @error_msg = payload[RightScale::Windows::PowershellPipeServer::LAST_ERROR_MESSAGE_KEY]
+
+        # setup the exit conditions
+        res = @pending_command
+        @pending_command = nil
+        @sent_command = true
+      end
+
+      Log.debug(format_log_message("Responding with pending command #{res}"))
+      return res
+    end
+
+    # Start the associated powershell process
+    #
+    # === Return
+    # true:: Always return true
+    def start_powershell_process
+      platform = RightScale::Platform
+      shell    = platform.shell
+
+      # Import ChefNodeCmdlet.dll to allow powershell scripts to call get-ChefNode, etc.
+      # Also pass in name of pipe that client needs to connect to
+      lines_before_script = ["import-module #{CHEF_NODE_CMDLET_DLL_PATH}", "$RS_pipeName='#{@pipe_name}'"]
+
+      # enable debug and verbose powershell output if log level allows for it.
+      if Log.debug?
+        lines_before_script << "$VerbosePreference = 'Continue'"
+        lines_before_script << "$DebugPreference = 'Continue'"
+      end
+
+      # specifically disable additional error checking intended for RightScript
+      # and Powershell provider in Chef. doing this to ensure that existing
+      # dynamic provider scripts do not break if they have not cleared their
+      # $Error list before finishing.
+      lines_after_script = []
+
+      command = shell.format_powershell_command4(
+        ::RightScale::Platform::Shell::POWERSHELL_V1x0_EXECUTABLE_PATH,
+        lines_before_script,
+        lines_after_script,
+        RUN_LOOP_SCRIPT_PATH)
+
+      Log.debug(format_log_message("Starting powershell process for host #{command}"))
+
+      ::RightScale::RightPopen.popen3_async(
+        command,
+        :environment    => nil,
+        :target         => self,
+        :stdout_handler => :on_read_output,
+        :stderr_handler => :on_read_output,
+        :exit_handler   => :on_exit)
+
+      return true
+    end
+
+    # executes a powershell command and waits until the command has completed
+    #
+    # === Argument
+    # command(String):: a powershell command
+    #
+    # === Return
+    # res[exit_code](Number):: The exit code of the script that was run. nil if no exit status was available.
+    #
+    # === Raise
+    # RightScale::Exceptions::Application:: If Powershell process is not running (i.e. :active is false)
+    def run_command(command)
+      raise RightScale::Exceptions::Application, "Powershell host not active, cannot run: #{command}" unless active
+      @response_mutex.synchronize do
+        @pending_command = command
+        @last_command = nil
+        Log.debug(format_log_message("Waiting to process #{command}"))
+        @response_event.wait(@response_mutex)
+        Log.debug(format_log_message("Finished processing #{command}"))
+        @pending_command = nil
+        @sent_command = false
+      end
+
+      res = {:exit_code => @exit_code, :error_msg => @error_msg}
+      res
+    end
+
+    TEMP_DIR_NAME = 'powershell_host-82D5D281-5E7C-423A-88C2-69E9B7D3F37E'
+    SOURCE_WINDOWS_PATH = ::File.normalize_path(::File.dirname(__FILE__))
+    LOCAL_WINDOWS_BIN_PATH = RightScale::Platform.filesystem.ensure_local_drive_path(::File.join(SOURCE_WINDOWS_PATH, 'bin'), TEMP_DIR_NAME)
+    LOCAL_WINDOWS_SCRIPTS_PATH = RightScale::Platform.filesystem.ensure_local_drive_path(::File.join(SOURCE_WINDOWS_PATH, 'scripts'), TEMP_DIR_NAME)
+    CHEF_NODE_CMDLET_DLL_PATH = ::File.normalize_path(::File.join(LOCAL_WINDOWS_BIN_PATH, 'ChefNodeCmdlet.dll')).gsub("/", "\\")
+    RUN_LOOP_SCRIPT_PATH = File.normalize_path(File.join(LOCAL_WINDOWS_SCRIPTS_PATH, 'run_loop.ps1')).gsub("/", "\\")
+
+    # Data available in STDOUT pipe event
+    # Audit raw output
+    #
+    # === Parameters
+    # data(String):: STDOUT data
+    #
+    # === Return
+    # true:: Always return true
+    def on_read_output(data)
+      write_output_to_log(data)
+    end
+
+    # Handles a tendency of Windows command line tools to append extraneous
+    # newlines by stripping whitespace before logging. this might accidentally
+    # strip whitespace on a buffer boundary, but the buffer will likely be
+    # read more frequently than it is written to and the after-boundary text
+    # would appear on a new logger line anyway.
+    #
+    # === Parameters
+    # data(String):: data to write
+    def write_output_to_log(data)
+      data = data.strip
+      unless data.empty?
+        ::Chef::Log.info(data)
+      end
+    end
+
+    # Process exited event
+    # Record duration and process exist status and signal Chef thread so it can resume
+    #
+    # === Parameters
+    # status(Process::Status):: Process exit status
+    #
+    # === Return
+    # true:: Always return true
+    def on_exit(status)
+      @exit_status = status
+
+      Log.debug(format_log_message("Stopping host server"))
+      @pipe_server.stop
+      @pipe_server = nil
+
+      # signal response to ensure proper termination
+      Log.debug(format_log_message("Terminated"))
+      @response_event.signal
+    end
+  end
+end

data/lib/chef/windows/powershell_pipe_server.rb

@@ -0,0 +1,136 @@
+#
+# Copyright (c) 2010-2011 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+require 'rubygems'
+require File.normalize_path(File.join(File.dirname(__FILE__), 'pipe_server'))
+require 'json'
+require 'set'
+
+module RightScale
+
+  module Windows
+
+    # Provides a server for a named pipe connection which serves a series of
+    # commands to be executed in the powershell context. The final command is
+    # expected to be an "exit" statement.
+    class PowershellPipeServer
+
+      # Request hash key associated with previous execution exit code
+      LAST_EXIT_CODE_KEY      = "LastExitCode"
+      LAST_ERROR_MESSAGE_KEY  = "LastErrorMessage"
+
+      # Response hash key associated with action to run
+      NEXT_ACTION_KEY = :NextAction
+
+      # Initialize pipe server
+      #
+      # === Parameters
+      # options[:pipe_name](String):: Name of pipe to connect to (required)
+      #
+      # === Block
+      # Given block gets called back for each request
+      # It should take two arguments:
+      #   * First argument is either :is_ready or :respond
+      #     calls with :is_ready should return a boolean value set to true if there is a pending command
+      #     calls with :respond should return the pending command
+      #   * Second argument contains the request data (only set with :respond)
+      def initialize(options = {}, &callback)
+        raise ArgumentError, "Missing required :pipe_name" unless @pipe_name = options[:pipe_name]
+        @callback = callback
+        @pipe_eventable = nil
+      end
+
+      # Starts the pipe server by creating an asynchronous named pipe. Returns
+      # control to the caller after adding the pipe to the event machine.
+      #
+      # === Return
+      # true:: If server was successfully started
+      # false:: Otherwise
+      def start
+        flags = ::Win32::Pipe::ACCESS_DUPLEX | ::Win32::Pipe::OVERLAPPED
+        pipe  = PipeServer.new(@pipe_name, 0, flags)
+        res   = true
+        begin
+          options = {:target => self,
+                     :request_handler => :request_handler,
+                     :request_query => :request_query,
+                     :pipe => pipe}
+          @pipe_eventable = EM.watch(pipe, PipeServerHandler, options)
+          @pipe_eventable.notify_readable = true
+        rescue Exception => e
+          pipe.close rescue nil
+          RightScale::Log.error("Failed to start pipe server", e, :trace)
+          res = false
+        end
+        res
+      end
+
+      # Stops the pipe server by detaching the eventable from the event machine.
+      #
+      # === Return
+      # true:: Always return true
+      def stop
+        @pipe_eventable.force_detach if @pipe_eventable
+        @pipe_eventable = nil
+        true
+      end
+
+      # Ready to respond if the next action queue is empty, otherwise continue
+      # blocking client.
+      #
+      # === Parameters
+      # request_data(String):: request data
+      #
+      # === Returns
+      # result(Boolean):: true if response is ready
+      def request_query(request_data)
+        return @callback.call(:is_ready, nil)
+      end
+
+      # Handler for next action requests. Expects complete requests and
+      # responses to appear serialized as JSON on individual lines (i.e.
+      # delimited by newlines). note that JSON text escapes newline characters
+      # within string values and normally only includes whitespace for human-
+      # readability.
+      #
+      # === Parameters
+      # request_data(String):: Request data
+      #
+      # === Returns
+      # response(String):: Request response
+      def request_handler(request_data)
+        # assume request_data is a single line with a possible newline trailing.
+        request = JSON.load(request_data.chomp)
+        if 2 == request.keys.size && request.has_key?(LAST_EXIT_CODE_KEY) && request.has_key?(LAST_ERROR_MESSAGE_KEY)
+          # pop the next action from the queue.
+          command = @callback.call(:respond, request)
+          return JSON.dump(NEXT_ACTION_KEY => command) + "\n";
+        end
+        raise ArgumentError, "Invalid request"
+      rescue Exception => e
+        return JSON.dump(:Error => "#{e.class}: #{e.message}", :Detail => e.backtrace.join("\n")) + "\n"
+      end
+
+    end
+
+  end
+
+end

data/lib/chef/windows/powershell_provider_base.rb

@@ -0,0 +1,92 @@
+#
+# Copyright (c) 2010-2011 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module RightScale
+
+  # Base class to dynamically generated Powershell Chef providers
+  class PowershellProviderBase < Chef::Provider
+
+    def initialize(new_resource, run_context)
+      super(new_resource, run_context)
+      self.class.init(@run_context.node)
+      # Have to wait until the Chef node server has been initialized before setting the new resource
+      RightScale::Windows::ChefNodeServer.instance.new_resource = @new_resource
+    end
+
+    # Initialize Powershell host, should be called before :run and :terminate
+    #
+    # === Return
+    # true:: If init script must be run
+    # false:: Otherwise
+    def self.init(node)
+      run_init = @ps_instance.nil?
+      @ps_instance = PowershellHost.new(:node => node, :provider_name => self.to_s.gsub("::", "_")) unless @ps_instance
+      run_init
+    end
+
+    # Run powershell script in associated Powershell instance
+    #
+    # === Parameters
+    # script(String):: Fully qualified path to Powershell script
+    #
+    # === Return
+    # true:: Always return true
+    def self.run_script(script)
+      if @ps_instance
+        res = @ps_instance.run(script)
+
+        # the powershell provider script the host runs will return exit code of 100 if the last action threw an exception.
+        if res && res[:exit_code] && res[:exit_code] != 0
+          message = "Unexpected exit code from action. Expected 0 but returned #{res[:exit_code]}.  Script: #{script}\n"
+          message += "#{res[:error_msg]}"
+          raise RightScale::Exceptions::Exec, message
+        end
+      end
+
+      true
+    end
+
+    # Terminate Powershell process if it was started
+    #
+    # === Return
+    # true:: Always return true
+    def self.terminate
+      if @ps_instance
+        begin
+          @ps_instance.terminate
+        ensure
+          @ps_instance = nil
+        end
+      end
+      true
+    end
+
+    # Must override Chef's load_current_resource
+    #
+    # === Return
+    # true:: Always return true
+    def load_current_resource
+      # Dummy
+    end
+  end
+
+end

data/lib/chef/windows/scripts/run_loop.ps1

@@ -0,0 +1,105 @@
+$RS_lastExitCode = 0
+$RS_lastErrorMessage = ""
+$global:RS_lastErrorRecord = $NULL
+while ($TRUE)
+{
+    try
+    {
+        $Error.clear()
+        $LastExitCode = 0
+        $RS_nextAction = $NULL
+        $RS_nextAction = get-NextAction $RS_pipeName $RS_lastExitCode $RS_lastErrorMessage
+        if ($RS_lastErrorMessage -ne "" -or $RS_lastExitCode -ne 0)
+        {
+            exit $RS_lastExitCode
+        }
+        elseif ($Error.Count -eq 0)
+        {
+            # note that $RS_nextAction may be wrapped with additional instructions and so
+            # is too verbose for normal output. the next action usually refers to a locally
+            # cached script whose name but not path is meaningful to the user (with the
+            # exception of a terminating "exit" which doesn't need to be seen here). scripts
+            # should provide sufficient standard output to indicate what activity is
+            # occurring without our having to report which script is running.
+            write-verbose $RS_nextAction
+
+            # invoke next action.
+            invoke-command -scriptblock $RS_nextAction
+            $RS_lastExitCode = $global:LastExitCode
+            if ($NULL -eq $RS_lastExitCode)
+            {
+                $RS_lastExitCode = 0
+            }
+            $RS_lastErrorMessage = ""
+        }
+        else
+        {
+            break
+        }
+    }
+    catch
+    {
+        if ($RS_lastErrorMessage -ne "" -or $RS_lastExitCode -ne 0)
+        {
+            exit $RS_lastExitCode
+        }
+        if ($NULL -eq $global:RS_lastErrorRecord)
+        {
+            $global:RS_lastErrorRecord = $_
+        }
+    }
+
+    if ($NULL -ne $global:RS_lastErrorRecord)
+    {
+        $invocationInfo = $global:RS_lastErrorRecord.invocationInfo
+        write-debug ($invocationInfo | Out-String).TrimEnd()
+        $scriptSnip = ""
+        $scriptPath = $invocationInfo.ScriptName
+        if (($NULL -ne $scriptPath) -and ($scriptPath.Length -gt 0))
+        {
+            $scriptSource = get-content $scriptPath
+            $firstLine    = [system.math]::max($invocationInfo.ScriptLineNumber - 4, 0)
+            $lastLine     = [system.math]::min($invocationInfo.ScriptLineNumber + 4, $scriptSource.length)
+            for ($i = $firstLine; $i -lt $lastLine; ++$i)
+            {
+                $lineNumber = $i + 1
+                if ($lineNumber -eq $invocationInfo.ScriptLineNumber)
+                {
+                    # the reported character offset in the offending line can be past the end for
+                    # some exceptions. an example is missing inputs on a piped command line.
+                    $lineOffset = $invocationInfo.OffsetInLine
+                    $lineLength = $invocationInfo.Line.Length
+                    if ($lineOffset -gt $lineLength)
+                    {
+                        $lineOffset = $lineLength
+                    }
+                    $firstPart   = $invocationInfo.Line.Substring(0, $lineOffset)
+                    $secondPart  = $invocationInfo.Line.Substring($lineOffset, $lineLength - $lineOffset)
+                    $scriptSnip += "`n    + $lineNumber" + ":`t$FirstPart <<<< $SecondPart"
+                }
+                else
+                {
+                    $scriptSnip += "`n    + $LineNumber" + ":`t" + $scriptSource[$i]
+                }
+            }
+        }
+        else
+        {
+            # failure occurred in an internal code fragment which has no meaningful script or line information.
+            # the stringized error record contains sufficient information in this case.
+            $scriptSnip = $NULL
+        }
+        $RS_lastErrorMessage = ($global:RS_lastErrorRecord | Out-String).TrimEnd()
+        if ($NULL -ne $scriptSnip)
+        {
+            $RS_lastErrorMessage += "`n    +`n    + Script error near:" +  $scriptSnip + "`n"
+        }
+        else
+        {
+            $RS_lastErrorMessage += "`n    +`n    + Error occurred in internal code block."
+        }
+        $RS_lastExitCode = 1
+    }
+}
+
+exit $RS_lastExitCode