puppet 0.25.5 → 2.6.0

data/lib/puppet/util/pidlock.rb

@@ -1,68 +1,68 @@
 require 'fileutils'
 
 class Puppet::Util::Pidlock
-    attr_reader :lockfile
+  attr_reader :lockfile
 
-    def initialize(lockfile)
-        @lockfile = lockfile
-    end
+  def initialize(lockfile)
+    @lockfile = lockfile
+  end
 
-    def locked?
-        clear_if_stale
-        File.exists? @lockfile
-    end
+  def locked?
+    clear_if_stale
+    File.exists? @lockfile
+  end
 
-    def mine?
-        Process.pid == lock_pid
-    end
+  def mine?
+    Process.pid == lock_pid
+  end
 
-    def anonymous?
-        return false unless File.exists?(@lockfile)
-        File.read(@lockfile) == ""
-    end
+  def anonymous?
+    return false unless File.exists?(@lockfile)
+    File.read(@lockfile) == ""
+  end
 
-    def lock(opts = {})
-        opts = {:anonymous => false}.merge(opts)
+  def lock(opts = {})
+    opts = {:anonymous => false}.merge(opts)
 
-        if locked?
-            mine?
-        else
-            if opts[:anonymous]
-                File.open(@lockfile, 'w') { |fd| true }
-            else
-                File.open(@lockfile, "w") { |fd| fd.write(Process.pid) }
-            end
-            true
-        end
+    if locked?
+      mine?
+    else
+      if opts[:anonymous]
+        File.open(@lockfile, 'w') { |fd| true }
+      else
+        File.open(@lockfile, "w") { |fd| fd.write(Process.pid) }
+      end
+      true
     end
+  end
 
-    def unlock(opts = {})
-        opts = {:anonymous => false}.merge(opts)
+  def unlock(opts = {})
+    opts = {:anonymous => false}.merge(opts)
 
-        if mine? or (opts[:anonymous] and anonymous?)
-            File.unlink(@lockfile)
-            true
-        else
-            false
-        end
+    if mine? or (opts[:anonymous] and anonymous?)
+      File.unlink(@lockfile)
+      true
+    else
+      false
     end
+  end
 
-    private
-    def lock_pid
-        if File.exists? @lockfile
-            File.read(@lockfile).to_i
-        else
-            nil
-        end
+  private
+  def lock_pid
+    if File.exists? @lockfile
+      File.read(@lockfile).to_i
+    else
+      nil
     end
+  end
 
-    def clear_if_stale
-        return if lock_pid.nil?
+  def clear_if_stale
+    return if lock_pid.nil?
 
-        begin
-            Process.kill(0, lock_pid)
-        rescue Errno::ESRCH
-            File.unlink(@lockfile)
-        end
+    begin
+      Process.kill(0, lock_pid)
+    rescue Errno::ESRCH
+      File.unlink(@lockfile)
     end
+  end
 end

data/lib/puppet/util/posix.rb

@@ -1,137 +1,137 @@
 # Utility methods for interacting with POSIX objects; mostly user and group
 module Puppet::Util::POSIX
 
-    # Retrieve a field from a POSIX Etc object.  The id can be either an integer
-    # or a name.  This only works for users and groups.  It's also broken on
-    # some platforms, unfortunately, which is why we fall back to the other
-    # method search_posix_field in the gid and uid methods if a sanity check
-    # fails
-    def get_posix_field(space, field, id)
-        raise Puppet::DevError, "Did not get id from caller" unless id
+  # Retrieve a field from a POSIX Etc object.  The id can be either an integer
+  # or a name.  This only works for users and groups.  It's also broken on
+  # some platforms, unfortunately, which is why we fall back to the other
+  # method search_posix_field in the gid and uid methods if a sanity check
+  # fails
+  def get_posix_field(space, field, id)
+    raise Puppet::DevError, "Did not get id from caller" unless id
 
-        if id.is_a?(Integer)
-            if id > Puppet[:maximum_uid].to_i
-                Puppet.err "Tried to get %s field for silly id %s" % [field, id]
-                return nil
-            end
-            method = methodbyid(space)
-        else
-            method = methodbyname(space)
-        end
+    if id.is_a?(Integer)
+      if id > Puppet[:maximum_uid].to_i
+        Puppet.err "Tried to get #{field} field for silly id #{id}"
+        return nil
+      end
+      method = methodbyid(space)
+    else
+      method = methodbyname(space)
+    end
 
-        begin
-            return Etc.send(method, id).send(field)
-        rescue ArgumentError => detail
-            # ignore it; we couldn't find the object
-            return nil
-        end
+    begin
+      return Etc.send(method, id).send(field)
+    rescue ArgumentError => detail
+      # ignore it; we couldn't find the object
+      return nil
     end
+  end
 
-    # A degenerate method of retrieving name/id mappings.  The job of this method is
-    # to retrieve all objects of a certain type, search for a specific entry
-    # and then return a given field from that entry.
-    def search_posix_field(type, field, id)
-        idmethod = idfield(type)
-        integer = false
-        if id.is_a?(Integer)
-            integer = true
-            if id > Puppet[:maximum_uid].to_i
-                Puppet.err "Tried to get %s field for silly id %s" % [field, id]
-                return nil
-            end
-        end
+  # A degenerate method of retrieving name/id mappings.  The job of this method is
+  # to retrieve all objects of a certain type, search for a specific entry
+  # and then return a given field from that entry.
+  def search_posix_field(type, field, id)
+    idmethod = idfield(type)
+    integer = false
+    if id.is_a?(Integer)
+      integer = true
+      if id > Puppet[:maximum_uid].to_i
+        Puppet.err "Tried to get #{field} field for silly id #{id}"
+        return nil
+      end
+    end
 
-        Etc.send(type) do |object|
-            if integer and object.send(idmethod) == id
-                return object.send(field)
-            elsif object.name == id
-                return object.send(field)
-            end
-        end
+    Etc.send(type) do |object|
+      if integer and object.send(idmethod) == id
+        return object.send(field)
+      elsif object.name == id
+        return object.send(field)
+      end
+    end
 
-        # Apparently the group/passwd methods need to get reset; if we skip
-        # this call, then new users aren't found.
-        case type
-        when :passwd; Etc.send(:endpwent)
-        when :group; Etc.send(:endgrent)
-        end
-        return nil
+    # Apparently the group/passwd methods need to get reset; if we skip
+    # this call, then new users aren't found.
+    case type
+    when :passwd; Etc.send(:endpwent)
+    when :group; Etc.send(:endgrent)
     end
+    nil
+  end
 
-    # Determine what the field name is for users and groups.
-    def idfield(space)
-        case Puppet::Util.symbolize(space)
-        when :gr, :group; return :gid
-        when :pw, :user, :passwd; return :uid
-        else
-            raise ArgumentError.new("Can only handle users and groups")
-        end
+  # Determine what the field name is for users and groups.
+  def idfield(space)
+    case Puppet::Util.symbolize(space)
+    when :gr, :group; return :gid
+    when :pw, :user, :passwd; return :uid
+    else
+      raise ArgumentError.new("Can only handle users and groups")
     end
+  end
 
-    # Determine what the method is to get users and groups by id
-    def methodbyid(space)
-        case Puppet::Util.symbolize(space)
-        when :gr, :group; return :getgrgid
-        when :pw, :user, :passwd; return :getpwuid
-        else
-            raise ArgumentError.new("Can only handle users and groups")
-        end
+  # Determine what the method is to get users and groups by id
+  def methodbyid(space)
+    case Puppet::Util.symbolize(space)
+    when :gr, :group; return :getgrgid
+    when :pw, :user, :passwd; return :getpwuid
+    else
+      raise ArgumentError.new("Can only handle users and groups")
     end
+  end
 
-    # Determine what the method is to get users and groups by name
-    def methodbyname(space)
-        case Puppet::Util.symbolize(space)
-        when :gr, :group; return :getgrnam
-        when :pw, :user, :passwd; return :getpwnam
-        else
-            raise ArgumentError.new("Can only handle users and groups")
-        end
+  # Determine what the method is to get users and groups by name
+  def methodbyname(space)
+    case Puppet::Util.symbolize(space)
+    when :gr, :group; return :getgrnam
+    when :pw, :user, :passwd; return :getpwnam
+    else
+      raise ArgumentError.new("Can only handle users and groups")
     end
+  end
 
-    # Get the GID of a given group, provided either a GID or a name
-    def gid(group)
-        begin
-            group = Integer(group)
-        rescue ArgumentError
-            # pass
-        end
-        if group.is_a?(Integer)
-            return nil unless name = get_posix_field(:group, :name, group)
-            gid = get_posix_field(:group, :gid, name)
-            check_value = gid
-        else
-            return nil unless gid = get_posix_field(:group, :gid, group)
-            name = get_posix_field(:group, :name, gid)
-            check_value = name
-        end
-        if check_value != group
-            return search_posix_field(:group, :gid, group)
-        else
-            return gid
-        end
+  # Get the GID of a given group, provided either a GID or a name
+  def gid(group)
+    begin
+      group = Integer(group)
+    rescue ArgumentError
+      # pass
+    end
+    if group.is_a?(Integer)
+      return nil unless name = get_posix_field(:group, :name, group)
+      gid = get_posix_field(:group, :gid, name)
+      check_value = gid
+    else
+      return nil unless gid = get_posix_field(:group, :gid, group)
+      name = get_posix_field(:group, :name, gid)
+      check_value = name
+    end
+    if check_value != group
+      return search_posix_field(:group, :gid, group)
+    else
+      return gid
     end
+  end
 
-    # Get the UID of a given user, whether a UID or name is provided
-    def uid(user)
-        begin
-            user = Integer(user)
-        rescue ArgumentError
-            # pass
-        end
-        if user.is_a?(Integer)
-            return nil unless name = get_posix_field(:passwd, :name, user)
-            uid = get_posix_field(:passwd, :uid, name)
-            check_value = uid
-        else
-            return nil unless uid = get_posix_field(:passwd, :uid, user)
-            name = get_posix_field(:passwd, :name, uid)
-            check_value = name
-        end
-        if check_value != user
-            return search_posix_field(:passwd, :uid, user)
-        else
-            return uid
-        end
+  # Get the UID of a given user, whether a UID or name is provided
+  def uid(user)
+    begin
+      user = Integer(user)
+    rescue ArgumentError
+      # pass
+    end
+    if user.is_a?(Integer)
+      return nil unless name = get_posix_field(:passwd, :name, user)
+      uid = get_posix_field(:passwd, :uid, name)
+      check_value = uid
+    else
+      return nil unless uid = get_posix_field(:passwd, :uid, user)
+      name = get_posix_field(:passwd, :name, uid)
+      check_value = name
+    end
+    if check_value != user
+      return search_posix_field(:passwd, :uid, user)
+    else
+      return uid
     end
+  end
 end
 

data/lib/puppet/util/provider_features.rb

@@ -3,175 +3,167 @@ require 'puppet/util/methodhelper'
 require 'puppet/util/docs'
 require 'puppet/util'
 module Puppet::Util::ProviderFeatures
+  include Puppet::Util::Docs
+  # The class that models the features and handles checking whether the features
+  # are present.
+  class ProviderFeature
+    include Puppet::Util
+    include Puppet::Util::MethodHelper
     include Puppet::Util::Docs
-    # The class that models the features and handles checking whether the features
-    # are present.
-    class ProviderFeature
-        include Puppet::Util
-        include Puppet::Util::MethodHelper
-        include Puppet::Util::Docs
-        attr_accessor :name, :docs, :methods
-
-        # Are all of the requirements met?
-        def available?(obj)
-            if self.methods
-                if methods_available?(obj)
-                    return true
-                else
-                    return false
-                end
-            else
-                # In this case, the provider has to declare support for this
-                # feature, and that's been checked before we ever get to the
-                # method checks.
-                return false
-            end
-        end
-
-        def initialize(name, docs, hash)
-            self.name = symbolize(name)
-            self.docs = docs
-            hash = symbolize_options(hash)
-            set_options(hash)
-        end
-
-        private
-
-        # Are all of the required methods available?
-        def methods_available?(obj)
-            methods.each do |m|
-                if obj.is_a?(Class)
-                    return false unless obj.public_method_defined?(m)
-                else
-                    return false unless obj.respond_to?(m)
-                end
-            end
-            return true
-        end
+    attr_accessor :name, :docs, :methods
+
+    # Are all of the requirements met?
+    def available?(obj)
+      if self.methods
+        return !!methods_available?(obj)
+      else
+        # In this case, the provider has to declare support for this
+        # feature, and that's been checked before we ever get to the
+        # method checks.
+        return false
+      end
     end
 
-    # Define one or more features.  At a minimum, features require a name
-    # and docs, and at this point they should also specify a list of methods
-    # required to determine if the feature is present.
-    def feature(name, docs, hash = {})
-        @features ||= {}
-        raise(Puppet::DevError, "Feature %s is already defined" % name) if @features.include?(name)
-        begin
-            obj = ProviderFeature.new(name, docs, hash)
-            @features[obj.name] = obj
-        rescue ArgumentError => detail
-            error = ArgumentError.new(
-                "Could not create feature %s: %s" % [name, detail]
-            )
-            error.set_backtrace(detail.backtrace)
-            raise error
-        end
+    def initialize(name, docs, hash)
+      self.name = symbolize(name)
+      self.docs = docs
+      hash = symbolize_options(hash)
+      set_options(hash)
     end
 
-    # Return a hash of all feature documentation.
-    def featuredocs
-        str = ""
-        @features ||= {}
-        return nil if @features.empty?
-        names = @features.keys.sort { |a,b| a.to_s <=> b.to_s }
-        names.each do |name|
-            doc = @features[name].docs.gsub(/\n\s+/, " ")
-            str += "- **%s**: %s\n" % [name, doc]
-        end
+    private
 
-        if providers.length > 0
-            headers = ["Provider", names].flatten
-            data = {}
-            providers.each do |provname|
-                data[provname] = []
-                prov = provider(provname)
-                names.each do |name|
-                    if prov.feature?(name)
-                        data[provname] << "**X**"
-                    else
-                        data[provname] << ""
-                    end
-                end
-            end
-            str += doctable(headers, data)
+    # Are all of the required methods available?
+    def methods_available?(obj)
+      methods.each do |m|
+        if obj.is_a?(Class)
+          return false unless obj.public_method_defined?(m)
+        else
+          return false unless obj.respond_to?(m)
         end
-        str
+      end
+      true
+    end
+  end
+
+  # Define one or more features.  At a minimum, features require a name
+  # and docs, and at this point they should also specify a list of methods
+  # required to determine if the feature is present.
+  def feature(name, docs, hash = {})
+    @features ||= {}
+    raise(Puppet::DevError, "Feature #{name} is already defined") if @features.include?(name)
+    begin
+      obj = ProviderFeature.new(name, docs, hash)
+      @features[obj.name] = obj
+    rescue ArgumentError => detail
+      error = ArgumentError.new(
+        "Could not create feature #{name}: #{detail}"
+      )
+      error.set_backtrace(detail.backtrace)
+      raise error
+    end
+  end
+
+  # Return a hash of all feature documentation.
+  def featuredocs
+    str = ""
+    @features ||= {}
+    return nil if @features.empty?
+    names = @features.keys.sort { |a,b| a.to_s <=> b.to_s }
+    names.each do |name|
+      doc = @features[name].docs.gsub(/\n\s+/, " ")
+      str += "- **#{name}**: #{doc}\n"
     end
 
-    # Return a list of features.
-    def features
-        @features ||= {}
-        @features.keys
+    if providers.length > 0
+      headers = ["Provider", names].flatten
+      data = {}
+      providers.each do |provname|
+        data[provname] = []
+        prov = provider(provname)
+        names.each do |name|
+          if prov.feature?(name)
+            data[provname] << "**X**"
+          else
+            data[provname] << ""
+          end
+        end
+      end
+      str += doctable(headers, data)
     end
+    str
+  end
+
+  # Return a list of features.
+  def features
+    @features ||= {}
+    @features.keys
+  end
+
+  # Generate a module that sets up the boolean methods to test for given
+  # features.
+  def feature_module
+    unless defined?(@feature_module)
+      @features ||= {}
+      @feature_module = ::Module.new
+      const_set("FeatureModule", @feature_module)
+      features = @features
+      # Create a feature? method that can be passed a feature name and
+      # determine if the feature is present.
+      @feature_module.send(:define_method, :feature?) do |name|
+        method = name.to_s + "?"
+        return !!(respond_to?(method) and send(method))
+      end
+
+      # Create a method that will list all functional features.
+      @feature_module.send(:define_method, :features) do
+        return false unless defined?(features)
+        features.keys.find_all { |n| feature?(n) }.sort { |a,b|
+          a.to_s <=> b.to_s
+        }
+      end
+
+      # Create a method that will determine if a provided list of
+      # features are satisfied by the curred provider.
+      @feature_module.send(:define_method, :satisfies?) do |*needed|
+        ret = true
+        needed.flatten.each do |feature|
+          unless feature?(feature)
+            ret = false
+            break
+          end
+        end
+        ret
+      end
+
+      # Create a boolean method for each feature so you can test them
+      # individually as you might need.
+      @features.each do |name, feature|
+        method = name.to_s + "?"
+        @feature_module.send(:define_method, method) do
+          (is_a?(Class) ?  declared_feature?(name) : self.class.declared_feature?(name)) or feature.available?(self)
+        end
+      end
 
-    # Generate a module that sets up the boolean methods to test for given
-    # features.
-    def feature_module
-        unless defined? @feature_module
-            @features ||= {}
-            @feature_module = ::Module.new
-            const_set("FeatureModule", @feature_module)
-            features = @features
-            # Create a feature? method that can be passed a feature name and
-            # determine if the feature is present.
-            @feature_module.send(:define_method, :feature?) do |name|
-                method = name.to_s + "?"
-                if respond_to?(method) and send(method)
-                    return true
-                else
-                    return false
-                end
-            end
-
-            # Create a method that will list all functional features.
-            @feature_module.send(:define_method, :features) do
-                return false unless defined?(features)
-                features.keys.find_all { |n| feature?(n) }.sort { |a,b|
-                    a.to_s <=> b.to_s
-                }
-            end
-
-            # Create a method that will determine if a provided list of
-            # features are satisfied by the curred provider.
-            @feature_module.send(:define_method, :satisfies?) do |*needed|
-                ret = true
-                needed.flatten.each do |feature|
-                    unless feature?(feature)
-                        ret = false
-                        break
-                    end
-                end
-                ret
-            end
-
-            # Create a boolean method for each feature so you can test them
-            # individually as you might need.
-            @features.each do |name, feature|
-                method = name.to_s + "?"
-                @feature_module.send(:define_method, method) do
-                    (is_a?(Class) ?  declared_feature?(name) : self.class.declared_feature?(name)) or feature.available?(self)
-                end
-            end
-
-            # Allow the provider to declare that it has a given feature.
-            @feature_module.send(:define_method, :has_features) do |*names|
-                @declared_features ||= []
-                names.each do |name|
-                    name = symbolize(name)
-                    @declared_features << name
-                end
-            end
-            # Aaah, grammatical correctness
-            @feature_module.send(:alias_method, :has_feature, :has_features)
+      # Allow the provider to declare that it has a given feature.
+      @feature_module.send(:define_method, :has_features) do |*names|
+        @declared_features ||= []
+        names.each do |name|
+          name = symbolize(name)
+          @declared_features << name
         end
-        @feature_module
+      end
+      # Aaah, grammatical correctness
+      @feature_module.send(:alias_method, :has_feature, :has_features)
     end
+    @feature_module
+  end
 
-    # Return the actual provider feature instance.  Really only used for testing.
-    def provider_feature(name)
-        return nil unless defined?(@features)
+  # Return the actual provider feature instance.  Really only used for testing.
+  def provider_feature(name)
+    return nil unless defined?(@features)
 
-        @features[name]
-    end
+    @features[name]
+  end
 end