train 0.19.1 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a52a5c7ef67219ce7efa1358a142c6a26d400d61
-  data.tar.gz: 0e4a108030e0164506191a128463d691cdbfa177
+  metadata.gz: e2e42871db47191abec6fe3d94b56a60863abd48
+  data.tar.gz: 9004baaebe7b8021f840647bdc5032b88fb130fc
 SHA512:
-  metadata.gz: 58bc527291b454cdd415a2c39fdc3166e010b2b5106f4917b5b845933612d6b9ea01914dafb932eea0760157c925d2f58abb1cd6be626f513c165a37db12acdd
-  data.tar.gz: d67667d29a6cb0bebe830c0c6c4d8706c4c15054ecc7eae6c1f774d0d8c58b9ed51bce96dd4e807444210419e98ff15a6b47ad2d04d4b35240908d87b9948ba0
+  metadata.gz: 32c7d11c6aeaee6a856dfa3ce914e8d6a64d23108d8239473a7364b82929cace43c495f21765486d5b4fec02911c67747075376bde4ed8239fb88c54d30cac6d
+  data.tar.gz: 1335190030d7f53d31b7c5ee4f7c882fc101e80b9ae808da030c4090ecac2cc95a1b609049dbccd78ab9e7235a1c649dc9a206700de9c4689c2c1b890425f77f

data/.rubocop.yml

@@ -69,3 +69,5 @@ Style/SpaceAroundOperators:
   Enabled: false
 Style/IfUnlessModifier:
   Enabled: false
+Style/FrozenStringLiteralComment:
+  Enabled: false

data/CHANGELOG.md

@@ -1,7 +1,20 @@
 # Change Log
 
-## [0.19.1](https://github.com/chef/train/tree/0.19.1) (2016-09-16)
-[Full Changelog](https://github.com/chef/train/compare/v0.19.0...0.19.1)
+## [0.20.0](https://github.com/chef/train/tree/0.20.0) (2016-09-21)
+[Full Changelog](https://github.com/chef/train/compare/v0.19.1...0.20.0)
+
+**Fixed bugs:**
+
+- get `Preparing modules for first use.` when I use train on Windows [\#153](https://github.com/chef/train/issues/153)
+
+**Merged pull requests:**
+
+- `Preparing modules for first use.` error message on Windows [\#152](https://github.com/chef/train/pull/152) ([chris-rock](https://github.com/chris-rock))
+- Convert `wmic` architecture to a normal standard [\#151](https://github.com/chef/train/pull/151) ([jerryaldrichiii](https://github.com/jerryaldrichiii))
+- Login shell [\#149](https://github.com/chef/train/pull/149) ([jonathanmorley](https://github.com/jonathanmorley))
+
+## [v0.19.1](https://github.com/chef/train/tree/v0.19.1) (2016-09-16)
+[Full Changelog](https://github.com/chef/train/compare/v0.19.0...v0.19.1)
 
 **Implemented enhancements:**
 

data/lib/train/extras/command_wrapper.rb

@@ -28,6 +28,9 @@ module Train::Extras
   class LinuxCommand < CommandWrapperBase
     Train::Options.attach(self)
 
+    option :shell, default: false
+    option :shell_options, default: nil
+    option :shell_command, default: nil
     option :sudo, default: false
     option :sudo_options, default: nil
     option :sudo_password, default: nil
@@ -38,12 +41,14 @@ module Train::Extras
       @backend = backend
       validate_options(options)
 
+      @shell = options[:shell]
+      @shell_options = options[:shell_options] # e.g. '--login'
+      @shell_command = options[:shell_command] # e.g. '/bin/sh'
       @sudo = options[:sudo]
       @sudo_options = options[:sudo_options]
       @sudo_password = options[:sudo_password]
       @sudo_command = options[:sudo_command]
       @user = options[:user]
-      @prefix = build_prefix
     end
 
     # (see CommandWrapperBase::verify)
@@ -71,29 +76,48 @@ module Train::Extras
 
     # (see CommandWrapperBase::run)
     def run(command)
-      @prefix + command
+      shell_wrap(sudo_wrap(command))
     end
 
     def self.active?(options)
-      options.is_a?(Hash) && options[:sudo]
+      options.is_a?(Hash) && (
+        options[:sudo] ||
+        options[:shell]
+      )
     end
 
     private
 
-    def build_prefix
-      return '' unless @sudo
-      return '' if @user == 'root'
+    # wrap the cmd in a sudo command
+    def sudo_wrap(cmd)
+      return cmd unless @sudo
+      return cmd if @user == 'root'
 
       res = (@sudo_command || 'sudo') + ' '
 
-      unless @sudo_password.nil?
-        b64pw = Base64.strict_encode64(@sudo_password + "\n")
-        res = "echo #{b64pw} | base64 --decode | #{res}-S "
-      end
+      res = "#{safe_string(@sudo_password + "\n")} | #{res}-S " unless @sudo_password.nil?
 
       res << @sudo_options.to_s + ' ' unless @sudo_options.nil?
 
-      res
+      res + cmd
+    end
+
+    # wrap the cmd in a subshell allowing for options to
+    # passed to the subshell
+    def shell_wrap(cmd)
+      return cmd unless @shell
+
+      shell = @shell_command || '$SHELL'
+      options = ' ' + @shell_options.to_s unless @shell_options.nil?
+
+      "#{safe_string(cmd)} | #{shell}#{options}"
+    end
+
+    # encapsulates encoding the string into a safe form, and decoding for use.
+    # @return [String] A command line snippet that can be used as part of a pipeline.
+    def safe_string(str)
+      b64str = Base64.strict_encode64(str)
+      "echo #{b64str} | base64 --decode"
     end
   end
 
@@ -113,7 +137,7 @@ module Train::Extras
       # especially in local mode, we cannot be sure that we get a Powershell
       # we may just get a `cmd`.
       # TODO: we may want to opt for powershell.exe -command instead of `encodeCommand`
-      "powershell -encodedCommand #{encoded(safe_script(script))}"
+      "powershell -NoProfile -encodedCommand #{encoded(safe_script(script))}"
     end
 
     # suppress the progress stream from leaking to stderr

data/lib/train/extras/os_detect_windows.rb

@@ -50,8 +50,37 @@ module Train::Extras
         @platform[:build] = sys_info[:BuildNumber]
         @platform[:name] = sys_info[:Caption]
         @platform[:name] = @platform[:name].gsub('Microsoft', '').strip unless @platform[:name].empty?
-        @platform[:arch] = sys_info[:OSArchitecture]
+        @platform[:arch] = read_wmic_cpu
       end
     end
+
+    # `OSArchitecture` from `read_wmic` does not match a normal standard
+    # For example, `x86_64` shows as `64-bit`
+    def read_wmic_cpu
+      res = @backend.run_command('wmic cpu get architecture /format:list')
+      if res.exit_status == 0
+        sys_info = {}
+        res.stdout.lines.each { |line|
+          m = /^\s*([^=]*?)\s*=\s*(.*?)\s*$/.match(line)
+          sys_info[m[1].to_sym] = m[2] unless m.nil? || m[1].nil?
+        }
+      end
+
+      # This converts `wmic os get architecture` output to a normal standard
+      # https://msdn.microsoft.com/en-us/library/aa394373(VS.85).aspx
+      arch_map = {
+        0 => 'i386',
+        1 => 'mips',
+        2 => 'alpha',
+        3 => 'powerpc',
+        5 => 'arm',
+        6 => 'ia64',
+        9 => 'x86_64',
+      }
+
+      # The value of `wmic cpu get architecture` is always a number between 0-9
+      arch_number = sys_info[:Architecture].to_i
+      arch_map[arch_number]
+    end
   end
 end

data/lib/train/version.rb

@@ -3,5 +3,5 @@
 # Author:: Dominik Richter (<dominik.richter@gmail.com>)
 
 module Train
-  VERSION = '0.19.1'.freeze
+  VERSION = '0.20.0'.freeze
 end

data/test/unit/extras/command_wrapper_test.rb

@@ -16,47 +16,95 @@ describe 'linux command' do
     backend
   }
 
-  it 'wraps commands in sudo' do
-    lc = cls.new(backend, { sudo: true })
-    lc.run(cmd).must_equal "sudo #{cmd}"
-  end
+  describe 'sudo wrapping' do
+    it 'wraps commands in sudo' do
+      lc = cls.new(backend, { sudo: true })
+      lc.run(cmd).must_equal "sudo #{cmd}"
+    end
 
-  it 'doesnt wrap commands in sudo if user == root' do
-    lc = cls.new(backend, { sudo: true, user: 'root' })
-    lc.run(cmd).must_equal cmd
-  end
+    it 'doesnt wrap commands in sudo if user == root' do
+      lc = cls.new(backend, { sudo: true, user: 'root' })
+      lc.run(cmd).must_equal cmd
+    end
 
-  it 'wraps commands in sudo with all options' do
-    opts = rand.to_s
-    lc = cls.new(backend, { sudo: true, sudo_options: opts })
-    lc.run(cmd).must_equal "sudo #{opts} #{cmd}"
-  end
+    it 'wraps commands in sudo with all options' do
+      opts = rand.to_s
+      lc = cls.new(backend, { sudo: true, sudo_options: opts })
+      lc.run(cmd).must_equal "sudo #{opts} #{cmd}"
+    end
 
-  it 'runs commands in sudo with password' do
-    pw = rand.to_s
-    lc = cls.new(backend, { sudo: true, sudo_password: pw })
-    bpw = Base64.strict_encode64(pw + "\n")
-    lc.run(cmd).must_equal "echo #{bpw} | base64 --decode | sudo -S #{cmd}"
-  end
+    it 'runs commands in sudo with password' do
+      pw = rand.to_s
+      lc = cls.new(backend, { sudo: true, sudo_password: pw })
+      bpw = Base64.strict_encode64(pw + "\n")
+      lc.run(cmd).must_equal "echo #{bpw} | base64 --decode | sudo -S #{cmd}"
+    end
 
-  it 'wraps commands in sudo_command instead of sudo' do
-    sudo_command = rand.to_s
-    lc = cls.new(backend, { sudo: true, sudo_command: sudo_command })
-    lc.run(cmd).must_equal "#{sudo_command} #{cmd}"
-  end
+    it 'wraps commands in sudo_command instead of sudo' do
+      sudo_command = rand.to_s
+      lc = cls.new(backend, { sudo: true, sudo_command: sudo_command })
+      lc.run(cmd).must_equal "#{sudo_command} #{cmd}"
+    end
+
+    it 'wraps commands in sudo_command with all options' do
+      opts = rand.to_s
+      sudo_command = rand.to_s
+      lc = cls.new(backend, { sudo: true, sudo_command: sudo_command, sudo_options: opts })
+      lc.run(cmd).must_equal "#{sudo_command} #{opts} #{cmd}"
+    end
 
-  it 'wraps commands in sudo_command with all options' do
-    opts = rand.to_s
-    sudo_command = rand.to_s
-    lc = cls.new(backend, { sudo: true, sudo_command: sudo_command, sudo_options: opts })
-    lc.run(cmd).must_equal "#{sudo_command} #{opts} #{cmd}"
+    it 'runs commands in sudo_command with password' do
+      pw = rand.to_s
+      sudo_command = rand.to_s
+      lc = cls.new(backend, { sudo: true, sudo_command: sudo_command, sudo_password: pw })
+      bpw = Base64.strict_encode64(pw + "\n")
+      lc.run(cmd).must_equal "echo #{bpw} | base64 --decode | #{sudo_command} -S #{cmd}"
+    end
   end
 
-  it 'runs commands in sudo_command with password' do
-    pw = rand.to_s
-    sudo_command = rand.to_s
-    lc = cls.new(backend, { sudo: true, sudo_command: sudo_command, sudo_password: pw })
-    bpw = Base64.strict_encode64(pw + "\n")
-    lc.run(cmd).must_equal "echo #{bpw} | base64 --decode | #{sudo_command} -S #{cmd}"
+  describe 'shell wrapping' do
+    it 'wraps commands in a default shell with login' do
+      lc = cls.new(backend, { shell: true, shell_options: '--login' })
+      bcmd = Base64.strict_encode64(cmd)
+      lc.run(cmd).must_equal "echo #{bcmd} | base64 --decode | $SHELL --login"
+    end
+
+    it 'wraps sudo commands in a default shell with login' do
+      lc = cls.new(backend, { sudo: true, shell: true, shell_options: '--login' })
+      bcmd = Base64.strict_encode64("sudo #{cmd}")
+      lc.run(cmd).must_equal "echo #{bcmd} | base64 --decode | $SHELL --login"
+    end
+
+    it 'wraps sudo commands and sudo passwords in a default shell with login' do
+      pw = rand.to_s
+      lc = cls.new(backend, { sudo: true, sudo_password: pw, shell: true, shell_options: '--login' })
+      bpw = Base64.strict_encode64(pw + "\n")
+      bcmd = Base64.strict_encode64("echo #{bpw} | base64 --decode | sudo -S #{cmd}")
+      lc.run(cmd).must_equal "echo #{bcmd} | base64 --decode | $SHELL --login"
+      p bcmd
+    end
+
+    it 'wraps commands in a default shell when shell is true' do
+      lc = cls.new(backend, { shell: true })
+      bcmd = Base64.strict_encode64(cmd)
+      lc.run(cmd).must_equal "echo #{bcmd} | base64 --decode | $SHELL"
+    end
+
+    it 'doesnt wrap commands in a shell when shell is false' do
+      lc = cls.new(backend, { shell: false })
+      lc.run(cmd).must_equal cmd
+    end
+
+    it 'wraps commands in a `shell` instead of default shell' do
+      lc = cls.new(backend, { shell: true, shell_command: '/bin/bash' })
+      bcmd = Base64.strict_encode64(cmd)
+      lc.run(cmd).must_equal "echo #{bcmd} | base64 --decode | /bin/bash"
+    end
+
+    it 'wraps commands in a default shell with login' do
+      lc = cls.new(backend, { shell: true, shell_command: '/bin/bash', shell_options: '--login' })
+      bcmd = Base64.strict_encode64(cmd)
+      lc.run(cmd).must_equal "echo #{bcmd} | base64 --decode | /bin/bash --login"
+    end
   end
 end

data/test/unit/extras/os_detect_windows_test.rb

@@ -17,6 +17,7 @@ describe 'os_detect_windows' do
       detector = OsDetectWindowsTester.new
       detector.backend.mock_command('cmd /c ver', "\r\nMicrosoft Windows [Version 6.3.9600]\r\n", '', 0)
       detector.backend.mock_command('wmic os get * /format:list',"\r\r\nBuildNumber=9600\r\r\nCaption=Microsoft Windows Server 2012 R2 Standard\r\r\nOSArchitecture=64-bit\r\r\nVersion=6.3.9600\r\r\n" , '', 0)
+      detector.backend.mock_command('wmic cpu get architecture /format:list',"\r\r\nArchitecture=9\r\r\n" , '', 0)
       detector
     }
 
@@ -24,7 +25,7 @@ describe 'os_detect_windows' do
       detector.detect_windows
       detector.platform[:family].must_equal('windows')
       detector.platform[:name].must_equal('Windows Server 2012 R2 Standard')
-      detector.platform[:arch].must_equal('64-bit')
+      detector.platform[:arch].must_equal('x86_64')
       detector.platform[:release].must_equal('6.3.9600')
     end
   end
@@ -34,6 +35,7 @@ describe 'os_detect_windows' do
       detector = OsDetectWindowsTester.new
       detector.backend.mock_command('cmd /c ver', "\r\nMicrosoft Windows [Version 6.1.7601]\r\n", '', 0)
       detector.backend.mock_command('wmic os get * /format:list',"\r\r\nBuildNumber=7601\r\r\nCaption=Microsoft Windows Server 2008 R2 Standard \r\r\nOSArchitecture=64-bit\r\r\nVersion=6.1.7601\r\r\n" , '', 0)
+      detector.backend.mock_command('wmic cpu get architecture /format:list',"\r\r\nArchitecture=9\r\r\n" , '', 0)
       detector
     }
 
@@ -41,7 +43,7 @@ describe 'os_detect_windows' do
       detector.detect_windows
       detector.platform[:family].must_equal('windows')
       detector.platform[:name].must_equal('Windows Server 2008 R2 Standard')
-      detector.platform[:arch].must_equal('64-bit')
+      detector.platform[:arch].must_equal('x86_64')
       detector.platform[:release].must_equal('6.1.7601')
     end
   end
@@ -51,6 +53,7 @@ describe 'os_detect_windows' do
       detector = OsDetectWindowsTester.new
       detector.backend.mock_command('cmd /c ver', "\r\nMicrosoft Windows [Version 6.1.7601]\r\n", '', 0)
       detector.backend.mock_command('wmic os get * /format:list',"\r\r\nBuildNumber=7601\r\r\nCaption=Microsoft Windows 7 Enterprise \r\r\nOSArchitecture=32-bit\r\r\nVersion=6.1.7601\r\r\n\r\r\n" , '', 0)
+      detector.backend.mock_command('wmic cpu get architecture /format:list',"\r\r\nArchitecture=0\r\r\n" , '', 0)
       detector
     }
 
@@ -58,7 +61,7 @@ describe 'os_detect_windows' do
       detector.detect_windows
       detector.platform[:family].must_equal('windows')
       detector.platform[:name].must_equal('Windows 7 Enterprise')
-      detector.platform[:arch].must_equal('32-bit')
+      detector.platform[:arch].must_equal('i386')
       detector.platform[:release].must_equal('6.1.7601')
     end
   end
@@ -68,6 +71,7 @@ describe 'os_detect_windows' do
       detector = OsDetectWindowsTester.new
       detector.backend.mock_command('cmd /c ver', "\r\nMicrosoft Windows [Version 10.0.10240]\r\n", '', 0)
       detector.backend.mock_command('wmic os get * /format:list',"\r\r\nBuildNumber=10240\r\r\nCaption=Microsoft Windows 10 Pro\r\r\nOSArchitecture=64-bit\r\r\nVersion=10.0.10240\r\r\n\r\r\n" , '', 0)
+      detector.backend.mock_command('wmic cpu get architecture /format:list',"\r\r\nArchitecture=9\r\r\n" , '', 0)
       detector
     }
 
@@ -75,7 +79,7 @@ describe 'os_detect_windows' do
       detector.detect_windows
       detector.platform[:family].must_equal('windows')
       detector.platform[:name].must_equal('Windows 10 Pro')
-      detector.platform[:arch].must_equal('64-bit')
+      detector.platform[:arch].must_equal('x86_64')
       detector.platform[:release].must_equal('10.0.10240')
     end
   end
@@ -84,7 +88,8 @@ describe 'os_detect_windows' do
     let(:detector) {
       detector = OsDetectWindowsTester.new
       detector.backend.mock_command('cmd /c ver', "\r\nMicrosoft Windows [Version 4.10.1998]\r\n", '', 0)
-      detector.backend.mock_command('wmic os get * /format:list', nil , '', 1)
+      detector.backend.mock_command('wmic os get * /format:list', nil, '', 1)
+      detector.backend.mock_command('wmic cpu get architecture /format:list', nil, '', 1)
       detector
     }
 

data/test/windows/local_test.rb

@@ -24,7 +24,7 @@ describe 'windows local command' do
     os[:name].must_equal 'Windows Server 2012 R2 Datacenter'
     os[:family].must_equal "windows"
     os[:release].must_equal '6.3.9600'
-    os[:arch].must_equal '64-bit'
+    os[:arch].must_equal 'x86_64'
   end
 
   it 'run echo test' do

data/test/windows/winrm_test.rb

@@ -30,7 +30,7 @@ describe 'windows winrm command' do
     os[:name].must_equal 'Windows Server 2012 R2 Datacenter'
     os[:family].must_equal 'windows'
     os[:release].must_equal '6.3.9600'
-    os[:arch].must_equal '64-bit'
+    os[:arch].must_equal 'x86_64'
   end
 
   it 'run echo test' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: train
 version: !ruby/object:Gem::Version
-  version: 0.19.1
+  version: 0.20.0
 platform: ruby
 authors:
 - Dominik Richter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-16 00:00:00.000000000 Z
+date: 2016-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json