winrm 2.2.0 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5339846f9181cf6fe697c0d33cd865d1a9a8aecb
-  data.tar.gz: 6780ada80472407f0946199c3162ce5c8fed97df
+  metadata.gz: 5aee7bd9437669d90fa2e9a928624cd459d5c2ba
+  data.tar.gz: f29dc28620dca84b05b1ca1f65ac3bdd1f98a5da
 SHA512:
-  metadata.gz: 44849b77e53db8a83bc9dbcc471fbb3fb2cddc809f32c4a516c8523660eb3609af2fb4b3bd04c6ff169a6ae9732c4d7b9b1afbd98e9fb0dfe7cfcb183604bc67
-  data.tar.gz: 89a535c6b28501f36f337c9b4b03926515117c2e0a0dcd25972a1d197e7a78e1f13f62dfd06212b14489011718386ac8c57dc8b27b0b6c5056b60ed1aef7e678
+  metadata.gz: 5ba7e3c9917afee28df831efa38cd4234de1749ff237292eb13682a806bc71b6e8e83c3ed25c4aa1cd32304ffbc68a60bf4eb59937f67ccf779ee125e6851e56
+  data.tar.gz: 618c9e4000b0d4bb0754991863ce5845e3e9df4ee77cdf1fa58ca6c6b76ee9b4c96e609184a97f837858cbc1ded51f148b219563beb01caadd70c5643bc10d14

data/changelog.md

@@ -1,5 +1,8 @@
 # WinRM Gem Changelog
 
+# 2.2.1
+- Ignore error 2150858843 during shell closing
+
 # 2.2.0
 - Allow run_wql to accept custom namespace
 - Allow enumeration of WQL result sets

data/lib/winrm/shells/base.rb

@@ -1,181 +1,185 @@
-# -*- encoding: utf-8 -*-
-#
-# Copyright 2016 Shawn Neal <sneal@sneal.net>
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require_relative 'retryable'
-require_relative '../http/transport'
-require_relative '../wsmv/cleanup_command'
-require_relative '../wsmv/close_shell'
-require_relative '../wsmv/command'
-require_relative '../wsmv/command_output'
-require_relative '../wsmv/receive_response_reader'
-require_relative '../wsmv/create_shell'
-require_relative '../wsmv/soap'
-
-module WinRM
-  module Shells
-    # Base class for remote shell
-    class Base
-      TOO_MANY_COMMANDS = '2150859174'.freeze
-      ERROR_OPERATION_ABORTED = '995'.freeze
-      SHELL_NOT_FOUND = '2150858843'.freeze
-
-      FAULTS_FOR_RESET = [
-        '2150858843', # Shell has been closed
-        '2147943418', # Error reading registry key
-        TOO_MANY_COMMANDS, # Maximum commands per user exceeded
-      ].freeze
-
-      include Retryable
-
-      # Create a new Cmd shell
-      # @param connection_opts [ConnectionOpts] The WinRM connection options
-      # @param transport [HttpTransport] The WinRM SOAP transport
-      # @param logger [Logger] The logger to log diagnostic messages to
-      # @param shell_opts [Hash] Options targeted for the created shell
-      def initialize(connection_opts, transport, logger, shell_opts = {})
-        @connection_opts = connection_opts
-        @transport = transport
-        @logger = logger
-        @shell_opts = shell_opts
-      end
-
-      # @return [String] shell id of the currently opn shell or nil if shell is closed
-      attr_reader :shell_id
-
-      # @return [String] uri that SOAP calls use to identify shell type
-      attr_reader :shell_uri
-
-      # @return [ConnectionOpts] connection options of the shell
-      attr_reader :connection_opts
-
-      # @return [WinRM::HTTP::HttpTransport] transport used to talk with endpoint
-      attr_reader :transport
-
-      # @return [Logger] logger used for diagnostic messages
-      attr_reader :logger
-
-      # @return [Hash] Options targeted for the created shell
-      attr_reader :shell_opts
-
-      # Runs the specified command with optional arguments
-      # @param command [String] The command or executable to run
-      # @param arguments [Array] The optional command arguments
-      # @param block [&block] The optional callback for any realtime output
-      # @yieldparam [string] standard out response text
-      # @yieldparam [string] standard error response text
-      # @yieldreturn [WinRM::Output] The command output
-      def run(command, arguments = [], &block)
-        with_command_shell(command, arguments) do |shell, cmd|
-          response_reader.read_output(command_output_message(shell, cmd), &block)
-        end
-      end
-
-      # Closes the shell if one is open
-      def close
-        return unless shell_id
-        self.class.close_shell(connection_opts, transport, shell_id)
-        remove_finalizer
-        @shell_id = nil
-      end
-
-      protected
-
-      def send_command(_command, _arguments)
-        raise NotImplementedError
-      end
-
-      def response_reader
-        raise NotImplementedError
-      end
-
-      def open_shell
-        raise NotImplementedError
-      end
-
-      def out_streams
-        raise NotImplementedError
-      end
-
-      def command_output_message(shell_id, command_id)
-        cmd_out_opts = {
-          shell_id: shell_id,
-          command_id: command_id,
-          shell_uri: shell_uri,
-          out_streams: out_streams
-        }
-        WinRM::WSMV::CommandOutput.new(connection_opts, cmd_out_opts)
-      end
-
-      def with_command_shell(command, arguments = [])
-        tries ||= 2
-
-        open unless shell_id
-        command_id = send_command(command, arguments)
-        logger.debug("[WinRM] creating command_id: #{command_id} on shell_id #{shell_id}")
-        yield shell_id, command_id
-      rescue WinRMWSManFault => e
-        raise unless FAULTS_FOR_RESET.include?(e.fault_code) && (tries -= 1) > 0
-        reset_on_error(e)
-        retry
-      ensure
-        cleanup_command(command_id) if command_id
-      end
-
-      private
-
-      def reset_on_error(error)
-        close if error.fault_code == TOO_MANY_COMMANDS
-        logger.debug('[WinRM] opening new shell since the current one was deleted')
-        @shell_id = nil
-      end
-
-      def cleanup_command(command_id)
-        logger.debug("[WinRM] cleaning up command_id: #{command_id} on shell_id #{shell_id}")
-        cleanup_msg = WinRM::WSMV::CleanupCommand.new(
-          connection_opts,
-          shell_uri: shell_uri,
-          shell_id: shell_id,
-          command_id: command_id)
-        transport.send_request(cleanup_msg.build)
-      rescue WinRMWSManFault => e
-        raise unless [ERROR_OPERATION_ABORTED, SHELL_NOT_FOUND].include?(e.fault_code)
-      rescue WinRMHTTPTransportError => t
-        # dont let the cleanup raise so we dont lose any errors from the command
-        logger.info("[WinRM] #{t.status_code} returned in cleanup with error: #{t.message}")
-      end
-
-      def open
-        close
-        retryable(connection_opts[:retry_limit], connection_opts[:retry_delay]) do
-          logger.debug("[WinRM] opening remote shell on #{connection_opts[:endpoint]}")
-          @shell_id = open_shell
-        end
-        logger.debug("[WinRM] remote shell created with shell_id: #{shell_id}")
-        add_finalizer
-      end
-
-      def add_finalizer
-        ObjectSpace.define_finalizer(
-          self,
-          self.class.finalize(connection_opts, transport, shell_id))
-      end
-
-      def remove_finalizer
-        ObjectSpace.undefine_finalizer(self)
-      end
-    end
-  end
-end
+# -*- encoding: utf-8 -*-
+#
+# Copyright 2016 Shawn Neal <sneal@sneal.net>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative 'retryable'
+require_relative '../http/transport'
+require_relative '../wsmv/cleanup_command'
+require_relative '../wsmv/close_shell'
+require_relative '../wsmv/command'
+require_relative '../wsmv/command_output'
+require_relative '../wsmv/receive_response_reader'
+require_relative '../wsmv/create_shell'
+require_relative '../wsmv/soap'
+
+module WinRM
+  module Shells
+    # Base class for remote shell
+    class Base
+      TOO_MANY_COMMANDS = '2150859174'.freeze
+      ERROR_OPERATION_ABORTED = '995'.freeze
+      SHELL_NOT_FOUND = '2150858843'.freeze
+
+      FAULTS_FOR_RESET = [
+        '2150858843', # Shell has been closed
+        '2147943418', # Error reading registry key
+        TOO_MANY_COMMANDS, # Maximum commands per user exceeded
+      ].freeze
+
+      include Retryable
+
+      # Create a new Cmd shell
+      # @param connection_opts [ConnectionOpts] The WinRM connection options
+      # @param transport [HttpTransport] The WinRM SOAP transport
+      # @param logger [Logger] The logger to log diagnostic messages to
+      # @param shell_opts [Hash] Options targeted for the created shell
+      def initialize(connection_opts, transport, logger, shell_opts = {})
+        @connection_opts = connection_opts
+        @transport = transport
+        @logger = logger
+        @shell_opts = shell_opts
+      end
+
+      # @return [String] shell id of the currently opn shell or nil if shell is closed
+      attr_reader :shell_id
+
+      # @return [String] uri that SOAP calls use to identify shell type
+      attr_reader :shell_uri
+
+      # @return [ConnectionOpts] connection options of the shell
+      attr_reader :connection_opts
+
+      # @return [WinRM::HTTP::HttpTransport] transport used to talk with endpoint
+      attr_reader :transport
+
+      # @return [Logger] logger used for diagnostic messages
+      attr_reader :logger
+
+      # @return [Hash] Options targeted for the created shell
+      attr_reader :shell_opts
+
+      # Runs the specified command with optional arguments
+      # @param command [String] The command or executable to run
+      # @param arguments [Array] The optional command arguments
+      # @param block [&block] The optional callback for any realtime output
+      # @yieldparam [string] standard out response text
+      # @yieldparam [string] standard error response text
+      # @yieldreturn [WinRM::Output] The command output
+      def run(command, arguments = [], &block)
+        with_command_shell(command, arguments) do |shell, cmd|
+          response_reader.read_output(command_output_message(shell, cmd), &block)
+        end
+      end
+
+      # Closes the shell if one is open
+      def close
+        return unless shell_id
+        begin
+          self.class.close_shell(connection_opts, transport, shell_id)
+        rescue WinRMWSManFault => e
+          raise unless [ERROR_OPERATION_ABORTED, SHELL_NOT_FOUND].include?(e.fault_code)
+        end
+        remove_finalizer
+        @shell_id = nil
+      end
+
+      protected
+
+      def send_command(_command, _arguments)
+        raise NotImplementedError
+      end
+
+      def response_reader
+        raise NotImplementedError
+      end
+
+      def open_shell
+        raise NotImplementedError
+      end
+
+      def out_streams
+        raise NotImplementedError
+      end
+
+      def command_output_message(shell_id, command_id)
+        cmd_out_opts = {
+          shell_id: shell_id,
+          command_id: command_id,
+          shell_uri: shell_uri,
+          out_streams: out_streams
+        }
+        WinRM::WSMV::CommandOutput.new(connection_opts, cmd_out_opts)
+      end
+
+      def with_command_shell(command, arguments = [])
+        tries ||= 2
+
+        open unless shell_id
+        command_id = send_command(command, arguments)
+        logger.debug("[WinRM] creating command_id: #{command_id} on shell_id #{shell_id}")
+        yield shell_id, command_id
+      rescue WinRMWSManFault => e
+        raise unless FAULTS_FOR_RESET.include?(e.fault_code) && (tries -= 1) > 0
+        reset_on_error(e)
+        retry
+      ensure
+        cleanup_command(command_id) if command_id
+      end
+
+      private
+
+      def reset_on_error(error)
+        close if error.fault_code == TOO_MANY_COMMANDS
+        logger.debug('[WinRM] opening new shell since the current one was deleted')
+        @shell_id = nil
+      end
+
+      def cleanup_command(command_id)
+        logger.debug("[WinRM] cleaning up command_id: #{command_id} on shell_id #{shell_id}")
+        cleanup_msg = WinRM::WSMV::CleanupCommand.new(
+          connection_opts,
+          shell_uri: shell_uri,
+          shell_id: shell_id,
+          command_id: command_id)
+        transport.send_request(cleanup_msg.build)
+      rescue WinRMWSManFault => e
+        raise unless [ERROR_OPERATION_ABORTED, SHELL_NOT_FOUND].include?(e.fault_code)
+      rescue WinRMHTTPTransportError => t
+        # dont let the cleanup raise so we dont lose any errors from the command
+        logger.info("[WinRM] #{t.status_code} returned in cleanup with error: #{t.message}")
+      end
+
+      def open
+        close
+        retryable(connection_opts[:retry_limit], connection_opts[:retry_delay]) do
+          logger.debug("[WinRM] opening remote shell on #{connection_opts[:endpoint]}")
+          @shell_id = open_shell
+        end
+        logger.debug("[WinRM] remote shell created with shell_id: #{shell_id}")
+        add_finalizer
+      end
+
+      def add_finalizer
+        ObjectSpace.define_finalizer(
+          self,
+          self.class.finalize(connection_opts, transport, shell_id))
+      end
+
+      def remove_finalizer
+        ObjectSpace.undefine_finalizer(self)
+      end
+    end
+  end
+end

data/lib/winrm/version.rb

@@ -3,5 +3,5 @@
 # WinRM module
 module WinRM
   # The version of the WinRM library
-  VERSION = '2.2.0'.freeze
+  VERSION = '2.2.1'.freeze
 end

data/tests/spec/shells/base_spec.rb

@@ -1,216 +1,225 @@
-# encoding: UTF-8
-
-require 'winrm/shells/base'
-
-# Dummy shell class
-class DummyShell < WinRM::Shells::Base
-  class << self
-    def finalize(connection_opts, transport, shell_id)
-      proc { DummyShell.close_shell(connection_opts, transport, shell_id) }
-    end
-
-    def close_shell(_connection_opts, _transport, _shell_id)
-      @closed = true
-    end
-
-    def closed?
-      @closed
-    end
-  end
-
-  def open_shell
-    @closed = false
-    'shell_id'
-  end
-
-  def send_command(_command, _arguments)
-    'command_id'
-  end
-
-  def out_streams
-    %w(std)
-  end
-end
-
-describe DummyShell do
-  let(:retry_limit) { 1 }
-  let(:shell_id) { 'shell_id' }
-  let(:output) { 'output' }
-  let(:command_id) { 'command_id' }
-  let(:payload) { 'message_payload' }
-  let(:command) { 'command' }
-  let(:arguments) { ['args'] }
-  let(:output_message) { double('output_message', build: 'output_message') }
-  let(:connection_options) { { max_commands: 100, retry_limit: retry_limit, retry_delay: 0 } }
-  let(:transport) { double('transport') }
-  let(:reader) { double('reader') }
-
-  before do
-    allow(subject).to receive(:response_reader).and_return(reader)
-    allow(subject).to receive(:command_output_message).with(shell_id, command_id)
-      .and_return(output_message)
-    allow(reader).to receive(:read_output).with(output_message).and_return(output)
-    allow(transport).to receive(:send_request)
-  end
-
-  subject { described_class.new(connection_options, transport, Logging.logger['test']) }
-
-  shared_examples 'retry shell command' do
-    it 'only closes the shell if there are too many' do
-      if fault == WinRM::Shells::Base::TOO_MANY_COMMANDS
-        expect(DummyShell).to receive(:close_shell)
-      else
-        expect(DummyShell).not_to receive(:close_shell)
-      end
-
-      subject.run(command, arguments)
-    end
-
-    it 'opens a new shell' do
-      expect(subject).to receive(:open).and_call_original.twice
-
-      subject.run(command, arguments)
-    end
-
-    it 'retries the command once' do
-      expect(subject).to receive(:send_command).twice
-
-      subject.run(command, arguments)
-    end
-  end
-
-  describe '#run' do
-    it 'opens a shell' do
-      subject.run(command, arguments)
-      expect(subject.shell_id).not_to be nil
-    end
-
-    it 'returns output from generated command' do
-      expect(subject.run(command, arguments)).to eq output
-    end
-
-    it 'sends cleanup message through transport' do
-      allow(SecureRandom).to receive(:uuid).and_return('uuid')
-      expect(transport).to receive(:send_request)
-        .with(
-          WinRM::WSMV::CleanupCommand.new(
-            connection_options,
-            shell_uri: nil,
-            shell_id: shell_id,
-            command_id: command_id
-          ).build
-        )
-      subject.run(command, arguments)
-    end
-
-    it 'does not error if cleanup is aborted' do
-      allow(SecureRandom).to receive(:uuid).and_return('uuid')
-      expect(transport).to receive(:send_request)
-        .with(
-          WinRM::WSMV::CleanupCommand.new(
-            connection_options,
-            shell_uri: nil,
-            shell_id: shell_id,
-            command_id: command_id
-          ).build
-        ).and_raise(WinRM::WinRMWSManFault.new('oops', '995'))
-      subject.run(command, arguments)
-    end
-
-    it 'does not error if shell is not present anymore' do
-      allow(SecureRandom).to receive(:uuid).and_return('uuid')
-      expect(transport).to receive(:send_request)
-        .with(
-          WinRM::WSMV::CleanupCommand.new(
-            connection_options,
-            shell_uri: nil,
-            shell_id: shell_id,
-            command_id: command_id
-          ).build
-        ).and_raise(WinRM::WinRMWSManFault.new('oops', '2150858843'))
-      subject.run(command, arguments)
-    end
-
-    it 'opens a shell only once when shell is already open' do
-      expect(subject).to receive(:open_shell).and_call_original.once
-      subject.run(command, arguments)
-      subject.run(command, arguments)
-    end
-
-    describe 'connection resets' do
-      before do
-        @times_called = 0
-
-        allow(subject).to receive(:send_command) do
-          @times_called += 1
-          raise WinRM::WinRMWSManFault.new('oops', fault) if @times_called == 1
-          command_id
-        end
-      end
-
-      context 'when shell is closed on server' do
-        let(:fault) { '2150858843' }
-
-        include_examples 'retry shell command'
-      end
-
-      context 'when shell accesses a deleted registry key' do
-        let(:fault) { '2147943418' }
-
-        include_examples 'retry shell command'
-      end
-
-      context 'when maximum number of concurrent shells is exceeded' do
-        let(:fault) { '2150859174' }
-
-        include_examples 'retry shell command'
-      end
-    end
-
-    context 'open_shell fails' do
-      let(:retry_limit) { 2 }
-      let(:output_message2) { double('message') }
-
-      it 'retries and raises failure if it never succeeds' do
-        expect(subject).to receive(:open_shell)
-          .and_raise(Errno::ECONNREFUSED).exactly(retry_limit).times
-        expect { subject.run(command) }.to raise_error(Errno::ECONNREFUSED)
-      end
-
-      it 'retries and returns shell on success' do
-        @times = 0
-        allow(subject).to receive(:command_output_message).with('shell_id 2', command_id)
-          .and_return(output_message2)
-        allow(reader).to receive(:read_output)
-          .with(output_message2).and_return(output)
-        allow(subject).to receive(:open_shell) do
-          @times += 1
-          raise(Errno::ECONNREFUSED) if @times == 1
-          "shell_id #{@times}"
-        end
-
-        subject.run(command, arguments)
-        expect(subject.shell_id).to eq 'shell_id 2'
-      end
-    end
-  end
-
-  describe '#close' do
-    it 'does not close if not opened' do
-      expect(DummyShell).not_to receive(:close_shell)
-      subject.close
-    end
-
-    it 'close shell if opened' do
-      subject.run(command, arguments)
-      subject.close
-      expect(DummyShell.closed?).to be(true)
-    end
-
-    it 'nils out the shell_id' do
-      subject.run(command, arguments)
-      subject.close
-      expect(subject.shell_id).to be(nil)
-    end
-  end
-end
+# encoding: UTF-8
+
+require 'winrm/shells/base'
+
+# Dummy shell class
+class DummyShell < WinRM::Shells::Base
+  class << self
+    def finalize(connection_opts, transport, shell_id)
+      proc { DummyShell.close_shell(connection_opts, transport, shell_id) }
+    end
+
+    def close_shell(_connection_opts, _transport, _shell_id)
+      @closed = true
+    end
+
+    def closed?
+      @closed
+    end
+  end
+
+  def open_shell
+    @closed = false
+    'shell_id'
+  end
+
+  def send_command(_command, _arguments)
+    'command_id'
+  end
+
+  def out_streams
+    %w(std)
+  end
+end
+
+describe DummyShell do
+  let(:retry_limit) { 1 }
+  let(:shell_id) { 'shell_id' }
+  let(:output) { 'output' }
+  let(:command_id) { 'command_id' }
+  let(:payload) { 'message_payload' }
+  let(:command) { 'command' }
+  let(:arguments) { ['args'] }
+  let(:output_message) { double('output_message', build: 'output_message') }
+  let(:connection_options) { { max_commands: 100, retry_limit: retry_limit, retry_delay: 0 } }
+  let(:transport) { double('transport') }
+  let(:reader) { double('reader') }
+
+  before do
+    allow(subject).to receive(:response_reader).and_return(reader)
+    allow(subject).to receive(:command_output_message).with(shell_id, command_id)
+      .and_return(output_message)
+    allow(reader).to receive(:read_output).with(output_message).and_return(output)
+    allow(transport).to receive(:send_request)
+  end
+
+  subject { described_class.new(connection_options, transport, Logging.logger['test']) }
+
+  shared_examples 'retry shell command' do
+    it 'only closes the shell if there are too many' do
+      if fault == WinRM::Shells::Base::TOO_MANY_COMMANDS
+        expect(DummyShell).to receive(:close_shell)
+      else
+        expect(DummyShell).not_to receive(:close_shell)
+      end
+
+      subject.run(command, arguments)
+    end
+
+    it 'opens a new shell' do
+      expect(subject).to receive(:open).and_call_original.twice
+
+      subject.run(command, arguments)
+    end
+
+    it 'retries the command once' do
+      expect(subject).to receive(:send_command).twice
+
+      subject.run(command, arguments)
+    end
+  end
+
+  describe '#run' do
+    it 'opens a shell' do
+      subject.run(command, arguments)
+      expect(subject.shell_id).not_to be nil
+    end
+
+    it 'returns output from generated command' do
+      expect(subject.run(command, arguments)).to eq output
+    end
+
+    it 'sends cleanup message through transport' do
+      allow(SecureRandom).to receive(:uuid).and_return('uuid')
+      expect(transport).to receive(:send_request)
+        .with(
+          WinRM::WSMV::CleanupCommand.new(
+            connection_options,
+            shell_uri: nil,
+            shell_id: shell_id,
+            command_id: command_id
+          ).build
+        )
+      subject.run(command, arguments)
+    end
+
+    it 'does not error if cleanup is aborted' do
+      allow(SecureRandom).to receive(:uuid).and_return('uuid')
+      expect(transport).to receive(:send_request)
+        .with(
+          WinRM::WSMV::CleanupCommand.new(
+            connection_options,
+            shell_uri: nil,
+            shell_id: shell_id,
+            command_id: command_id
+          ).build
+        ).and_raise(WinRM::WinRMWSManFault.new('oops', '995'))
+      subject.run(command, arguments)
+    end
+
+    it 'does not error if shell is not present anymore' do
+      allow(SecureRandom).to receive(:uuid).and_return('uuid')
+      expect(transport).to receive(:send_request)
+        .with(
+          WinRM::WSMV::CleanupCommand.new(
+            connection_options,
+            shell_uri: nil,
+            shell_id: shell_id,
+            command_id: command_id
+          ).build
+        ).and_raise(WinRM::WinRMWSManFault.new('oops', '2150858843'))
+      subject.run(command, arguments)
+    end
+
+    it 'opens a shell only once when shell is already open' do
+      expect(subject).to receive(:open_shell).and_call_original.once
+      subject.run(command, arguments)
+      subject.run(command, arguments)
+    end
+
+    describe 'connection resets' do
+      before do
+        @times_called = 0
+
+        allow(subject).to receive(:send_command) do
+          @times_called += 1
+          raise WinRM::WinRMWSManFault.new('oops', fault) if @times_called == 1
+          command_id
+        end
+      end
+
+      context 'when shell is closed on server' do
+        let(:fault) { '2150858843' }
+
+        include_examples 'retry shell command'
+      end
+
+      context 'when shell accesses a deleted registry key' do
+        let(:fault) { '2147943418' }
+
+        include_examples 'retry shell command'
+      end
+
+      context 'when maximum number of concurrent shells is exceeded' do
+        let(:fault) { '2150859174' }
+
+        include_examples 'retry shell command'
+      end
+    end
+
+    context 'open_shell fails' do
+      let(:retry_limit) { 2 }
+      let(:output_message2) { double('message') }
+
+      it 'retries and raises failure if it never succeeds' do
+        expect(subject).to receive(:open_shell)
+          .and_raise(Errno::ECONNREFUSED).exactly(retry_limit).times
+        expect { subject.run(command) }.to raise_error(Errno::ECONNREFUSED)
+      end
+
+      it 'retries and returns shell on success' do
+        @times = 0
+        allow(subject).to receive(:command_output_message).with('shell_id 2', command_id)
+          .and_return(output_message2)
+        allow(reader).to receive(:read_output)
+          .with(output_message2).and_return(output)
+        allow(subject).to receive(:open_shell) do
+          @times += 1
+          raise(Errno::ECONNREFUSED) if @times == 1
+          "shell_id #{@times}"
+        end
+
+        subject.run(command, arguments)
+        expect(subject.shell_id).to eq 'shell_id 2'
+      end
+    end
+  end
+
+  describe '#close' do
+    it 'does not close if not opened' do
+      expect(DummyShell).not_to receive(:close_shell)
+      subject.close
+    end
+
+    it 'close shell if opened' do
+      subject.run(command, arguments)
+      subject.close
+      expect(DummyShell.closed?).to be(true)
+    end
+
+    it 'nils out the shell_id' do
+      subject.run(command, arguments)
+      subject.close
+      expect(subject.shell_id).to be(nil)
+    end
+
+    context 'when shell was not found' do
+      it 'does not raise' do
+        subject.run(command, arguments)
+        expect(DummyShell).to receive(:close_shell)
+          .and_raise(WinRM::WinRMWSManFault.new('oops', '2150858843'))
+        expect { subject.close }.not_to raise_error
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: winrm
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.1
 platform: ruby
 authors:
 - Dan Wanek
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-04 00:00:00.000000000 Z
+date: 2017-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gssapi