winrm 1.3.0.dev.1 → 1.3.0.dev.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6e51474e140d25ef1680a4c431b1bcdee6185fd0
-  data.tar.gz: 6c1cb088c144cf90125121f25727f277d0f7a3f2
+  metadata.gz: cd79ebba5bae6d5d3a3149b46ec99c8bef9ddfac
+  data.tar.gz: 080075faa797bbfacd52383b8f5c3847ce1f6ee4
 SHA512:
-  metadata.gz: 7dc6b9dfa831f92c35488bef5cdf25e54e44289b20b1c61fcd7bafffea6cb361f98bb05fa8a7022ba74f9b1c903fa7e0ec95cf54ad053017ea9f80b27824e769
-  data.tar.gz: 00000ad60eaf4ea00f4c55814c74af0270dc80840e7eaf3c2b3e89c9e70005678121895a4274d4acd51552ca4b2fdeeb27b88aa4dc8beee0f9e207b36f463890
+  metadata.gz: 37c993dab7b631fd83e13eb9dffcd0aec1c9769c9ff21af1bbe1ba8e8db88a2e7b94c2174096e591268525f9ff942be8a4dc8b47a57e9f3fb77f47bb4403cd1b
+  data.tar.gz: 68589e411195257d6380409938e5ee311d5001f747d5727f96f95df4c0a044c4d975b4fdfcc4ece08d8e0fd28359b6a01adb0a1efa19aacf5dc7aecefb0fd47d

data/README.md

@@ -72,6 +72,20 @@ iex $cmd
 WinRM::WinRMWebService.new(endpoint, :kerberos, :realm => 'MYREALM.COM')
 ```
 
+### Uploading files
+Files may be copied from the local machine to the winrm endpoint. Individual files or directories may be specified:
+```ruby
+WinRM::FileTransfer.upload(client, 'c:/dev/my_dir', '$env:AppData')
+```
+Or an array of several files and/or directories can be included:
+```ruby
+WinRM::FileTransfer.upload(client, ['c:/dev/file1.txt','c:/dev/dir1'], '$env:AppData')
+```
+**Note**:The winrm protocol poseses some limitations that can adversely affect the performance of large file transfers. By default, the above upload call will display a progress bar to indicate the progress of a file transfer currently underway. This progress bar can be suppressed by setting the `:quiet` option to `true`:
+```ruby
+WinRM::FileTransfer.upload(client, 'c:/dev/my_dir', '$env:AppData', :quiet => true)
+```
+
 ## Troubleshooting
 You may have some errors like ```WinRM::WinRMHTTPTransportError: Bad HTTP response returned from server (401).```.
 You can run the following commands on the server to try to solve the problem:

data/VERSION

@@ -1 +1 @@
-1.3.0.dev.1
+1.3.0.dev.2

data/bin/rwinrm

@@ -22,12 +22,18 @@ require 'winrm'
 
 def parse_options
   options = {}
-  optparse = OptionParser.new do |opts|
-    opts.banner = "Usage: rwinrm endpoint [options]"
+  options[:auth_type] = :plaintext
+  options[:basic_auth_only] = true
+  options[:mode] = :repl
 
-    options[:auth_type] = :plaintext
-    options[:basic_auth_only] = true
-    options[:endpoint] = ARGV[0]
+  optparse = OptionParser.new do |opts|
+    opts.banner = "Usage: rwinrm [command] [local_path] [remote_path] endpoint [options]"
+    opts.separator  ""
+    opts.separator  "Commands"
+    opts.separator  "     repl(default)"
+    opts.separator  "     upload"
+    opts.separator  ""
+    opts.separator  "Options"
 
     opts.on('-u', '--user username', String, 'WinRM user name') do |v|
       options[:user] = v
@@ -38,27 +44,53 @@ def parse_options
     end
 
     opts.on('-h', '--help', 'Display this screen') do
-      puts opts
+      puts optparse
       exit
     end
   end
 
   optparse.parse!
+
+  if ARGV[0] && ARGV[0].downcase !~ /\A#{URI::regexp(['http', 'https'])}\z/
+    options[:mode] = ARGV.shift.downcase.to_sym
+
+    case options[:mode]
+    when :upload
+      options[:local_path] = ARGV.shift
+      options[:remote_path] = ARGV.shift
+
+      raise OptionParser::MissingArgument.new(:local_path) if options[:local_path].nil?
+      raise OptionParser::MissingArgument.new(:remote_path) if options[:remote_path].nil?
+    when :repl
+    else
+      raise OptionParser::InvalidArgument.new(options[:mode])
+    end
+  end
+  options[:endpoint] = ARGV.shift
+
   raise OptionParser::MissingArgument.new(:endpoint) if options[:endpoint].nil?
 
   options
-rescue OptionParser::InvalidOption, OptionParser::MissingArgument
+rescue OptionParser::InvalidOption, OptionParser::MissingArgument, OptionParser::InvalidArgument
   puts $!.message
   puts optparse
   exit 1
 end
 
-def repl(options)
-  client = WinRM::WinRMWebService.new(
-    options[:endpoint],
-    options[:auth_type].to_sym,
-    options)
+def winrm_client(options)
+  WinRM::WinRMWebService.new(
+      options[:endpoint],
+      options[:auth_type].to_sym,
+      options)
+end
 
+def upload(client, options)
+  bytes = WinRM::FileTransfer.upload(client, options[:local_path], options[:remote_path])
+  shell_id = client.open_shell()
+  puts "#{bytes} total bytes transfered"
+end
+
+def repl(client, options)
   shell_id = client.open_shell()
   command_id = client.run_command(shell_id, 'cmd')
 
@@ -79,6 +111,12 @@ def repl(options)
       client.write_stdin(shell_id, command_id, "#{buf}\r\n")
     end
   end
+end
+
+def run(options)
+  client = winrm_client(options)
+  method(options[:mode]).call(client, options)
+  exit 0
 rescue Interrupt
   # ctrl-c
 rescue StandardError => e
@@ -86,4 +124,4 @@ rescue StandardError => e
   exit 1
 end
 
-repl(parse_options())
+run(parse_options())

data/lib/winrm/exceptions/exceptions.rb

@@ -20,6 +20,8 @@ module WinRM
   # Authorization Error
   class WinRMAuthorizationError < WinRMError; end
 
+  class WinRMUploadFailed < WinRMError; end
+
   # A Fault returned in the SOAP response. The XML node is a WSManFault
   class WinRMWSManFault < WinRMError
     attr_reader :fault_code

data/lib/winrm/file_transfer/remote_file.rb

@@ -0,0 +1,184 @@
+require 'io/console'
+require 'json'
+require 'ruby-progressbar'
+
+module WinRM
+  class RemoteFile
+
+    attr_reader :local_path
+    attr_reader :remote_path
+    attr_reader :closed
+    attr_reader :options
+
+    def initialize(service, local_path, remote_path, opts = {})
+      @logger = Logging.logger[self]
+      @options = opts
+      @closed = false
+      @service = service
+      @shell = service.open_shell
+      @local_path = local_path
+      @remote_path = full_remote_path(local_path, remote_path)
+      @logger.debug("Creating RemoteFile of local '#{local_path}' at '#{@remote_path}'")
+    ensure
+      if !shell.nil?
+        ObjectSpace.define_finalizer( self, self.class.close(shell, service) )
+      end
+    end
+
+    def upload
+      raise WinRMUploadFailed.new("This RemoteFile is closed.") if closed
+      raise WinRMUploadFailed.new("Cannot find path: '#{local_path}'") unless File.exist?(local_path)
+
+      @remote_path, should_upload = powershell_batch do | builder |
+        builder << resolve_remote_command
+        builder << is_dirty_command
+      end
+
+      if should_upload
+        size = upload_to_remote
+        powershell_batch {|builder| builder << create_post_upload_command}
+      else
+        size = 0
+        logger.debug("Files are equal. Not copying #{local_path} to #{remote_path}")
+      end
+      size
+    end
+    
+    def close
+      service.close_shell(shell) unless shell.nil? or closed
+      @closed = true
+    end
+
+    protected
+
+    attr_reader :logger
+    attr_reader :service
+    attr_reader :shell
+
+    def self.close(shell_id, service)
+      proc { service.close_shell(shell_id) }
+    end
+
+    def full_remote_path(local_path, remote_path)
+      base_file_name = File.basename(local_path)
+      if File.basename(remote_path) != base_file_name
+        remote_path = File.join(remote_path, base_file_name)
+      end
+      remote_path
+    end
+
+    def resolve_remote_command
+      <<-EOH
+        $dest_file_path = $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath("#{remote_path}")
+
+        if (!(Test-Path $dest_file_path)) {
+          $dest_dir = ([System.IO.Path]::GetDirectoryName($dest_file_path))
+          New-Item -ItemType directory -Force -Path $dest_dir | Out-Null
+        }
+
+        $dest_file_path
+      EOH
+    end
+
+    def is_dirty_command
+      local_md5 = Digest::MD5.file(local_path).hexdigest
+      <<-EOH
+        $dest_file_path = $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath("#{remote_path}")
+
+        if (Test-Path $dest_file_path) {
+          $crypto_prov = new-object -TypeName System.Security.Cryptography.MD5CryptoServiceProvider
+          try {
+            $file = [System.IO.File]::Open($dest_file_path,
+              [System.IO.Filemode]::Open, [System.IO.FileAccess]::Read)
+            $guest_md5 = ([System.BitConverter]::ToString($crypto_prov.ComputeHash($file)))
+            $guest_md5 = $guest_md5.Replace("-","").ToLower()
+          }
+          finally {
+            $file.Dispose()
+          }
+          if ($guest_md5 -eq '#{local_md5}') {
+            return $false
+          }
+        }
+        if(Test-Path $dest_file_path){remove-item $dest_file_path -Force}
+        return $true
+      EOH
+    end
+
+    def upload_to_remote
+      logger.debug("Uploading '#{local_path}' to temp file '#{remote_path}'")
+      base64_host_file = Base64.encode64(IO.binread(local_path)).gsub("\n", "")
+      base64_array = base64_host_file.chars.to_a
+      unless options[:quiet]
+        console_width = IO.console.winsize[1]
+        bar = ProgressBar.create(:title => "Copying #{File.basename(local_path)}...", :total => base64_array.count, :length => console_width-1)
+      end      
+      base64_array.each_slice(8000 - remote_path.size) do |chunk|
+        cmd("echo #{chunk.join} >> \"#{remote_path}\"")
+        bar.progress += chunk.count unless options[:quiet]
+      end
+      base64_array.length
+    end
+
+    def decode_command
+      <<-EOH
+        $base64_string = Get-Content '#{remote_path}'
+        $bytes = [System.Convert]::FromBase64String($base64_string)
+        [System.IO.File]::WriteAllBytes('#{remote_path}', $bytes) | Out-Null
+      EOH
+    end
+
+    def create_post_upload_command
+      [decode_command]
+    end
+
+    def powershell_batch(&block)
+      ps_builder = []
+      yield ps_builder
+
+      commands = [ "$result = @{}" ]
+      idx = 0
+      ps_builder.flatten.each do |cmd_item|
+        commands << <<-EOH
+          $result.ret#{idx} = Invoke-Command { #{cmd_item} }
+        EOH
+        idx += 1
+      end
+      commands << "$(ConvertTo-Json $result)"
+
+      result = []
+      JSON.parse(powershell(commands.join("\n"))).each do |k,v|
+        result << v unless v.nil?
+      end
+      result unless result.empty?
+    end
+
+    def powershell(script)
+      script = "$ProgressPreference='SilentlyContinue';" + script
+      logger.debug("executing powershell script: \n#{script}")
+      script = script.encode('UTF-16LE', 'UTF-8')
+      script = Base64.strict_encode64(script)
+      cmd("powershell", ['-encodedCommand', script])
+    end
+
+    def cmd(command, arguments = [])
+      command_output = nil
+      out_stream = []
+      err_stream = []
+      service.run_command(shell, command, arguments) do |command_id|
+        command_output = service.get_command_output(shell, command_id) do |stdout, stderr|
+          out_stream << stdout if stdout
+          err_stream << stderr if stderr
+        end
+      end
+
+      if !command_output[:exitcode].zero? or !err_stream.empty?
+        raise WinRMUploadFailed,
+          :from => local_path,
+          :to => remote_path,
+          :message => command_output.inspect
+      end
+      out_stream.join.chomp
+    end
+  end
+end

data/lib/winrm/file_transfer/remote_zip_file.rb

@@ -0,0 +1,60 @@
+require 'zip'
+
+module WinRM
+  class RemoteZipFile < RemoteFile
+
+    attr_reader :archive
+
+    def initialize(service, remote_path, opts = {})
+      @logger = Logging.logger[self]
+      @archive = create_archive(remote_path)
+      @unzip_remote_path = remote_path
+      remote_path = "$env:temp/WinRM_file_transfer"
+      super(service, @archive, remote_path, opts)
+    end
+
+    def add_file(path)
+      path = path.gsub("\\","/")
+      logger.debug("adding '#{path}' to zip file")
+      raise WinRMUploadFailed.new("Cannot find path: '#{path}'") unless File.exist?(path)
+      File.directory?(path) ? glob = File.join(path, "**/*") : glob = path
+      logger.debug("iterating files in '#{glob}'")
+      Zip::File.open(archive, 'w') do |zipfile|
+        Dir.glob(glob).each do |file|
+          logger.debug("adding zip entry for '#{file}'")
+          entry = Zip::Entry.new(archive, file.sub(File.dirname(path)+'/',''), nil, nil, nil, nil, nil, nil, ::Zip::DOSTime.new(2000))
+          zipfile.add(entry,file)
+        end
+      end
+    end
+
+    protected
+
+    def create_post_upload_command
+      super << extract_zip_command
+    end
+
+    private
+
+    def create_archive(remote_path)
+      archive_folder = File.join(ENV['TMP'] || ENV['TMPDIR'] || '/tmp', 'WinRM_file_transfer_local')
+      Dir.mkdir(archive_folder) unless File.exist?(archive_folder)
+      archive = File.join(archive_folder,File.basename(remote_path))+'.zip'
+      FileUtils.rm archive, :force=>true
+
+      archive
+    end
+
+    def extract_zip_command
+      <<-EOH
+        $destination = $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath("#{@unzip_remote_path}")
+        $shellApplication = new-object -com shell.application 
+
+        $zipPackage = $shellApplication.NameSpace('#{remote_path}') 
+        mkdir $destination -ErrorAction SilentlyContinue | Out-Null
+        $destinationFolder = $shellApplication.NameSpace($destination) 
+        $destinationFolder.CopyHere($zipPackage.Items(),0x10) | Out-Null
+      EOH
+    end
+  end
+end

data/lib/winrm/file_transfer.rb

@@ -0,0 +1,39 @@
+require 'winrm/file_transfer/remote_file'
+require 'winrm/file_transfer/remote_zip_file'
+
+module WinRM
+  # Perform file transfer operations between a local machine and winrm endpoint
+  class FileTransfer
+    # Upload one or more local files and directories to a remote directory
+    # @example copy a single directory to a winrm endpoint
+    #
+    #   WinRM::FileTransfer.upload(client, 'c:/dev/my_dir', '$env:AppData')
+    #
+    # @example copy several paths to the winrm endpoint
+    #
+    #   WinRM::FileTransfer.upload(client, ['c:/dev/file1.txt','c:/dev/dir1'], '$env:AppData')
+    #
+    # @param [WinRM::WinRMService] a winrm service client connected to the endpoint where the remote path resides
+    # @param [Array<String>] One or more paths that will be copied to the remote path. These can be files or directories to be deeply copied
+    # @param [String] The directory on the remote endpoint to copy the local items to. This path may contain powershell style environment variables
+    # @option opts [String] options to be used for the copy. Currently only :quiet is supported to suppress the progress bar
+    # @return [Fixnum] The total number of bytes copied
+    def self.upload(service, local_path, remote_path, opts = {})
+      file = nil
+      local_path = [local_path] if local_path.is_a? String
+
+      if local_path.count == 1 && !File.directory?(local_path[0])
+        file = RemoteFile.new(service, local_path[0], remote_path, opts)
+      else
+        file = RemoteZipFile.new(service, remote_path, opts)
+        local_path.each do |path|
+          file.add_file(path)
+        end
+      end
+
+      file.upload
+    ensure
+      file.close unless file.nil?
+    end
+  end
+end

data/lib/winrm/winrm_service.rb

@@ -81,7 +81,7 @@ module WinRM
     # @option shell_opts [Hash] :env_vars environment variables to set for the shell. For instance;
     #   :env_vars => {:myvar1 => 'val1', :myvar2 => 'var2'}
     # @return [String] The ShellId from the SOAP response.  This is our open shell instance on the remote machine.
-    def open_shell(shell_opts = {})
+    def open_shell(shell_opts = {}, &block)
       i_stream = shell_opts.has_key?(:i_stream) ? shell_opts[:i_stream] : 'stdin'
       o_stream = shell_opts.has_key?(:o_stream) ? shell_opts[:o_stream] : 'stdout stderr'
       codepage = shell_opts.has_key?(:codepage) ? shell_opts[:codepage] : 437
@@ -113,7 +113,16 @@ module WinRM
 
       resp_doc = send_message(builder.target!)
       shell_id = REXML::XPath.first(resp_doc, "//*[@Name='ShellId']").text
-      shell_id
+
+      if block_given?
+        begin
+          yield shell_id
+        ensure
+          close_shell(shell_id)
+        end
+      else
+        shell_id
+      end
     end
 
     # Run a command on a machine with an open shell
@@ -121,7 +130,7 @@ module WinRM
     # @param [String] command The command to run on the remote machine
     # @param [Array<String>] arguments An array of arguments for this command
     # @return [String] The CommandId from the SOAP response.  This is the ID we need to query in order to get output.
-    def run_command(shell_id, command, arguments = [], cmd_opts = {})
+    def run_command(shell_id, command, arguments = [], cmd_opts = {}, &block)
       consolemode = cmd_opts.has_key?(:console_mode_stdin) ? cmd_opts[:console_mode_stdin] : 'TRUE'
       skipcmd     = cmd_opts.has_key?(:skip_cmd_shell) ? cmd_opts[:skip_cmd_shell] : 'FALSE'
 
@@ -147,7 +156,16 @@ module WinRM
 
       resp_doc = send_message(xml)
       command_id = REXML::XPath.first(resp_doc, "//#{NS_WIN_SHELL}:CommandId").text
-      command_id
+      
+      if block_given?
+        begin
+          yield command_id
+        ensure
+          cleanup_command(shell_id, command_id)
+        end
+      else
+        command_id
+      end
     end
 
     def write_stdin(shell_id, command_id, stdin)
@@ -261,13 +279,15 @@ module WinRM
     # Run a CMD command
     # @param [String] command The command to run on the remote system
     # @param [Array <String>] arguments arguments to the command
+    # @param [String] an existing and open shell id to reuse
     # @return [Hash] :stdout and :stderr
     def run_cmd(command, arguments = [], &block)
-      shell_id = open_shell
-      command_id =  run_command(shell_id, command, arguments)
-      command_output = get_command_output(shell_id, command_id, &block)
-      cleanup_command(shell_id, command_id)
-      close_shell(shell_id)
+      command_output = nil
+      open_shell do |shell_id|
+        run_command(shell_id, command, arguments) do |command_id|
+          command_output = get_command_output(shell_id, command_id, &block)
+        end
+      end
       command_output
     end
     alias :cmd :run_cmd
@@ -275,18 +295,14 @@ module WinRM
 
     # Run a Powershell script that resides on the local box.
     # @param [IO,String] script_file an IO reference for reading the Powershell script or the actual file contents
+    # @param [String] an existing and open shell id to reuse
     # @return [Hash] :stdout and :stderr
     def run_powershell_script(script_file, &block)
       # if an IO object is passed read it..otherwise assume the contents of the file were passed
       script = script_file.kind_of?(IO) ? script_file.read : script_file
       script = script.encode('UTF-16LE', 'UTF-8')
       script = Base64.strict_encode64(script)
-      shell_id = open_shell
-      command_id = run_command(shell_id, "powershell -encodedCommand #{script}")
-      command_output = get_command_output(shell_id, command_id, &block)
-      cleanup_command(shell_id, command_id)
-      close_shell(shell_id)
-      command_output
+      run_cmd("powershell -encodedCommand #{script}", &block)
     end
     alias :powershell :run_powershell_script
 

data/lib/winrm.rb

@@ -35,3 +35,4 @@ end
 
 require 'winrm/helpers/iso8601_duration'
 require 'winrm/soap_provider'
+require 'winrm/file_transfer'

data/spec/file_transfer/remote_file_spec.rb

@@ -0,0 +1,71 @@
+describe WinRM::RemoteFile, :integration => true do
+  
+  let(:this_file) { __FILE__ }
+  let(:service) { winrm_connection }
+  let(:destination) {"#{ENV['temp']}/WinRM_tests"}
+  after {
+    subject.close
+    FileUtils.rm_rf(destination)
+  }
+
+  context 'Upload a new file to directory path' do
+    subject {WinRM::RemoteFile.new(service, this_file, destination, :quiet => true)}
+
+    it 'copies the file inside the directory' do
+      expect(subject.upload).to be > 0
+      expect(File.exist?(File.join(destination, File.basename(this_file)))).to be_truthy
+    end
+    it 'copies the exact file content' do
+      expect(subject.upload).to be > 0
+      expect(File.read(File.join(destination, File.basename(this_file)))).to eq(File.read(this_file))
+    end
+
+  end
+
+  context 'Upload an identical file to directory path' do
+    subject {WinRM::RemoteFile.new(service, this_file, destination, :quiet => true)}
+    let (:next_transfer) {WinRM::RemoteFile.new(service, this_file, destination, :quiet => true)}
+
+    it 'does not copy the file' do
+      expect(subject.upload).to be > 0
+      expect(next_transfer.upload).to be == 0
+    end
+  end
+
+  context 'Upload a file to file path' do
+    subject {WinRM::RemoteFile.new(service, this_file, File.join(destination, File.basename(this_file)), :quiet => true)}
+
+    it 'copies the file to the exact path' do
+      expect(subject.upload).to be > 0
+      expect(File.exist?(File.join(destination, File.basename(this_file)))).to be_truthy
+    end
+  end
+
+  context 'Upload a new file to nested directory' do
+    let (:nested) {File.join(destination, 'nested')}
+    subject {WinRM::RemoteFile.new(service, this_file, nested, :quiet => true)}
+
+    it 'copies the file to the nested path' do
+      expect(subject.upload).to be > 0
+      expect(File.exist?(File.join(nested, File.basename(this_file)))).to be_truthy
+    end
+  end
+
+  context 'Upload a file after RemoteFile is closed' do
+    subject {WinRM::RemoteFile.new(service, this_file, destination, :quiet => true)}
+
+    it 'raises WinRMUploadFailed' do
+      expect(subject.upload).to be > 0
+      subject.close
+      expect{subject.upload}.to raise_error(WinRM::WinRMUploadFailed)
+    end
+  end
+
+  context 'Upload a bad path' do
+    subject {WinRM::RemoteFile.new(service, 'c:/some/bad/path', destination, :quiet => true)}
+
+    it 'raises WinRMUploadFailed' do
+      expect { subject.upload }.to raise_error(WinRM::WinRMUploadFailed)
+    end
+  end
+end

data/spec/file_transfer/remote_zip_file_spec.rb

@@ -0,0 +1,51 @@
+describe WinRM::RemoteZipFile, :integration => true do
+  
+  let(:this_dir) { File.dirname(__FILE__) }
+  let(:service) { winrm_connection }
+  let(:destination) {"#{ENV['temp']}/WinRM_tests"}
+  before { FileUtils.rm_rf(Dir.glob("#{ENV['temp'].gsub("\\","/")}/WinRM_*")) }
+  after { subject.close }
+  subject {WinRM::RemoteZipFile.new(service, destination, :quiet => true)}
+
+  context 'Upload a new directory' do
+    it 'copies the directory' do
+      subject.add_file(this_dir)
+      expect(subject.upload).to be > 0
+      expect(File.read(File.join(destination, "file_transfer", "remote_file_spec.rb"))).to eq(File.read(File.join(this_dir, 'remote_file_spec.rb')))
+      expect(File.read(File.join(destination, "file_transfer", "remote_zip_file_spec.rb"))).to eq(File.read(File.join(this_dir, 'remote_zip_file_spec.rb')))
+      expect(File.exist?(File.join(this_dir, "file_transfer.zip"))).to be_falsey
+      expect(File.exist?(File.join(destination, "file_transfer.zip"))).to be_falsey
+    end
+  end
+
+  context 'Upload an identical directory' do
+    let (:next_transfer) {WinRM::RemoteZipFile.new(service, destination, :quiet => true)}
+
+    it 'does not copy the directory' do
+      subject.add_file(this_dir)
+      expect(subject.upload).to be > 0
+      next_transfer.add_file(this_dir)
+      expect(next_transfer.upload).to be == 0
+    end
+  end
+
+  context 'Upload multiple entries' do
+    it 'copies each entry' do
+      subject.add_file(this_dir)
+      spec_helper = File.join(File.dirname(this_dir), 'spec_helper.rb')
+      subject.add_file(spec_helper)
+      expect(subject.upload).to be > 0
+      expect(File.read(File.join(destination, "file_transfer", "remote_file_spec.rb"))).to eq(File.read(File.join(this_dir, 'remote_file_spec.rb')))
+      expect(File.read(File.join(destination, "file_transfer", "remote_zip_file_spec.rb"))).to eq(File.read(File.join(this_dir, 'remote_zip_file_spec.rb')))
+      expect(File.read(File.join(destination, "spec_helper.rb"))).to eq(File.read(spec_helper))
+    end
+  end
+
+  context 'Upload a bad path' do
+    it 'raises WinRMUploadFailed' do
+      expect {
+        subject.add_file('c:/some/bad/path')
+        }.to raise_error(WinRM::WinRMUploadFailed)
+    end
+  end
+end

data/spec/file_transfer_spec.rb

@@ -0,0 +1,39 @@
+describe WinRM::FileTransfer, :unit => true do
+  
+  let(:this_file) { __FILE__ }
+  let(:remote_file) {double('RemoteFile')}
+  let(:remote_zip_file) {double('RemoteZipFile')}
+  
+  before {
+    allow(WinRM::RemoteFile).to receive(:new).and_return(remote_file)
+    allow(WinRM::RemoteZipFile).to receive(:new).and_return(remote_zip_file)
+  }
+  subject {WinRM::FileTransfer}
+
+  context 'copying a single file' do
+    it 'uploads a remote_file' do
+      expect(remote_file).to receive(:upload)
+      expect(remote_file).to receive(:close)
+      subject.upload("service", this_file, "c:/directory")
+    end
+  end
+
+  context 'copying a single directory' do
+    it 'uploads a remote_zip_file' do
+      expect(remote_zip_file).to receive(:add_file).with(File.dirname(this_file))
+      expect(remote_zip_file).to receive(:upload)
+      expect(remote_zip_file).to receive(:close)
+      subject.upload("service", File.dirname(this_file), "c:/directory")
+    end
+  end
+
+  context 'copying both a file and a directory' do
+    it 'adds both to a remote_zip_file' do
+      expect(remote_zip_file).to receive(:upload)
+      expect(remote_zip_file).to receive(:add_file).with(this_file)
+      expect(remote_zip_file).to receive(:add_file).with(File.dirname(this_file))
+      expect(remote_zip_file).to receive(:close)
+      subject.upload("service", [File.dirname(this_file), this_file], "c:/directory")
+    end
+  end
+end

data/winrm.gemspec

@@ -23,15 +23,19 @@ Gem::Specification.new do |s|
   s.rdoc_options	= %w(-x test/ -x examples/)
   s.extra_rdoc_files = %w(README.md LICENSE)
 
+  s.bindir = "bin"
+  s.executables   = ['rwinrm']
   s.required_ruby_version	= '>= 1.9.0'
   s.add_runtime_dependency  'gssapi', '~> 1.0'
   s.add_runtime_dependency  'httpclient', '~> 2.2', '>= 2.2.0.2'
-  s.add_runtime_dependency  'rubyntlm', '~> 0.1'
+  s.add_runtime_dependency  'rubyntlm', '~> 0.4.0'
   s.add_runtime_dependency  'uuidtools', '~> 2.1.2'
   s.add_runtime_dependency  'logging', '~> 1.6', '>= 1.6.1'
   s.add_runtime_dependency  'nori', '~> 2.0'
   s.add_runtime_dependency  'gyoku', '~> 1.0'
   s.add_runtime_dependency  'builder', '>= 2.1.2'
+  s.add_runtime_dependency  'rubyzip', '~> 1.1'
+  s.add_runtime_dependency  'ruby-progressbar', '~> 1.6'
   s.add_development_dependency 'rspec', '~> 3.0.0'
   s.add_development_dependency 'rake', '~> 10.3.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: winrm
 version: !ruby/object:Gem::Version
-  version: 1.3.0.dev.1
+  version: 1.3.0.dev.2
 platform: ruby
 authors:
 - Dan Wanek
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-14 00:00:00.000000000 Z
+date: 2014-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gssapi
@@ -51,14 +51,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: 0.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: 0.4.0
 - !ruby/object:Gem::Dependency
   name: uuidtools
   requirement: !ruby/object:Gem::Requirement
@@ -135,6 +135,34 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: 2.1.2
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: ruby-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -168,7 +196,8 @@ description: |2
 email:
 - dan.wanek@gmail.com
 - paul@themortonsonline.com
-executables: []
+executables:
+- rwinrm
 extensions: []
 extra_rdoc_files:
 - README.md
@@ -186,6 +215,9 @@ files:
 - changelog.md
 - lib/winrm.rb
 - lib/winrm/exceptions/exceptions.rb
+- lib/winrm/file_transfer.rb
+- lib/winrm/file_transfer/remote_file.rb
+- lib/winrm/file_transfer/remote_zip_file.rb
 - lib/winrm/helpers/iso8601_duration.rb
 - lib/winrm/http/response_handler.rb
 - lib/winrm/http/transport.rb
@@ -196,6 +228,9 @@ files:
 - spec/cmd_spec.rb
 - spec/config-example.yml
 - spec/exception_spec.rb
+- spec/file_transfer/remote_file_spec.rb
+- spec/file_transfer/remote_zip_file_spec.rb
+- spec/file_transfer_spec.rb
 - spec/matchers.rb
 - spec/powershell_spec.rb
 - spec/response_handler_spec.rb