vagrant-winrm 0.0.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: 210c89d4530fcbed54ae1c14abfb7296eac6a39f
-  data.tar.gz: 26bd2ffbf4d1b9aebedd4f3dd5e8c2c14ef6b4ef
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    OTEwOWNjNDY2ZjFjZmMzZGNlOGYwZDI2NjZhZmU0YTU3OWIwMWI3NA==
+  data.tar.gz: !binary |-
+    MmVhYTJmZGY3YjkzNjgwNmM2ODY4YmMxMTNiNWM1OTZlNjg1MTc1Yw==
 SHA512:
-  metadata.gz: 376ec1e96ba09e7edb537c4d813b9e39bff4dff4a14024c4ad95d89a5c47bbb2bd2cc82951ead06258da431e0ebc0fbc822a7b338cf30a2931b88d59227885d9
-  data.tar.gz: 6a14eee48918be937014f323f63f1d9ca5c8554c7c3452963d1a480626009416964c9ce836e50efe9d44792b52a5c2699e63f3cec554423730c21e81959393a7
+  metadata.gz: !binary |-
+    ODdhMWYyMDdmNjM2Mzk5MWM2N2QxYzJiYThjMDFiZmNjZGEyYTYxMDI4M2Ux
+    NDBkNzVlZTdhMDFjMmE3MzFlY2NiNjgwMWJlNWM4MjBjOTllNWVhODgxMDQ2
+    NGZkYTgxY2M3NTBjNzdiODVjMDE5MTE3Yjc3MjE4M2MzYTUzY2Y=
+  data.tar.gz: !binary |-
+    OWJmMzZkMTFmOWFjNmExMWNmMzA4ZGZmM2NlY2NlYTQ2ZTIzOTlmNDU0ODA1
+    NTU0ZDhmZmNlOGI3OTgwODUzN2I2ZDNhMmMzYmU2NTY0NDg4MTg2NTJjZDI5
+    YzMyZDk1MTMxM2JkY2IwOGUzMTRjNzBkMDA2YTc3NTc2YWMwY2E=

data/.gitignore

@@ -20,3 +20,6 @@ tmp
 *.o
 *.a
 mkmf.log
+
+# Bundler vendor gems to vendor/
+vendor/

data/.travis.yml

@@ -1,4 +1,12 @@
-language: ruby
-rvm:
-  - 2.0.0
-script: rake spec
+language: ruby
+rvm:
+- 2.0.0
+deploy:
+  provider: rubygems
+  api_key:
+    secure: gzvD+LH/hVa7RmW3C9Vf6v+asnClSj3I5EHpghwnG7oxJNCiKW1N3zTHPE64M+GhOus9kXlL2/oy358kSNyKAv2eEiqifMs5+hrFAqIU8jEPG+jvaVhBsVpmKedEZEc4ZDgn0Y71Et3+U8+VAEK7iAOQmgKSlVWF1qJxMV7lXSw=
+  gem: vagrant-winrm
+  on:
+    tags: true
+    all_branches: true
+    repo: criteo/vagrant-winrm

data/Gemfile

@@ -3,5 +3,5 @@ source 'https://rubygems.org'
 gemspec
 
 group :development do
-  gem 'vagrant', git: 'https://github.com/mitchellh/vagrant.git', :tag => 'v1.6.3'
+  gem 'vagrant', git: 'https://github.com/mitchellh/vagrant.git'
 end

data/README.md

@@ -47,8 +47,8 @@ Host CustomHostname
 
 ## <a name="development"></a> Development
 
-* Source hosted at [Gitlab][repo]
-* Report issues/questions/feature requests on [Gitlab Issues][issues]
+* Source hosted at [Github][repo]
+* Report issues/questions/feature requests on [Github Issues][issues]
 
 Pull requests are very welcome! Make sure your patches are well tested.
 Ideally create a topic branch for every separate change you make. For
@@ -70,9 +70,9 @@ Apache 2.0 (see [LICENSE][license])
 
 
 [author]:                   https://github.com/Annih
-[issues]:                   https://gitlab.criteois.lan/ruby-gems/kitchen-vagrant_winrm/issues
-[license]:                  https://gitlab.criteois.lan/ruby-gems/kitchen-vagrant_winrm/blob/master/LICENSE
-[repo]:                     https://gitlab.criteois.lan/ruby-gems/kitchen-vagrant_winrm
+[issues]:                   https://github.com/criteo/vagrant-winrm/issues
+[license]:                  https://github.com/criteo/vagrant-winrm/blob/master/LICENSE
+[repo]:                     https://github.com/criteo/vagrant-winrm
 [plugin_usage]:             http://docs.vagrantup.com/v2/plugins/usage.html
 
 [vagrant_dl]:               http://downloads.vagrantup.com/

data/lib/vagrant-winrm/commands/winrm.rb

@@ -9,19 +9,21 @@ module VagrantPlugins
       end
 
       def execute
-        options = {}
+        options = { shell: :powershell }
 
         opts = OptionParser.new do |o|
           o.banner = 'Usage: vagrant winrm [options] [name]'
-          o.separator ''
           o.separator 'Options:'
-          o.separator ''
 
           o.on('-c', '--command COMMAND', 'Execute a WinRM command directly') do |c|
             options[:command] = Array.new if options[:command].nil?
             options[:command].push c
           end
 
+          o.on('-s', '--shell SHELL', [:powershell, :cmd], 'Use the specified shell (powershell, cmd)') do |s|
+            options[:shell] = s
+          end
+
           o.on('--plugin-version', 'Print the version of the plugin and exit') do
             options[:version] = true
           end
@@ -45,15 +47,11 @@ module VagrantPlugins
           raise Errors::ConfigurationError, { :communicator => vm.config.vm.communicator } if vm.config.vm.communicator != :winrm
 
           exit_code = 0
-          @logger.debug("Executing a batch of #{options[:command].length} on remote machine")
+          @logger.debug("Executing a batch of #{options[:command].length} on remote machine with #{options[:shell]}")
 
           options[:command].each do |c|
             @logger.debug("Executing command: #{c}")
-            c.gsub! '"', '\"' if c.include? '`' or c.include? '$(' # Powershell is so strange sometimes!
-            exit_code |= vm.communicate.execute(c) do |type, data|
-              $stdout.print data if type == :stdout
-              $stderr.print data if type == :stderr
-            end
+            exit_code |= vm.communicate.execute(c, shell: options[:shell]) { |type, data| (type == :stderr ? $stderr : $stdout).print data }
           end
           return exit_code
         end

data/lib/vagrant-winrm/commands/winrm_config.rb

@@ -15,9 +15,7 @@ module VagrantPlugins
 
         opts = OptionParser.new do |o|
           o.banner = 'Usage: vagrant winrm-config [options] [name]'
-          o.separator ''
           o.separator 'Options:'
-          o.separator ''
 
           o.on('--host NAME', 'Name the host for the config') do |h|
             options[:host] = h

data/lib/vagrant-winrm/commands/winrm_upload.rb

@@ -8,32 +8,103 @@ module VagrantPlugins
       end
 
       def execute
+        options = { temporary: false, compress: false }
+        source, destination, argv = parse_args options
 
+        return unless source || destination
+
+        # Execute the actual WinRM
+        with_target_vms(argv, single_target: true) do |vm|
+
+          raise Errors::ConfigurationError, { :communicator => vm.config.vm.communicator } if vm.config.vm.communicator != :winrm
+
+          tmp_dest = get_remote_temp_folder(vm) if options[:temporary] || options[:compress]
+
+          dest_file = options[:temporary] ? ::File.join(tmp_dest, destination) : destination
+          $stdout.print dest_file if options[:temporary]
+
+          @logger.debug("Uploading #{source} to #{destination}")
+          if options[:compress]
+            source_is_dir = ::File.directory? source
+            source = compress(source, source_is_dir)
+
+            dest_dir = source_is_dir || dest_file.end_with?('/') || dest_file.end_with?('\\') ? dest_file : ::File.dirname(dest_file)
+            remote_tgz_path = ::File.join(::File.dirname(tmp_dest), ::File.basename(source))
+            vm.communicate.upload(source, remote_tgz_path)
+            return vm.communicate.execute("New-Item '#{dest_dir}' -type directory -force; tar -xzf '#{remote_tgz_path}' -C '#{dest_dir}'; ")
+          else
+            return vm.communicate.upload(source, dest_file)
+          end
+        end
+      end
+
+
+      private
+
+      def compress(source, source_is_dir)
+        require 'zlib'
+        require 'tempfile'
+        require 'archive/tar/minitar'
+
+        cwd = Dir.pwd
+        begin
+          tmp = ::Tempfile.new(['script', '.tar.gz'])
+          tmp.binmode
+          tgz = Zlib::GzipWriter.new (tmp)
+
+          Dir.chdir source_is_dir ? source : ::File.dirname(source)
+          Archive::Tar::Minitar.pack(source_is_dir ? '.' : ::File.basename(source), tgz)
+
+          tmp.path # returns the temporary file path
+        ensure
+          tgz.close if tgz && !tgz.closed?
+          tmp.close if tmp && !tmp.closed?
+          Dir.chdir cwd
+        end
+      end
+
+      def parse_args(options)
         opts = OptionParser.new do |o|
-          o.banner = 'Usage: vagrant winrm-upload <source> <destination> [name]'
+          o.banner = <<-EOS
+Usage:
+\tvagrant winrm-upload [-c] <source> <destination> [name]
+\tvagrant winrm-upload [-c] -t <source> [name]
+          EOS
+          o.separator 'Options:'
+
+          o.on('-t', '--temporary', 'Upload the source file to a temporary directory and return the path') do
+            options[:temporary] = true
+          end
+
+          o.on('-c', '--compress', 'Use gzip compression to speed up the upload') do
+            options[:compress] = true
+          end
         end
 
         # Parse the options and return if we don't have any target.
         argv = parse_options opts
         return unless argv
 
-        if argv.empty? || argv.length > 3 || argv.length < 2
-          raise Vagrant::Errors::CLIInvalidUsage,
-            help: opts.help.chomp
-        end
-
         source = argv[0]
-        destination = argv[1]
-        argv = argv.drop(2)
-
-        # Execute the actual WinRM
-        with_target_vms(argv, single_target: true) do |vm|
+        if options[:temporary]
+          min, max, destination = 1, 2, ::File.basename(argv[0])
+        else
+          min, max, destination = 2, 3, argv[1]
+        end
 
-          raise Errors::ConfigurationError, { :communicator => vm.config.vm.communicator } if vm.config.vm.communicator != :winrm
+        if argv.empty? || argv.length > max || argv.length < min
+          raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp
+        end
+        [source, destination, argv.drop(min)]
+      end
 
-          @logger.debug("Uploading #{source} to #{destination}")
-          return vm.communicate.upload(source, destination)
+      def get_remote_temp_folder(vm)
+        dir = nil
+        vm.communicate.execute('[System.IO.Path]::Combine([System.IO.Path]::GetTempPath(), [System.IO.Path]::GetRandomFileName()) | Write-Host -NoNewline') do |type, data|
+          raise Errors::TempFolderError, { :communicator => vm.config.vm.communicator } if type == :stderr || dir
+          dir = data
         end
+        dir
       end
     end
   end

data/lib/vagrant-winrm/errors.rb

@@ -9,6 +9,10 @@ module VagrantPlugins
       class ConfigurationError < WinRMError
         error_key(:config_error)
       end
+
+      class TempFolderError < WinRMError
+        error_key(:tempfolder_error)
+      end
     end
   end
 end

data/lib/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module VagrantWinRM
-    VERSION = '0.0.2'
+    VERSION = '0.4.0'
   end
 end

data/locales/en.yml

@@ -4,4 +4,8 @@ en:
       config_error: |-
         The current machine is not configured to communicate through WinRM.
 
+        Communicator: %{communicator}
+      tempfolder_error: |-
+        Unable to retrieve a temporary folder on the remote machine through WinRM.
+
         Communicator: %{communicator}

data/spec/vagrant-winrm/commands/winrm_config_spec.rb

@@ -1,102 +1,112 @@
-require 'spec_helper'
-require 'stringio'
-
-describe VagrantPlugins::VagrantWinRM::WinRMConfig, :unit => true do
-
-=begin ############
-# Here we mock!
-=end ##############
-
-  let(:idx) { double('idx') }
-  let(:winrm_config) { double('winrm_config', host: 'winrm_super_host', port: 32424, username: 'usern@me', password: 'p4ssw0rd') }
-  let(:machine_config) { double('machine_config', winrm: winrm_config) }
-  let(:machine) { double('machine', config: machine_config, name: 'vagrant', provider: 'virtualbox', config: machine_config, ui: double('ui', opts: {})) }
-  let(:env) { double('env', root_path: '', home_path: '', ui_class: '', machine_names: [machine.name], active_machines: [machine], machine_index: idx, default_provider: 'virtualbox') }
-
-  before do
-    # Mock the local env creation
-    allow(machine).to receive(:vagrant_env).with('', { :ui_class => '' }).and_return env
-
-    # Mock the index to include only our machine
-    allow(idx).to receive(:release).with machine
-    allow(idx).to receive(:include?).with(any_args) do |name|
-      'vagrant' == name
-    end
-    allow(idx).to receive(:get).with(any_args) do |name|
-      env.machine(name.to_sym, :virtualbox)
-    end
-
-    # Add our machine to the environment
-    allow(env).to receive(:machine).with(any_args, :virtualbox) do |name, provider|
-      machine if :vagrant == name
-    end
-  end
-
-=begin ############
-# Here we test!
-=end ##############
-  describe 'execute' do
-
-    it 'displays help message with option --help' do
-      c = VagrantPlugins::VagrantWinRM::WinRMConfig.new(['--help'], env)
-      expect {
-        expect(c.execute).to be_nil
-      }.to output.to_stdout
-    end
-
-    it 'raises error on unknown target' do
-      c = VagrantPlugins::VagrantWinRM::WinRMConfig.new(['unknownTarget'], env)
-      expect { c.execute }.to raise_error(Vagrant::Errors::VMNotFoundError)
-    end
-
-    it 'raises error ''invalid options'' on unknown option' do
-      c = VagrantPlugins::VagrantWinRM::WinRMConfig.new(['--unknown'], env)
-      expect { c.execute }.to raise_error(Vagrant::Errors::CLIInvalidOptions)
-    end
-
-    it 'ouputs the WinRMConfig with no Target' do
-      c = VagrantPlugins::VagrantWinRM::WinRMConfig.new([], env)
-      begin
-        $stdout = StringIO.new
-        expect(c.execute).to be_zero
-        expect($stdout.string).to match(/#{machine.name}/)
-        expect($stdout.string).to match(/#{winrm_config.host}/)
-        expect($stdout.string).to match(/#{winrm_config.port}/)
-        expect($stdout.string).to match(/#{winrm_config.username}/)
-        expect($stdout.string).to match(/#{winrm_config.password}/)
-      ensure
-        $stdout = STDOUT
-      end
-    end
-
-    it 'ouputs the WinRMConfig with target' do
-      c = VagrantPlugins::VagrantWinRM::WinRMConfig.new(['vagrant'], env)
-      begin
-        $stdout = StringIO.new
-        expect(c.execute).to be_zero
-        expect($stdout.string).to match(/#{machine.name}/)
-        expect($stdout.string).to match(/#{winrm_config.host}/)
-        expect($stdout.string).to match(/#{winrm_config.port}/)
-        expect($stdout.string).to match(/#{winrm_config.username}/)
-        expect($stdout.string).to match(/#{winrm_config.password}/)
-      ensure
-        $stdout = STDOUT
-      end
-    end
-
-    it 'ouputs the WinRMConfig with custom host key when --host is provided' do
-      c = VagrantPlugins::VagrantWinRM::WinRMConfig.new(['--host', 'custom_host_key', 'vagrant'], env)
-      begin
-        $stdout = StringIO.new
-        expect(c.execute).to be_zero
-        expect($stdout.string).to match(/custom_host_key/)
-        expect($stdout.string).to match(/#{winrm_config.host}/)
-        expect($stdout.string).to match(/#{winrm_config.port}/)
-        expect($stdout.string).to match(/#{winrm_config.username}/)
-        expect($stdout.string).to match(/#{winrm_config.password}/)
-      ensure
-        $stdout = STDOUT
-      end
-    end
-  end
-end
+require 'spec_helper'
+require 'stringio'
+
+describe VagrantPlugins::VagrantWinRM::WinRMConfig, :unit => true do
+
+=begin ############
+# Here we mock!
+=end ##############
+
+  let(:idx) { double('idx') }
+  let(:winrm_config) { double('winrm_config', host: 'winrm_super_host', port: 32424, username: 'usern@me', password: 'p4ssw0rd') }
+  let(:machine_config) { double('machine_config', winrm: winrm_config) }
+  let(:machine) {
+    double(
+      'machine',
+      config: machine_config,
+      name: 'vagrant',
+      provider: 'virtualbox',
+      config: machine_config,
+      ui: double('ui', opts: {}),
+      state: nil
+    )
+  }
+  let(:env) { double('env', root_path: '', home_path: '', ui_class: '', machine_names: [machine.name], active_machines: [machine], machine_index: idx, default_provider: 'virtualbox') }
+
+  before do
+    # Mock the local env creation
+    allow(machine).to receive(:vagrant_env).with('', { :ui_class => '' }).and_return env
+
+    # Mock the index to include only our machine
+    allow(idx).to receive(:release).with machine
+    allow(idx).to receive(:include?).with(any_args) do |name|
+      'vagrant' == name
+    end
+    allow(idx).to receive(:get).with(any_args) do |name|
+      env.machine(name.to_sym, :virtualbox)
+    end
+
+    # Add our machine to the environment
+    allow(env).to receive(:machine).with(any_args, :virtualbox) do |name, provider|
+      machine if :vagrant == name
+    end
+  end
+
+=begin ############
+# Here we test!
+=end ##############
+  describe 'execute' do
+
+    it 'displays help message with option --help' do
+      c = VagrantPlugins::VagrantWinRM::WinRMConfig.new(['--help'], env)
+      expect {
+        expect(c.execute).to be_nil
+      }.to output.to_stdout
+    end
+
+    it 'raises error on unknown target' do
+      c = VagrantPlugins::VagrantWinRM::WinRMConfig.new(['unknownTarget'], env)
+      expect { c.execute }.to raise_error(Vagrant::Errors::VMNotFoundError)
+    end
+
+    it 'raises error ''invalid options'' on unknown option' do
+      c = VagrantPlugins::VagrantWinRM::WinRMConfig.new(['--unknown'], env)
+      expect { c.execute }.to raise_error(Vagrant::Errors::CLIInvalidOptions)
+    end
+
+    it 'ouputs the WinRMConfig with no Target' do
+      c = VagrantPlugins::VagrantWinRM::WinRMConfig.new([], env)
+      begin
+        $stdout = StringIO.new
+        expect(c.execute).to be_zero
+        expect($stdout.string).to match(/#{machine.name}/)
+        expect($stdout.string).to match(/#{winrm_config.host}/)
+        expect($stdout.string).to match(/#{winrm_config.port}/)
+        expect($stdout.string).to match(/#{winrm_config.username}/)
+        expect($stdout.string).to match(/#{winrm_config.password}/)
+      ensure
+        $stdout = STDOUT
+      end
+    end
+
+    it 'ouputs the WinRMConfig with target' do
+      c = VagrantPlugins::VagrantWinRM::WinRMConfig.new(['vagrant'], env)
+      begin
+        $stdout = StringIO.new
+        expect(c.execute).to be_zero
+        expect($stdout.string).to match(/#{machine.name}/)
+        expect($stdout.string).to match(/#{winrm_config.host}/)
+        expect($stdout.string).to match(/#{winrm_config.port}/)
+        expect($stdout.string).to match(/#{winrm_config.username}/)
+        expect($stdout.string).to match(/#{winrm_config.password}/)
+      ensure
+        $stdout = STDOUT
+      end
+    end
+
+    it 'ouputs the WinRMConfig with custom host key when --host is provided' do
+      c = VagrantPlugins::VagrantWinRM::WinRMConfig.new(['--host', 'custom_host_key', 'vagrant'], env)
+      begin
+        $stdout = StringIO.new
+        expect(c.execute).to be_zero
+        expect($stdout.string).to match(/custom_host_key/)
+        expect($stdout.string).to match(/#{winrm_config.host}/)
+        expect($stdout.string).to match(/#{winrm_config.port}/)
+        expect($stdout.string).to match(/#{winrm_config.username}/)
+        expect($stdout.string).to match(/#{winrm_config.password}/)
+      ensure
+        $stdout = STDOUT
+      end
+    end
+  end
+end

data/spec/vagrant-winrm/commands/winrm_spec.rb

@@ -1,120 +1,120 @@
-require 'spec_helper'
-require 'stringio'
-
-describe VagrantPlugins::VagrantWinRM::WinRM, :unit => true do
-
-=begin ############
-# Here we mock!
-=end ##############
-
-  let(:idx) { double('idx') }
-  let(:communicator) { double('communicator') }
-  let(:config_vm) { double('config_vm', communicator: :winrm) }
-  let(:machine_config) { double('machine_config', vm: config_vm) }
-  let(:machine) { double('machine', config: machine_config, name: 'vagrant', provider: 'virtualbox', config: machine_config, communicate: communicator, ui: double('ui', opts: {})) }
-  let(:env) { double('env', root_path: '', home_path: '', ui_class: '', machine_names: [machine.name], active_machines: [machine], machine_index: idx, default_provider: 'virtualbox') }
-
-  before do
-    # Mock the local env creation
-    allow(machine).to receive(:vagrant_env).with('', { :ui_class => '' }).and_return env
-
-    # Mock the index to include only our machine
-    allow(idx).to receive(:release).with machine
-    allow(idx).to receive(:include?).with(any_args) do |name|
-      'vagrant' == name
-    end
-    allow(idx).to receive(:get).with(any_args) do |name|
-      env.machine(name.to_sym, :virtualbox)
-    end
-
-    # Add our machine to the environment
-    allow(env).to receive(:machine).with(any_args, :virtualbox) do |name, provider|
-      machine if :vagrant == name
-    end
-  end
-
-=begin ############
-# Here we test!
-=end ##############
-  describe 'execute' do
-    it 'does nothing with no option' do
-      c = VagrantPlugins::VagrantWinRM::WinRM.new([], env)
-      expect {
-        expect(c.execute).to be_zero
-      }.not_to output.to_stdout
-    end
-
-    it 'gives proper version with option --plugin-version' do
-      c = VagrantPlugins::VagrantWinRM::WinRM.new(['--plugin-version'], env)
-      expect {
-        expect(c.execute).to be_zero
-      }.to output("Vagrant-winrm plugin 0.0.1\n").to_stdout
-    end
-
-    it 'displays help message with option --help' do
-      c = VagrantPlugins::VagrantWinRM::WinRM.new(['--help'], env)
-      expect {
-        expect(c.execute).to be_nil
-      }.to output.to_stdout
-    end
-
-    it 'raises error when communicator not winrm' do
-      c = VagrantPlugins::VagrantWinRM::WinRM.new(['-c', 'dummyCommand'], env)
-      expect(config_vm).to receive(:communicator).and_return :ssh
-
-      expect { c.execute }.to raise_error(VagrantPlugins::VagrantWinRM::Errors::ConfigurationError, /not configured to communicate through WinRM/)
-    end
-
-    it 'raises error on unknown target' do
-      c = VagrantPlugins::VagrantWinRM::WinRM.new(['-c', 'command1', 'unknownTarget'], env)
-      expect { c.execute }.to raise_error(Vagrant::Errors::VMNotFoundError)
-    end
-
-    it 'raises error ''invalid options'' on unknown option' do
-      c = VagrantPlugins::VagrantWinRM::WinRM.new(['--unknown'], env)
-      expect { c.execute }.to raise_error(Vagrant::Errors::CLIInvalidOptions)
-    end
-
-    it 'passes commands to communicator with no target' do
-      c = VagrantPlugins::VagrantWinRM::WinRM.new(['-c', 'command1', '--command', 'command2', '-c', 'command3', '--command', 'command4'], env)
-
-      expect(communicator).to receive(:execute).ordered.with('command1').and_return 0
-      expect(communicator).to receive(:execute).ordered.with('command2').and_return 0
-      expect(communicator).to receive(:execute).ordered.with('command3').and_return 0
-      expect(communicator).to receive(:execute).ordered.with('command4').and_return 0
-
-      expect {
-        expect(c.execute).to be_zero
-      }.not_to output.to_stdout
-    end
-
-    it 'passes commands to communicator even with a specific target' do
-      c = VagrantPlugins::VagrantWinRM::WinRM.new(['-c', 'command5', '--command', 'command6', '-c', 'command7', '--command', 'command8', 'vagrant'], env)
-      expect(communicator).to receive(:execute).ordered.with('command5').and_return 0
-      expect(communicator).to receive(:execute).ordered.with('command6').and_return 0
-      expect(communicator).to receive(:execute).ordered.with('command7').and_return 0
-      expect(communicator).to receive(:execute).ordered.with('command8').and_return 0
-      expect {
-        expect(c.execute).to be_zero
-      }.not_to output.to_stdout
-    end
-
-    it 'redirects winrm outputs to stdout' do
-      c = VagrantPlugins::VagrantWinRM::WinRM.new(['-c', 'command'], env)
-
-      expect(communicator).to receive(:execute).with('command').and_yield(:stdout, 'output message').and_return 0
-      expect {
-        expect(c.execute).to be_zero
-      }.to output('output message').to_stdout
-    end
-
-    it 'redirects winrm errors to stderr' do
-      c = VagrantPlugins::VagrantWinRM::WinRM.new(['-c', 'command'], env)
-
-      expect(communicator).to receive(:execute).with('command').and_yield(:stderr, 'error message').and_return 0
-      expect {
-        expect(c.execute).to be_zero
-      }.to output('error message').to_stderr
-    end
-  end
-end
+require 'spec_helper'
+require 'stringio'
+
+describe VagrantPlugins::VagrantWinRM::WinRM, :unit => true do
+
+=begin ############
+# Here we mock!
+=end ##############
+
+  let(:idx) { double('idx') }
+  let(:communicator) { double('communicator') }
+  let(:config_vm) { double('config_vm', communicator: :winrm) }
+  let(:machine_config) { double('machine_config', vm: config_vm) }
+  let(:machine) { double('machine', config: machine_config, name: 'vagrant', provider: 'virtualbox', config: machine_config, communicate: communicator, ui: double('ui', opts: {})) }
+  let(:env) { double('env', root_path: '', home_path: '', ui_class: '', machine_names: [machine.name], active_machines: [machine], machine_index: idx, default_provider: 'virtualbox') }
+
+  before do
+    # Mock the local env creation
+    allow(machine).to receive(:vagrant_env).with('', { :ui_class => '' }).and_return env
+
+    # Mock the index to include only our machine
+    allow(idx).to receive(:release).with machine
+    allow(idx).to receive(:include?).with(any_args) do |name|
+      'vagrant' == name
+    end
+    allow(idx).to receive(:get).with(any_args) do |name|
+      env.machine(name.to_sym, :virtualbox)
+    end
+
+    # Add our machine to the environment
+    allow(env).to receive(:machine).with(any_args, :virtualbox) do |name, provider|
+      machine if :vagrant == name
+    end
+  end
+
+=begin ############
+# Here we test!
+=end ##############
+  describe 'execute' do
+    it 'does nothing with no option' do
+      c = VagrantPlugins::VagrantWinRM::WinRM.new([], env)
+      expect {
+        expect(c.execute).to be_zero
+      }.not_to output.to_stdout
+    end
+
+    it 'gives proper version with option --plugin-version' do
+      c = VagrantPlugins::VagrantWinRM::WinRM.new(['--plugin-version'], env)
+      expect {
+        expect(c.execute).to be_zero
+      }.to output("Vagrant-winrm plugin #{VagrantPlugins::VagrantWinRM::VERSION}\n").to_stdout
+    end
+
+    it 'displays help message with option --help' do
+      c = VagrantPlugins::VagrantWinRM::WinRM.new(['--help'], env)
+      expect {
+        expect(c.execute).to be_nil
+      }.to output.to_stdout
+    end
+
+    it 'raises error when communicator not winrm' do
+      c = VagrantPlugins::VagrantWinRM::WinRM.new(['-c', 'dummyCommand'], env)
+      expect(config_vm).to receive(:communicator).and_return :ssh
+
+      expect { c.execute }.to raise_error(VagrantPlugins::VagrantWinRM::Errors::ConfigurationError, /not configured to communicate through WinRM/)
+    end
+
+    it 'raises error on unknown target' do
+      c = VagrantPlugins::VagrantWinRM::WinRM.new(['-c', 'command1', 'unknownTarget'], env)
+      expect { c.execute }.to raise_error(Vagrant::Errors::VMNotFoundError)
+    end
+
+    it 'raises error ''invalid options'' on unknown option' do
+      c = VagrantPlugins::VagrantWinRM::WinRM.new(['--unknown'], env)
+      expect { c.execute }.to raise_error(Vagrant::Errors::CLIInvalidOptions)
+    end
+
+    it 'passes commands to communicator with no target' do
+      c = VagrantPlugins::VagrantWinRM::WinRM.new(['-c', 'command1', '--command', 'command2', '-c', 'command3', '--command', 'command4'], env)
+
+      expect(communicator).to receive(:execute).ordered.with('command1', { shell: :powershell }).and_return 0
+      expect(communicator).to receive(:execute).ordered.with('command2', { shell: :powershell }).and_return 0
+      expect(communicator).to receive(:execute).ordered.with('command3', { shell: :powershell }).and_return 0
+      expect(communicator).to receive(:execute).ordered.with('command4', { shell: :powershell }).and_return 0
+
+      expect {
+        expect(c.execute).to be_zero
+      }.not_to output.to_stdout
+    end
+
+    it 'passes commands to communicator even with a specific target' do
+      c = VagrantPlugins::VagrantWinRM::WinRM.new(['-c', 'command5', '--command', 'command6', '-c', 'command7', '--command', 'command8', 'vagrant'], env)
+      expect(communicator).to receive(:execute).ordered.with('command5', { shell: :powershell }).and_return 0
+      expect(communicator).to receive(:execute).ordered.with('command6', { shell: :powershell }).and_return 0
+      expect(communicator).to receive(:execute).ordered.with('command7', { shell: :powershell }).and_return 0
+      expect(communicator).to receive(:execute).ordered.with('command8', { shell: :powershell }).and_return 0
+      expect {
+        expect(c.execute).to be_zero
+      }.not_to output.to_stdout
+    end
+
+    it 'redirects winrm outputs to stdout' do
+      c = VagrantPlugins::VagrantWinRM::WinRM.new(['-c', 'command'], env)
+
+      expect(communicator).to receive(:execute).with('command', { shell: :powershell }).and_yield(:stdout, 'output message').and_return 0
+      expect {
+        expect(c.execute).to be_zero
+      }.to output('output message').to_stdout
+    end
+
+    it 'redirects winrm errors to stderr' do
+      c = VagrantPlugins::VagrantWinRM::WinRM.new(['-c', 'command'], env)
+
+      expect(communicator).to receive(:execute).with('command', { shell: :powershell }).and_yield(:stderr, 'error message').and_return 0
+      expect {
+        expect(c.execute).to be_zero
+      }.to output('error message').to_stderr
+    end
+  end
+end

data/spec/vagrant-winrm/commands/winrm_upload_spec.rb

@@ -1,87 +1,87 @@
-require 'spec_helper'
-require 'stringio'
-
-describe VagrantPlugins::VagrantWinRM::WinRMUpload, :unit => true do
-
-=begin ############
-# Here we mock!
-=end ##############
-
-  let(:idx) { double('idx') }
-  let(:communicator) { double('communicator') }
-  let(:config_vm) { double('config_vm', communicator: :winrm) }
-  let(:machine_config) { double('machine_config', vm: config_vm) }
-  let(:machine) { double('machine', config: machine_config, name: 'vagrant', provider: 'virtualbox', config: machine_config, communicate: communicator, ui: double('ui', opts: {})) }
-  let(:env) { double('env', root_path: '', home_path: '', ui_class: '', machine_names: [machine.name], active_machines: [machine], machine_index: idx, default_provider: 'virtualbox') }
-
-  before do
-    # Mock the local env creation
-    allow(machine).to receive(:vagrant_env).with('', { :ui_class => '' }).and_return env
-
-    # Mock the index to include only our machine
-    allow(idx).to receive(:release).with machine
-    allow(idx).to receive(:include?).with(any_args) do |name|
-      'vagrant' == name
-    end
-    allow(idx).to receive(:get).with(any_args) do |name|
-      env.machine(name.to_sym, :virtualbox)
-    end
-
-    # Add our machine to the environment
-    allow(env).to receive(:machine).with(any_args, :virtualbox) do |name, provider|
-      machine if :vagrant == name
-    end
-  end
-
-=begin ############
-# Here we test!
-=end ##############
-  describe 'execute' do
-    it 'raises error ''invalid usage'' on bad usage' do
-      c = VagrantPlugins::VagrantWinRM::WinRMUpload.new([], env)
-      expect { c.execute }.to raise_error(Vagrant::Errors::CLIInvalidUsage)
-    end
-
-    it 'raises error ''invalid options'' on unknown option' do
-      c = VagrantPlugins::VagrantWinRM::WinRMUpload.new(['--unknown'], env)
-      expect { c.execute }.to raise_error(Vagrant::Errors::CLIInvalidOptions)
-    end
-
-    it 'displays help message with option --help' do
-      c = VagrantPlugins::VagrantWinRM::WinRMUpload.new(['--help'], env)
-      expect {
-        expect(c.execute).to be_nil
-      }.to output.to_stdout
-    end
-
-    it 'raises error when communicator not winrm' do
-      c = VagrantPlugins::VagrantWinRM::WinRMUpload.new(['source', 'destination'], env)
-      expect(config_vm).to receive(:communicator).and_return :ssh
-
-      expect { c.execute }.to raise_error(VagrantPlugins::VagrantWinRM::Errors::ConfigurationError, /not configured to communicate through WinRM/)
-    end
-
-    it 'raises error on unknown target' do
-      c = VagrantPlugins::VagrantWinRM::WinRMUpload.new(['source', 'destination', 'unknownTarget'], env)
-      expect { c.execute }.to raise_error Vagrant::Errors::VMNotFoundError
-    end
-
-
-    it 'passes source and destination to communicator with no target' do
-      c = VagrantPlugins::VagrantWinRM::WinRMUpload.new(['source', 'destination'], env)
-      expect(communicator).to receive(:upload).with('source', 'destination').and_return 0
-
-      expect {
-        expect(c.execute).to be_zero
-      }.not_to output.to_stdout
-    end
-
-    it 'passes source and destination to communicator even with a specific target' do
-      c = VagrantPlugins::VagrantWinRM::WinRMUpload.new(['source', 'destination', 'vagrant'], env)
-      expect(communicator).to receive(:upload).with('source', 'destination').and_return 0
-      expect {
-        expect(c.execute).to be_zero
-      }.not_to output.to_stdout
-    end
-  end
-end
+require 'spec_helper'
+require 'stringio'
+
+describe VagrantPlugins::VagrantWinRM::WinRMUpload, :unit => true do
+
+=begin ############
+# Here we mock!
+=end ##############
+
+  let(:idx) { double('idx') }
+  let(:communicator) { double('communicator') }
+  let(:config_vm) { double('config_vm', communicator: :winrm) }
+  let(:machine_config) { double('machine_config', vm: config_vm) }
+  let(:machine) { double('machine', config: machine_config, name: 'vagrant', provider: 'virtualbox', config: machine_config, communicate: communicator, state:nil, ui: double('ui', opts: {})) }
+  let(:env) { double('env', root_path: '', home_path: '', ui_class: '', machine_names: [machine.name], active_machines: [machine], machine_index: idx, default_provider: 'virtualbox') }
+
+  before do
+    # Mock the local env creation
+    allow(machine).to receive(:vagrant_env).with('', { :ui_class => '' }).and_return env
+
+    # Mock the index to include only our machine
+    allow(idx).to receive(:release).with machine
+    allow(idx).to receive(:include?).with(any_args) do |name|
+      'vagrant' == name
+    end
+    allow(idx).to receive(:get).with(any_args) do |name|
+      env.machine(name.to_sym, :virtualbox)
+    end
+
+    # Add our machine to the environment
+    allow(env).to receive(:machine).with(any_args, :virtualbox) do |name, provider|
+      machine if :vagrant == name
+    end
+  end
+
+=begin ############
+# Here we test!
+=end ##############
+  describe 'execute' do
+    it 'raises error ''invalid usage'' on bad usage' do
+      c = VagrantPlugins::VagrantWinRM::WinRMUpload.new([], env)
+      expect { c.execute }.to raise_error(Vagrant::Errors::CLIInvalidUsage)
+    end
+
+    it 'raises error ''invalid options'' on unknown option' do
+      c = VagrantPlugins::VagrantWinRM::WinRMUpload.new(['--unknown'], env)
+      expect { c.execute }.to raise_error(Vagrant::Errors::CLIInvalidOptions)
+    end
+
+    it 'displays help message with option --help' do
+      c = VagrantPlugins::VagrantWinRM::WinRMUpload.new(['--help'], env)
+      expect {
+        expect(c.execute).to be_nil
+      }.to output.to_stdout
+    end
+
+    it 'raises error when communicator not winrm' do
+      c = VagrantPlugins::VagrantWinRM::WinRMUpload.new(['source', 'destination'], env)
+      expect(config_vm).to receive(:communicator).and_return :ssh
+
+      expect { c.execute }.to raise_error(VagrantPlugins::VagrantWinRM::Errors::ConfigurationError, /not configured to communicate through WinRM/)
+    end
+
+    it 'raises error on unknown target' do
+      c = VagrantPlugins::VagrantWinRM::WinRMUpload.new(['source', 'destination', 'unknownTarget'], env)
+      expect { c.execute }.to raise_error Vagrant::Errors::VMNotFoundError
+    end
+
+
+    it 'passes source and destination to communicator with no target' do
+      c = VagrantPlugins::VagrantWinRM::WinRMUpload.new(['source', 'destination'], env)
+      expect(communicator).to receive(:upload).with('source', 'destination').and_return 0
+
+      expect {
+        expect(c.execute).to be_zero
+      }.not_to output.to_stdout
+    end
+
+    it 'passes source and destination to communicator even with a specific target' do
+      c = VagrantPlugins::VagrantWinRM::WinRMUpload.new(['source', 'destination', 'vagrant'], env)
+      expect(communicator).to receive(:upload).with('source', 'destination').and_return 0
+      expect {
+        expect(c.execute).to be_zero
+      }.not_to output.to_stdout
+    end
+  end
+end

data/vagrant-winrm.gemspec

@@ -7,20 +7,22 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ['Baptiste Courtois']
   s.email       = ['b.courtois@criteo.fr']
-  s.homepage    = 'https://gitlab.criteois.lan/ruby-gems/vagrant-winrm/'
+  s.homepage    = 'https://github.com/criteo/vagrant-winrm/'
   s.summary     = 'A Vagrant 1.6+ plugin extending WinRM communication features.'
   s.description = 'A Vagrant 1.6+ plugin that adds new command to extends WinRM communication features.'
   s.license     = 'Apache 2.0'
 
   s.required_rubygems_version = '>= 2.0.0'
 
+  s.add_dependency 'minitar', '~> 0.5'
+
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec_junit_formatter'
-  s.add_development_dependency 'rspec-core', '~> 3.0.0'
-  s.add_development_dependency 'rspec-expectations', '~> 3.0.0'
-  s.add_development_dependency 'rspec-mocks', '~> 3.0.0'
+  s.add_development_dependency 'rspec-core', '~> 3.0'
+  s.add_development_dependency 'rspec-expectations', '~> 3.0'
+  s.add_development_dependency 'rspec-mocks', '~> 3.0'
 
-  s.add_development_dependency 'bundler', '>= 1.0.0'
+  s.add_development_dependency 'bundler', '~> 1.0'
 
   s.files        = `git ls-files`.split("\n")
   s.executables  = `git ls-files`.split("\n").map { |f| f =~ /^bin\/(.*)/ ? $1 : nil }.compact

metadata

@@ -1,41 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-winrm
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Baptiste Courtois
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-26 00:00:00.000000000 Z
+date: 2014-12-31 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec_junit_formatter
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
@@ -44,56 +58,56 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rspec-expectations
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rspec-mocks
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
 description: A Vagrant 1.6+ plugin that adds new command to extends WinRM communication
   features.
 email:
@@ -102,6 +116,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .bundle/config
 - .gitignore
 - .travis.yml
 - Gemfile
@@ -122,7 +137,7 @@ files:
 - spec/vagrant-winrm/commands/winrm_upload_spec.rb
 - templates/winrm_config/config.erb
 - vagrant-winrm.gemspec
-homepage: https://gitlab.criteois.lan/ruby-gems/vagrant-winrm/
+homepage: https://github.com/criteo/vagrant-winrm/
 licenses:
 - Apache 2.0
 metadata: {}
@@ -132,17 +147,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: 2.0.0
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A Vagrant 1.6+ plugin extending WinRM communication features.