train 0.29.2 → 0.30.0

data/lib/train/transports/ssh_connection.rb

@@ -55,67 +55,6 @@ class Train::Transports::SSH
       @session = nil
     end
 
-    def os
-      @os ||= OS.new(self)
-    end
-
-    def file(path)
-      @files[path] ||= \
-        if os.aix?
-          Train::File::Remote::Aix.new(self, path)
-        elsif os.solaris?
-          Train::File::Remote::Unix.new(self, path)
-        elsif os[:name] == 'qnx'
-          Train::File::Remote::Qnx.new(self, path)
-        else
-          Train::File::Remote::Linux.new(self, path)
-        end
-    end
-
-    # (see Base::Connection#run_command)
-    def run_command(cmd)
-      stdout = stderr = ''
-      exit_status = nil
-      cmd.dup.force_encoding('binary') if cmd.respond_to?(:force_encoding)
-      logger.debug("[SSH] #{self} (#{cmd})")
-
-      session.open_channel do |channel|
-        # wrap commands if that is configured
-        cmd = @cmd_wrapper.run(cmd) unless @cmd_wrapper.nil?
-
-        if @transport_options[:pty]
-          channel.request_pty do |_ch, success|
-            fail Train::Transports::SSHPTYFailed, 'Requesting PTY failed' unless success
-          end
-        end
-
-        channel.exec(cmd) do |_, success|
-          abort 'Couldn\'t execute command on SSH.' unless success
-
-          channel.on_data do |_, data|
-            stdout += data
-          end
-
-          channel.on_extended_data do |_, _type, data|
-            stderr += data
-          end
-
-          channel.on_request('exit-status') do |_, data|
-            exit_status = data.read_long
-          end
-
-          channel.on_request('exit-signal') do |_, data|
-            exit_status = data.read_long
-          end
-        end
-      end
-      @session.loop
-
-      CommandResult.new(stdout, stderr, exit_status)
-    rescue Net::SSH::Exception => ex
-      raise Train::Transports::SSHFailed, "SSH command failed (#{ex.message})"
-    end
-
     # (see Base::Connection#login_command)
     def login_command
       level = logger.debug? ? 'VERBOSE' : 'ERROR'
@@ -225,6 +164,61 @@ class Train::Transports::SSH
       retry
     end
 
+    def file_via_connection(path)
+      if os.aix?
+        Train::File::Remote::Aix.new(self, path)
+      elsif os.solaris?
+        Train::File::Remote::Unix.new(self, path)
+      elsif os[:name] == 'qnx'
+        Train::File::Remote::Qnx.new(self, path)
+      else
+        Train::File::Remote::Linux.new(self, path)
+      end
+    end
+
+    def run_command_via_connection(cmd)
+      stdout = stderr = ''
+      exit_status = nil
+      cmd.dup.force_encoding('binary') if cmd.respond_to?(:force_encoding)
+      logger.debug("[SSH] #{self} (#{cmd})")
+
+      session.open_channel do |channel|
+        # wrap commands if that is configured
+        cmd = @cmd_wrapper.run(cmd) unless @cmd_wrapper.nil?
+
+        if @transport_options[:pty]
+          channel.request_pty do |_ch, success|
+            fail Train::Transports::SSHPTYFailed, 'Requesting PTY failed' unless success
+          end
+        end
+
+        channel.exec(cmd) do |_, success|
+          abort 'Couldn\'t execute command on SSH.' unless success
+
+          channel.on_data do |_, data|
+            stdout += data
+          end
+
+          channel.on_extended_data do |_, _type, data|
+            stderr += data
+          end
+
+          channel.on_request('exit-status') do |_, data|
+            exit_status = data.read_long
+          end
+
+          channel.on_request('exit-signal') do |_, data|
+            exit_status = data.read_long
+          end
+        end
+      end
+      @session.loop
+
+      CommandResult.new(stdout, stderr, exit_status)
+    rescue Net::SSH::Exception => ex
+      raise Train::Transports::SSHFailed, "SSH command failed (#{ex.message})"
+    end
+
     # Returns a connection session, or establishes one when invoked the
     # first time.
     #
@@ -247,11 +241,5 @@ class Train::Transports::SSH
       options_to_print[:password] = '<hidden>' if options_to_print.key?(:password)
       "#{@username}@#{@hostname}<#{options_to_print.inspect}>"
     end
-
-    class OS < OSCommon
-      def initialize(backend)
-        super(backend)
-      end
-    end
   end
 end

data/lib/train/transports/winrm_connection.rb

@@ -46,26 +46,6 @@ class Train::Transports::WinRM
       @session = nil
     end
 
-    def os
-      @os ||= OS.new(self)
-    end
-
-    def file(path)
-      @files[path] ||= Train::File::Remote::Windows.new(self, path)
-    end
-
-    def run_command(command)
-      return if command.nil?
-      logger.debug("[WinRM] #{self} (#{command})")
-      out = ''
-
-      response = session.run(command) do |stdout, _|
-        out << stdout if stdout
-      end
-
-      CommandResult.new(out, response.stderr, response.exitcode)
-    end
-
     # (see Base::Connection#login_command)
     def login_command
       case RbConfig::CONFIG['host_os']
@@ -111,6 +91,22 @@ class Train::Transports::WinRM
 
     PING_COMMAND = "Write-Host '[WinRM] Established\n'".freeze
 
+    def file_via_connection(path)
+      Train::File::Remote::Windows.new(self, path)
+    end
+
+    def run_command_via_connection(command)
+      return if command.nil?
+      logger.debug("[WinRM] #{self} (#{command})")
+      out = ''
+
+      response = session.run(command) do |stdout, _|
+        out << stdout if stdout
+      end
+
+      CommandResult.new(out, response.stderr, response.exitcode)
+    end
+
     # Create a local RDP document and return it
     #
     # @param opts [Hash] configuration options
@@ -193,11 +189,5 @@ class Train::Transports::WinRM
       options_to_print[:password] = '<hidden>' if options_to_print.key?(:password)
       "#{@username}@#{@hostname}<#{options_to_print.inspect}>"
     end
-
-    class OS < OSCommon
-      def initialize(backend)
-        super(backend, { family: 'windows' })
-      end
-    end
   end
 end

data/lib/train/version.rb

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

data/test/unit/file/remote/linux_test.rb

@@ -7,14 +7,14 @@ describe Train::File::Remote::Linux do
   let(:cls) { Train::File::Remote::Linux }
   let(:backend) {
     backend = Train::Transports::Mock.new.connection
-    backend.mock_os({ family: 'linux' })
+    backend.mock_os({ name: 'linux', family: 'unix' })
     backend
   }  
 
   def mock_stat(args, out, err = '', code = 0)
     backend.mock_command(
       "stat #{args} 2>/dev/null --printf '%s\n%f\n%U\n%u\n%G\n%g\n%X\n%Y\n%C'",
-      out, err, code,
+      out, err, code
     )
   end
 

data/test/unit/platforms/detect/os_common_test.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+require 'helper'
+
+class OsDetectLinuxTester
+  attr_reader :platform
+  include Train::Platforms::Detect::Helpers::OSCommon
+
+  def initialize
+    @platform = {}
+  end
+end
+
+describe 'os_common' do
+  let(:detector) { OsDetectLinuxTester.new }
+
+  describe 'winrm? check' do
+    it 'return winrm? true' do
+      require 'train/transports/winrm'
+      be = Train::Transports::WinRM::Connection.new(nil)
+      detector.instance_variable_set(:@backend, be)
+      detector.winrm?.must_equal(true)
+    end
+
+    it 'return winrm? false' do
+      be = mock('Backend')
+      detector.instance_variable_set(:@backend, be)
+      detector.winrm?.must_equal(false)
+    end
+  end
+
+  describe 'unix file contents' do
+    it 'return new file contents' do
+      be = mock('Backend')
+      output = mock('Output', exit_status: 0)
+      output.expects(:stdout).returns('test')
+      be.stubs(:run_command).with('test -f /etc/fstab && cat /etc/fstab').returns(output)
+      detector.instance_variable_set(:@backend, be)
+      detector.instance_variable_set(:@files, {})
+      detector.unix_file_contents('/etc/fstab').must_equal('test')
+    end
+
+    it 'return new file contents cached' do
+      be = mock('Backend')
+      detector.instance_variable_set(:@backend, be)
+      detector.instance_variable_set(:@files, { '/etc/profile' => 'test' })
+      detector.unix_file_contents('/etc/profile').must_equal('test')
+    end
+  end
+
+  describe 'unix file exist?' do
+    it 'file does exist' do
+      be = mock('Backend')
+      be.stubs(:run_command).with('test -f /etc/test').returns(mock('Output', exit_status: 0))
+      detector.instance_variable_set(:@backend, be)
+      detector.unix_file_exist?('/etc/test').must_equal(true)
+    end
+  end
+
+  describe '#detect_linux_arch' do
+    it 'uname m call' do
+      be = mock('Backend')
+      be.stubs(:run_command).with('uname -m').returns(mock('Output', stdout: "x86_64\n"))
+      detector.instance_variable_set(:@backend, be)
+      detector.instance_variable_set(:@uname, {})
+      detector.unix_uname_m.must_equal('x86_64')
+    end
+
+    it 'uname s call' do
+      be = mock('Backend')
+      be.stubs(:run_command).with('uname -s').returns(mock('Output', stdout: "linux"))
+      detector.instance_variable_set(:@backend, be)
+      detector.instance_variable_set(:@uname, {})
+      detector.unix_uname_s.must_equal('linux')
+    end
+
+    it 'uname r call' do
+      be = mock('Backend')
+      be.stubs(:run_command).with('uname -r').returns(mock('Output', stdout: "17.0.0\n"))
+      detector.instance_variable_set(:@backend, be)
+      detector.instance_variable_set(:@uname, {})
+      detector.unix_uname_r.must_equal('17.0.0')
+    end
+  end
+end

data/test/unit/platforms/detect/os_linux_test.rb

@@ -0,0 +1,124 @@
+# encoding: utf-8
+
+require 'helper'
+require 'train/transports/mock'
+
+class OsDetectLinuxTester
+  include Train::Platforms::Detect::Helpers::OSCommon
+end
+
+describe 'os_linux' do
+  let(:detector) { OsDetectLinuxTester.new }
+
+  describe 'redhatish_platform cleaner' do
+    it 'normal redhat' do
+      detector.redhatish_platform('Red Hattter').must_equal('redhat')
+    end
+
+    it 'custom redhat' do
+      detector.redhatish_platform('Centos Pro 11').must_equal('centos')
+    end
+  end
+
+  describe 'redhatish_version cleaner' do
+    it 'normal rawhide' do
+      detector.redhatish_version('18 (Rawhide) Pro').must_equal('18 (rawhide)')
+    end
+
+    it 'normal linux' do
+      detector.redhatish_version('derived from Ubuntu Linux 11').must_equal('11')
+    end
+  end
+
+  describe 'lsb parse' do
+    it 'lsb config' do
+      lsb = "DISTRIB_ID=Ubuntu\nDISTRIB_RELEASE=14.06\nDISTRIB_CODENAME=xenial"
+      expect = { :id=>'Ubuntu', :release=>'14.06', :codename=>'xenial' }
+      detector.lsb_config(lsb).must_equal(expect)
+    end
+
+    it 'lsb releasel' do
+      lsb = "Distributor ID: Ubuntu\nRelease: 14.06\nCodename: xenial"
+      expect = { :id=>'Ubuntu', :release=>'14.06', :codename=>'xenial' }
+      detector.lsb_release(lsb).must_equal(expect)
+    end
+  end
+
+  describe '#linux_os_release' do
+    describe 'when no os-release data is available' do
+      it 'returns nil' do
+        detector.expects(:unix_file_contents).with('/etc/os-release').returns(nil)
+        detector.linux_os_release.must_be_nil
+      end
+    end
+  end
+
+  describe 'when os-release data exists with no CISCO_RELEASE_INFO' do
+    let(:os_release) { { 'KEY1' => 'VALUE1' } }
+
+    it 'returns a correct hash' do
+      detector.expects(:unix_file_contents).with('/etc/os-release').returns('os-release data')
+      detector.expects(:parse_os_release_info).with('os-release data').returns(os_release)
+      detector.linux_os_release['KEY1'].must_equal('VALUE1')
+    end
+  end
+
+  describe 'when os-release data exists with CISCO_RELEASE_INFO' do
+    let(:os_release)    { { 'KEY1' => 'VALUE1', 'CISCO_RELEASE_INFO' => 'cisco_file' } }
+    let(:cisco_release) { { 'KEY1' => 'NEWVALUE1', 'KEY2' => 'VALUE2' } }
+
+    it 'returns a correct hash' do
+      detector.expects(:unix_file_contents).with('/etc/os-release').returns('os-release data')
+      detector.expects(:unix_file_contents).with('cisco_file').returns('cisco data')
+      detector.expects(:parse_os_release_info).with('os-release data').returns(os_release)
+      detector.expects(:parse_os_release_info).with('cisco data').returns(cisco_release)
+
+      os_info = detector.linux_os_release
+      os_info['KEY1'].must_equal('NEWVALUE1')
+      os_info['KEY2'].must_equal('VALUE2')
+    end
+  end
+
+  describe '#parse_os_release_info' do
+    describe 'when nil is supplied' do
+      it 'returns an empty hash' do
+        detector.parse_os_release_info(nil).must_equal({})
+      end
+    end
+
+    describe 'when unexpectedly-formatted data is supplied' do
+      let(:data) do
+        <<-EOL
+blah blah
+no good data here
+        EOL
+      end
+
+      it 'returns an empty hash' do
+        detector.parse_os_release_info(nil).must_equal({})
+      end
+    end
+
+    describe 'when properly-formatted data is supplied' do
+      let(:data) do
+        <<-EOL
+KEY1=value1
+KEY2=
+KEY3=value3
+KEY4="value4 with spaces"
+KEY5="value5 with a = sign"
+        EOL
+      end
+
+      it 'parses the data correctly' do
+        parsed_data = detector.parse_os_release_info(data)
+
+        parsed_data['KEY1'].must_equal('value1')
+        parsed_data.key?('KEY2').must_equal(false)
+        parsed_data['KEY3'].must_equal('value3')
+        parsed_data['KEY4'].must_equal('value4 with spaces')
+        parsed_data['KEY5'].must_equal('value5 with a = sign')
+      end
+    end
+  end
+end

data/test/unit/{extras/os_detect_windows_test.rb → platforms/detect/os_windows_test.rb}

@@ -1,8 +1,11 @@
-require 'train/extras'
+# encoding: utf-8
+
+require 'helper'
+require 'train/transports/mock'
 
 class OsDetectWindowsTester
   attr_reader :platform, :backend
-  include Train::Extras::DetectWindows
+  include Train::Platforms::Detect::Helpers::Windows
 
   def initialize
     @platform = {}