rouster 0.53 → 0.57

data/lib/rouster/tests.rb

@@ -44,7 +44,7 @@ class Rouster
     if raw.match(/No such file or directory/)
       res = nil
     elsif raw.match(/Permission denied/)
-      @log.info(sprintf('dir(%s) output[%s], try with sudo', dir, raw)) unless self.uses_sudo?
+      @logger.info(sprintf('dir(%s) output[%s], try with sudo', dir, raw)) unless self.uses_sudo?
       res = nil
     else
       res = parse_ls_string(raw)
@@ -120,7 +120,7 @@ class Rouster
     end
 
     if raw.match(/No such file or directory/)
-      @log.info(sprintf('is_file?(%s) output[%s], try with sudo', file, raw)) unless self.uses_sudo?
+      @logger.info(sprintf('is_file?(%s) output[%s], try with sudo', file, raw)) unless self.uses_sudo?
       res = nil
     elsif raw.match(/Permission denied/)
       res = nil
@@ -264,7 +264,7 @@ class Rouster
 
     if scp
       # download the file to a temporary directory
-      @log.warn('is_in_file? scp option not implemented yet')
+      @logger.warn('is_in_file? scp option not implemented yet')
     end
 
     begin
@@ -373,8 +373,8 @@ class Rouster
   # * RedHat
   # * Ubuntu
   def is_process_running?(name)
-    # TODO support other flavors - this will work on RHEL and OSX
-    # TODO do better validation than just grepping for a matching filename
+    # TODO support Solaris
+    # TODO do better validation than just grepping for a matching filename, start with removing 'grep' from output
     begin
 
       os = self.os_type()
@@ -467,6 +467,25 @@ class Rouster
     end
   end
 
+  ##
+  # is_symlink?
+  #
+  # uses file() to return boolean indicating whether parameter passed is a symlink
+  #
+  # parameters
+  # * <file> - path of filename to validate
+  def is_symlink?(file)
+    res = nil
+
+    begin
+      res = self.file(file)
+    rescue => e
+      return false
+    end
+
+    res.class.eql?(Hash) ? res[:symlink?] : false
+  end
+
   ##
   # is_user?
   #
@@ -579,17 +598,26 @@ class Rouster
     end
 
     res[:mode]  = mode
-    res[:name]  = tokens[-1] # TODO better here: this does not support files/dirs with spaces
     res[:owner] = tokens[2]
     res[:group] = tokens[3]
     res[:size]  = tokens[4]
 
     res[:directory?]  = tokens[0][0].chr.eql?('d')
     res[:file?]       = ! res[:directory?]
+    res[:symlink?]    = tokens[0][0].chr.eql?('l')
     res[:executable?] = [ tokens[0][3].chr.eql?('x'), tokens[0][6].chr.eql?('x'), tokens[0][9].chr.eql?('x') || tokens[0][9].chr.eql?('t') ]
     res[:writeable?]  = [ tokens[0][2].chr.eql?('w'), tokens[0][5].chr.eql?('w'), tokens[0][8].chr.eql?('w') ]
     res[:readable?]   = [ tokens[0][1].chr.eql?('r'), tokens[0][4].chr.eql?('r'), tokens[0][7].chr.eql?('r') ]
 
+    # TODO better here: this does not support files/dirs with spaces
+    if res[:symlink?]
+      # not sure if we should only be adding this value if we're a symlink, or adding it to all results and just using nil if not a link
+      res[:target] = tokens[-1]
+      res[:name]   = tokens[-3]
+    else
+      res[:name] = tokens[-1]
+    end
+
     res
   end
 

data/lib/rouster/vagrant.rb

@@ -0,0 +1,242 @@
+require sprintf('%s/../../%s', File.dirname(File.expand_path(__FILE__)), 'path_helper')
+
+## Vagrant specific (and related) methods
+
+class Rouster
+
+  ##
+  # vagrant
+  #
+  # abstraction layer to call vagrant faces
+  #
+  # parameters
+  # * <face> - vagrant face to call (include arguments)
+  def vagrant(face, sleep_time=10)
+    if self.is_passthrough?
+      @logger.warn(sprintf('calling [vagrant %s] on a passthrough host is a noop', face))
+      return nil
+    end
+
+    unless @vagrant_concurrency.eql?(true)
+      # TODO don't (ab|re)use variables
+      0.upto(@retries) do |try|
+        break if self.is_vagrant_running?().eql?(false)
+
+        sleep sleep_time # TODO log a message?
+      end
+    end
+
+    0.upto(@retries) do |try| # TODO should really be doing this with 'retry', but i think this code is actually cleaner
+      begin
+        return self._run(sprintf('cd %s; vagrant %s', File.dirname(@vagrantfile), face))
+      rescue
+        @logger.error(sprintf('failed vagrant command[%s], attempt[%s/%s]', face, try, retries)) if self.retries > 0
+        sleep sleep_time
+      end
+    end
+
+    raise InternalError.new(sprintf('failed to execute [%s], exitcode[%s], output[%s]', face, self.exitcode, self.get_output()))
+
+
+  end
+
+  ##
+  # up
+  # runs `vagrant up` from the Vagrantfile path
+  # if :sshtunnel is passed to the object during instantiation, the tunnel is created here as well
+  def up
+    @logger.info('up()')
+    self.vagrant(sprintf('up %s', @name))
+
+    @ssh_info = nil # in case the ssh-info has changed, a la destroy/rebuild
+    self.connect_ssh_tunnel() if @sshtunnel
+  end
+
+  ##
+  # destroy
+  # runs `vagrant destroy <name>` from the Vagrantfile path
+  def destroy
+    @logger.info('destroy()')
+    disconnect_ssh_tunnel
+    self.vagrant(sprintf('destroy -f %s', @name))
+  end
+
+  ##
+  # status
+  #
+  # runs `vagrant status <name>` from the Vagrantfile path
+  # parses the status and provider out of output, but only status is returned
+  def status
+    status = nil
+
+    if @cache_timeout
+      if @cache.has_key?(:status)
+        if (Time.now.to_i - @cache[:status][:time]) < @cache_timeout
+          @logger.debug(sprintf('using cached status[%s] from [%s]', @cache[:status][:status], @cache[:status][:time]))
+          return @cache[:status][:status]
+        end
+      end
+    end
+
+    @logger.info('status()')
+    self.vagrant(sprintf('status %s', @name))
+
+    # else case here (both for nil/non-matching output) is handled by non-0 exit code
+    output = self.get_output()
+    if output.nil?
+      if self.is_passthrough?()
+        status = 'running'
+      end
+    elsif output.match(/^#{@name}\s*(.*\s?\w+)\s\((.+)\)$/)
+      # vagrant 1.2+, $1 = status, $2 = provider
+      status = $1
+    elsif output.match(/^#{@name}\s+(.+)$/)
+      # vagrant 1.2-, $1 = status
+      status = $1
+    end
+
+    if @cache_timeout
+      @cache[:status] = Hash.new unless @cache[:status].class.eql?(Hash)
+      @cache[:status][:time] = Time.now.to_i
+      @cache[:status][:status] = status
+      @logger.debug(sprintf('caching status[%s] at [%s]', @cache[:status][:status], @cache[:status][:time]))
+    end
+
+    return status
+  end
+
+  ##
+  # suspend
+  #
+  # runs `vagrant suspend <name>` from the Vagrantfile path
+  def suspend
+    @logger.info('suspend()')
+    self.vagrant(sprintf('suspend %s', @name))
+    disconnect_ssh_tunnel() unless self.is_passthrough?()
+  end
+
+  ##
+  # is_vagrant_running?()
+  #
+  # returns true|false if a vagrant process is running on the host machine
+  #
+  # meant to be used to prevent race-y conditions when interacting with VirtualBox (potentially others, haven't tested)
+  def is_vagrant_running?
+    res = false
+
+    begin
+      # TODO would like to get the 2 -v greps into a single call..
+      raw = self._run("ps -ef | grep -v 'grep' | grep -v 'ssh' | grep '#{self.vagrantbinary}'")
+      res = true
+    rescue
+    end
+
+    @logger.debug(sprintf('is_vagrant_running?[%s]', res))
+    res
+  end
+
+  ##
+  # sandbox_available?
+  #
+  # returns true or false after attempting to find out if the sandbox
+  # subcommand is available
+  def sandbox_available?
+    if self.is_passthrough?
+      @logger.warn('sandbox* methods on a passthrough host is a noop')
+      return nil
+    end
+
+    if @cache.has_key?(:sandbox_available?)
+      @logger.debug(sprintf('using cached sandbox_available?[%s]', @cache[:sandbox_available?]))
+      return @cache[:sandbox_available?]
+    end
+
+    @logger.info('sandbox_available()')
+    begin
+      # at some point, vagrant changed its behavior on exit code here, so rescuing
+      self._run(sprintf('cd %s; vagrant', File.dirname(@vagrantfile))) # calling 'vagrant' without parameters to determine available faces
+    rescue
+    end
+
+    sandbox_available = false
+    if self.get_output().match(/^\s+sandbox$/)
+      sandbox_available = true
+    end
+
+    @cache[:sandbox_available?] = sandbox_available
+    @logger.debug(sprintf('caching sandbox_available?[%s]', @cache[:sandbox_available?]))
+    @logger.error('sandbox support is not available, please install the "sahara" gem first, https://github.com/jedi4ever/sahara') unless sandbox_available
+
+    return sandbox_available
+  end
+
+  ##
+  # sandbox_on
+  # runs `vagrant sandbox on` from the Vagrantfile path
+  def sandbox_on
+    if self.is_passthrough?
+      @logger.warn('sandbox* methods on a passthrough host is a noop')
+      return nil
+    end
+
+    if self.sandbox_available?
+      return self.vagrant(sprintf('sandbox on %s', @name))
+    else
+      raise ExternalError.new('sandbox plugin not installed')
+    end
+  end
+
+  ##
+  # sandbox_off
+  # runs `vagrant sandbox off` from the Vagrantfile path
+  def sandbox_off
+    if self.is_passthrough?
+      @logger.warn('sandbox* methods on a passthrough host is a noop')
+      return nil
+    end
+
+    if self.sandbox_available?
+      return self.vagrant(sprintf('sandbox off %s', @name))
+    else
+      raise ExternalError.new('sandbox plugin not installed')
+    end
+  end
+
+  ##
+  # sandbox_rollback
+  # runs `vagrant sandbox rollback` from the Vagrantfile path
+  def sandbox_rollback
+    if self.is_passthrough?
+      @logger.warn('sandbox* methods on a passthrough host is a noop')
+      return nil
+    end
+
+    if self.sandbox_available?
+      self.disconnect_ssh_tunnel
+      self.vagrant(sprintf('sandbox rollback %s', @name))
+      self.connect_ssh_tunnel
+    else
+      raise ExternalError.new('sandbox plugin not installed')
+    end
+  end
+
+  ##
+  # sandbox_commit
+  # runs `vagrant sandbox commit` from the Vagrantfile path
+  def sandbox_commit
+    if self.is_passthrough?
+      @logger.warn('sandbox* methods on a passthrough host is a noop')
+      return nil
+    end
+
+    if self.sandbox_available?
+      self.disconnect_ssh_tunnel
+      self.vagrant(sprintf('sandbox commit %s', @name))
+      self.connect_ssh_tunnel
+    else
+      raise ExternalError.new('sandbox plugin not installed')
+    end
+  end
+
+
+end

data/test/basic.rb

@@ -5,6 +5,9 @@ require 'rouster/puppet'
 require 'rouster/testing'
 require 'rouster/tests'
 
-p = Rouster.new(:name => 'app', :verbosity => 0)
+#a = Rouster.new(:name => 'app', :verbosity => 1, :vagrantfile => '../piab/Vagrantfile', :retries => 3)
+#p = Rouster.new(:name => 'ppm', :verbosity => 1, :vagrantfile => '../piab/Vagrantfile')
+#r = Rouster.new(:name => 'app', :verbosity => 1, :vagrantfile => 'Vagrantfile')
+l = Rouster.new(:name => 'local', :passthrough => { :type => :local }, :verbosity => 3)
 
 p 'DBGZ' if nil?

data/test/functional/deltas/test_get_crontab.rb

@@ -115,8 +115,29 @@ class TestDeltasGetCrontab < Test::Unit::TestCase
 
   end
 
+  def test_unhappy_duplicate_entries
+
+    res = nil
+
+    # do this in a saner way? crontab call is overwriting existing records
+    user = 'puppet'
+    tmp  = sprintf('/tmp/rouster.tmp.crontab.%s.%s.%s', user, Time.now.to_i, $$)
+    @app.run("echo '0 0 * * * echo #{user}' > #{tmp}")
+    @app.run("echo '5 5 * * * echo #{user}' >> #{tmp}")
+    @app.run("crontab -u #{user} #{tmp}")
+
+    assert_nothing_raised do
+      res = @app.get_crontab('puppet')
+    end
+
+    assert_equal(Hash, res.class)
+    assert(res.has_key?('echo puppet'))
+    assert(res.has_key?('echo puppet-duplicate.55***echopuppet'))
+
+  end
+
   def teardown
     @app = nil
   end
 
-end
+end

data/test/functional/deltas/test_get_services.rb

@@ -31,6 +31,12 @@ class TestDeltasGetServices < Test::Unit::TestCase
       assert(@allowed_states.member?(res[k]))
     end
 
+    # this isn't the best validation, but does prove a point - no nil keys/values
+    assert_nothing_raised do
+      res.keys.sort
+      res.values.sort
+    end
+
   end
 
   def test_happy_path_caching

data/test/functional/test_inspect.rb

@@ -21,7 +21,7 @@ class TestInspect < Test::Unit::TestCase
     assert_match(/status/, res)
     assert_match(/sudo\[true\]/, res)
     assert_match(/vagrantfile/, res)
-    assert_match(/verbosity\[4\]/, res)
+    assert_match(/verbosity console\[3\] \/ log\[2/, res)
   end
 
   def teardown

data/test/functional/test_is_file.rb

@@ -22,8 +22,9 @@ class TestIsFile < Test::Unit::TestCase
     @file_other_rwx = sprintf('%s/other', @dir_tmp)
     @file_644       = sprintf('%s/sixfourfour', @dir_tmp)
     @file_755       = sprintf('%s/sevenfivefive', @dir_tmp)
+    @symlink        = sprintf('%s/symlinking', @dir_tmp)
 
-    @files = [@file_user_rwx, @file_group_rwx, @file_other_rwx, @file_644, @file_755]
+    @files = [@file_user_rwx, @file_group_rwx, @file_other_rwx, @file_644, @file_755, @symlink]
   end
 
   def test_user
@@ -41,6 +42,8 @@ class TestIsFile < Test::Unit::TestCase
     assert_equal(false, @app.is_readable?(@file_user_rwx,   'o'))
     assert_equal(false, @app.is_writeable?(@file_user_rwx,  'o'))
     assert_equal(false, @app.is_executable?(@file_user_rwx, 'o'))
+
+    assert_equal(false, @app.is_symlink?(@file_755))
   end
 
   def test_group
@@ -58,6 +61,8 @@ class TestIsFile < Test::Unit::TestCase
     assert_equal(false, @app.is_readable?(@file_group_rwx,   'o'))
     assert_equal(false, @app.is_writeable?(@file_group_rwx,  'o'))
     assert_equal(false, @app.is_executable?(@file_group_rwx, 'o'))
+
+    assert_equal(false, @app.is_symlink?(@file_755))
   end
 
   def test_other
@@ -76,6 +81,7 @@ class TestIsFile < Test::Unit::TestCase
     assert_equal(true, @app.is_writeable?(@file_other_rwx,  'o'))
     assert_equal(true, @app.is_executable?(@file_other_rwx, 'o'))
 
+    assert_equal(false, @app.is_symlink?(@file_755))
   end
 
   def test_644
@@ -93,6 +99,8 @@ class TestIsFile < Test::Unit::TestCase
     assert_equal(true, @app.is_readable?(@file_644,    'o'))
     assert_equal(false, @app.is_writeable?(@file_644,  'o'))
     assert_equal(false, @app.is_executable?(@file_644, 'o'))
+
+    assert_equal(false, @app.is_symlink?(@file_755))
   end
 
   def test_755
@@ -110,6 +118,14 @@ class TestIsFile < Test::Unit::TestCase
     assert_equal(true, @app.is_readable?(@file_755,   'o'))
     assert_equal(false, @app.is_writeable?(@file_755, 'o'))
     assert_equal(true, @app.is_executable?(@file_755, 'o'))
+
+    assert_equal(false, @app.is_symlink?(@file_755))
+  end
+
+  def test_symlink
+    @app.run("ln -s /etc/hosts #{@symlink}")
+
+    assert_equal(true, @app.is_symlink?(@symlink))
   end
 
   def teardown