puppet 0.25.5 → 2.6.0

data/lib/puppet/provider/mount.rb

@@ -6,50 +6,46 @@ require 'puppet'
 # A module just to store the mount/unmount methods.  Individual providers
 # still need to add the mount commands manually.
 module Puppet::Provider::Mount
-    # This only works when the mount point is synced to the fstab.
-    def mount
-        # Manually pass the mount options in, since some OSes *cough*OS X*cough* don't
-        # read from /etc/fstab but still want to use this type.
-        args = []
-        if self.options and self.options != :absent
-            args << "-o" << self.options
-        end
-        args << resource[:name]
+  # This only works when the mount point is synced to the fstab.
+  def mount
+    # Manually pass the mount options in, since some OSes *cough*OS X*cough* don't
+    # read from /etc/fstab but still want to use this type.
+    args = []
+    args << "-o" << self.options if self.options and self.options != :absent
+    args << resource[:name]
 
-        if respond_to?(:flush)
-            flush
-        end
-        mountcmd(*args)
-    end
+    flush if respond_to?(:flush)
+    mountcmd(*args)
+  end
 
-    def remount
-        info "Remounting"
-        if resource[:remounts] == :true
-            mountcmd "-o", "remount", resource[:name]
-        else
-            unmount()
-            mount()
-        end
+  def remount
+    info "Remounting"
+    if resource[:remounts] == :true
+      mountcmd "-o", "remount", resource[:name]
+    else
+      unmount
+      mount
     end
+  end
 
-    # This only works when the mount point is synced to the fstab.
-    def unmount
-        umount resource[:name]
-    end
+  # This only works when the mount point is synced to the fstab.
+  def unmount
+    umount resource[:name]
+  end
 
-    # Is the mount currently mounted?
-    def mounted?
-        platform = Facter.value("operatingsystem")
-        name = resource[:name]
-        mounts = mountcmd.split("\n").find do |line|
-            case platform
-            when "Darwin"
-                line =~ / on #{name} / or line =~ %r{ on /private/var/automount#{name}}
-            when "Solaris"
-                line =~ /^#{name} on /
-            else
-                line =~ / on #{name} /
-            end
-        end
+  # Is the mount currently mounted?
+  def mounted?
+    platform = Facter.value("operatingsystem")
+    name = resource[:name]
+    mounts = mountcmd.split("\n").find do |line|
+      case platform
+      when "Darwin"
+        line =~ / on #{name} / or line =~ %r{ on /private/var/automount#{name}}
+      when "Solaris"
+        line =~ /^#{name} on /
+      else
+        line =~ / on #{name} /
+      end
     end
+  end
 end

data/lib/puppet/provider/mount/parsed.rb

@@ -5,41 +5,43 @@ fstab = nil
 case Facter.value(:operatingsystem)
 when "Solaris"; fstab = "/etc/vfstab"
 else
-    fstab = "/etc/fstab"
+  fstab = "/etc/fstab"
 end
 
-Puppet::Type.type(:mount).provide(:parsed,
-    :parent => Puppet::Provider::ParsedFile,
-    :default_target => fstab,
-    :filetype => :flat
+
+      Puppet::Type.type(:mount).provide(
+        :parsed,
+  :parent => Puppet::Provider::ParsedFile,
+  :default_target => fstab,
+        
+  :filetype => :flat
 ) do
-    include Puppet::Provider::Mount
-    #confine :exists => fstab
+  include Puppet::Provider::Mount
+  #confine :exists => fstab
 
-    commands :mountcmd => "mount", :umount => "umount"
+  commands :mountcmd => "mount", :umount => "umount"
 
-    @platform = Facter["operatingsystem"].value
-    case @platform
-    when "Solaris"
-        @fields = [:device, :blockdevice, :name, :fstype, :pass, :atboot,
-               :options]
-    else
-        @fields = [:device, :name, :fstype, :options, :dump, :pass]
-        @fielddefaults = [ nil ] * 4 + [ "0", "2" ]
-    end
+  @platform = Facter["operatingsystem"].value
+  case @platform
+  when "Solaris"
+    @fields = [:device, :blockdevice, :name, :fstype, :pass, :atboot, :options]
+  else
+    @fields = [:device, :name, :fstype, :options, :dump, :pass]
+    @fielddefaults = [ nil ] * 4 + [ "0", "2" ]
+  end
 
-    text_line :comment, :match => /^\s*#/
-    text_line :blank, :match => /^\s*$/
+  text_line :comment, :match => /^\s*#/
+  text_line :blank, :match => /^\s*$/
 
-    optional_fields  = @fields - [:device, :name, :blockdevice]
-    mandatory_fields = @fields - optional_fields
+  optional_fields  = @fields - [:device, :name, :blockdevice]
+  mandatory_fields = @fields - optional_fields
 
-    # fstab will ignore lines that have fewer than the mandatory number of columns,
-    # so we should, too.
-    field_pattern = '(\s*(?>\S+))'
-    text_line :incomplete, :match => /^(?!#{field_pattern}{#{mandatory_fields.length}})/
+  # fstab will ignore lines that have fewer than the mandatory number of columns,
+  # so we should, too.
+  field_pattern = '(\s*(?>\S+))'
+  text_line :incomplete, :match => /^(?!#{field_pattern}{#{mandatory_fields.length}})/
 
-    record_line self.name, :fields => @fields, :separator => /\s+/, :joiner => "\t", :optional => optional_fields
+  record_line self.name, :fields => @fields, :separator => /\s+/, :joiner => "\t", :optional => optional_fields
 
 end
 

data/lib/puppet/provider/naginator.rb

@@ -7,54 +7,52 @@ require 'puppet/external/nagios'
 
 # The base class for all Naginator providers.
 class Puppet::Provider::Naginator < Puppet::Provider::ParsedFile
-    NAME_STRING = "## --PUPPET_NAME-- (called '_naginator_name' in the manifest)"
-    # Retrieve the associated class from Nagios::Base.
-    def self.nagios_type
-        unless defined?(@nagios_type) and @nagios_type
-            name = resource_type.name.to_s.sub(/^nagios_/, '')
-            unless @nagios_type = Nagios::Base.type(name.to_sym)
-                raise Puppet::DevError, "Could not find nagios type '%s'" % name
-            end
-
-            # And add our 'ensure' settings, since they aren't a part of
-            # Naginator by default
-            @nagios_type.send(:attr_accessor, :ensure, :target, :on_disk)
-        end
-        @nagios_type
+  NAME_STRING = "## --PUPPET_NAME-- (called '_naginator_name' in the manifest)"
+  # Retrieve the associated class from Nagios::Base.
+  def self.nagios_type
+    unless @nagios_type
+      name = resource_type.name.to_s.sub(/^nagios_/, '')
+      unless @nagios_type = Nagios::Base.type(name.to_sym)
+        raise Puppet::DevError, "Could not find nagios type '#{name}'"
+      end
+
+      # And add our 'ensure' settings, since they aren't a part of
+      # Naginator by default
+      @nagios_type.send(:attr_accessor, :ensure, :target, :on_disk)
     end
-
-    def self.parse(text)
-        begin
-            Nagios::Parser.new.parse(text.gsub(NAME_STRING, "_naginator_name"))
-        rescue => detail
-            raise Puppet::Error, "Could not parse configuration for %s: %s" % [resource_type.name, detail]
-        end
-    end
-
-    def self.to_file(records)
-        header + records.collect { |record| record.to_s }.join("\n").gsub("_naginator_name", NAME_STRING)
-    end
-
-    def self.skip_record?(record)
-        false
-    end
-
-    def self.valid_attr?(klass, attr_name)
-        nagios_type.parameters.include?(attr_name)
-    end
-
-    def initialize(resource = nil)
-        if resource.is_a?(Nagios::Base)
-            # We don't use a duplicate here, because some providers (ParsedFile, at least)
-            # use the hash here for later events.
-            @property_hash = resource
-        elsif resource
-            @resource = resource if resource
-            # LAK 2007-05-09: Keep the model stuff around for backward compatibility
-            @model = resource
-            @property_hash = self.class.nagios_type.new
-        else
-            @property_hash = self.class.nagios_type.new
-        end
+    @nagios_type
+  end
+
+  def self.parse(text)
+      Nagios::Parser.new.parse(text.gsub(NAME_STRING, "_naginator_name"))
+  rescue => detail
+      raise Puppet::Error, "Could not parse configuration for #{resource_type.name}: #{detail}"
+  end
+
+  def self.to_file(records)
+    header + records.collect { |record| record.to_s }.join("\n").gsub("_naginator_name", NAME_STRING)
+  end
+
+  def self.skip_record?(record)
+    false
+  end
+
+  def self.valid_attr?(klass, attr_name)
+    nagios_type.parameters.include?(attr_name)
+  end
+
+  def initialize(resource = nil)
+    if resource.is_a?(Nagios::Base)
+      # We don't use a duplicate here, because some providers (ParsedFile, at least)
+      # use the hash here for later events.
+      @property_hash = resource
+    elsif resource
+      @resource = resource if resource
+      # LAK 2007-05-09: Keep the model stuff around for backward compatibility
+      @model = resource
+      @property_hash = self.class.nagios_type.new
+    else
+      @property_hash = self.class.nagios_type.new
     end
+  end
 end

data/lib/puppet/provider/nameservice.rb

@@ -4,312 +4,270 @@ require 'puppet'
 # their backend, but they're pretty similar on the front-end.  This class
 # provides a way for them all to be as similar as possible.
 class Puppet::Provider::NameService < Puppet::Provider
-    class << self
-        def autogen_default(param)
-            if defined? @autogen_defaults
-                return @autogen_defaults[symbolize(param)]
-            else
-                return nil
-            end
-        end
+  class << self
+    def autogen_default(param)
+      defined?(@autogen_defaults) ? @autogen_defaults[symbolize(param)] : nil
+    end
 
-        def autogen_defaults(hash)
-            @autogen_defaults ||= {}
-            hash.each do |param, value|
-                @autogen_defaults[symbolize(param)] = value
-            end
-        end
+    def autogen_defaults(hash)
+      @autogen_defaults ||= {}
+      hash.each do |param, value|
+        @autogen_defaults[symbolize(param)] = value
+      end
+    end
 
-        def initvars
-            @checks = {}
-            super
-        end
+    def initvars
+      @checks = {}
+      super
+    end
 
-        def instances
-            objects = []
-            listbyname do |name|
-                objects << new(:name => name, :ensure => :present)
-            end
+    def instances
+      objects = []
+      listbyname do |name|
+        objects << new(:name => name, :ensure => :present)
+      end
 
-            objects
-        end
+      objects
+    end
 
-        def option(name, option)
-            name = name.intern if name.is_a? String
-            if defined? @options and @options.include? name and @options[name].include? option
-                return @options[name][option]
-            else
-                return nil
-            end
-        end
+    def option(name, option)
+      name = name.intern if name.is_a? String
+      (defined?(@options) and @options.include? name and @options[name].include? option) ? @options[name][option] : nil
+    end
 
-        def options(name, hash)
-            unless resource_type.validattr?(name)
-                raise Puppet::DevError, "%s is not a valid attribute for %s" %
-                    [name, resource_type.name]
-            end
-            @options ||= {}
-            @options[name] ||= {}
-
-            # Set options individually, so we can call the options method
-            # multiple times.
-            hash.each do |param, value|
-                @options[name][param] = value
-            end
-        end
+    def options(name, hash)
+      raise Puppet::DevError, "#{name} is not a valid attribute for #{resource_type.name}" unless resource_type.valid_parameter?(name)
+      @options ||= {}
+      @options[name] ||= {}
 
-        # List everything out by name.  Abstracted a bit so that it works
-        # for both users and groups.
-        def listbyname
-            names = []
-            Etc.send("set%sent" % section())
-            begin
-                while ent = Etc.send("get%sent" % section())
-                    names << ent.name
-                    if block_given?
-                        yield ent.name
-                    end
-                end
-            ensure
-                Etc.send("end%sent" % section())
-            end
-
-            return names
-        end
+      # Set options individually, so we can call the options method
+      # multiple times.
+      hash.each do |param, value|
+        @options[name][param] = value
+      end
+    end
 
-        def resource_type=(resource_type)
-            super
-            @resource_type.validproperties.each do |prop|
-                next if prop == :ensure
-                unless public_method_defined?(prop)
-                    define_method(prop) { get(prop) || :absent}
-                end
-                unless public_method_defined?(prop.to_s + "=")
-                    define_method(prop.to_s + "=") { |*vals| set(prop, *vals) }
-                end
-            end
+    # List everything out by name.  Abstracted a bit so that it works
+    # for both users and groups.
+    def listbyname
+      names = []
+      Etc.send("set#{section()}ent")
+      begin
+        while ent = Etc.send("get#{section()}ent")
+          names << ent.name
+          yield ent.name if block_given?
         end
+      ensure
+        Etc.send("end#{section()}ent")
+      end
 
-        # This is annoying, but there really aren't that many options,
-        # and this *is* built into Ruby.
-        def section
-            unless defined? @resource_type
-                raise Puppet::DevError,
-                    "Cannot determine Etc section without a resource type"
-
-            end
+      names
+    end
 
-            if @resource_type.name == :group
-                "gr"
-            else
-                "pw"
-            end
-        end
+    def resource_type=(resource_type)
+      super
+      @resource_type.validproperties.each do |prop|
+        next if prop == :ensure
+        define_method(prop) { get(prop) || :absent} unless public_method_defined?(prop)
+        define_method(prop.to_s + "=") { |*vals| set(prop, *vals) } unless public_method_defined?(prop.to_s + "=")
+      end
+    end
 
-        def validate(name, value)
-            name = name.intern if name.is_a? String
-            if @checks.include? name
-                block = @checks[name][:block]
-                unless block.call(value)
-                    raise ArgumentError, "Invalid value %s: %s" %
-                        [value, @checks[name][:error]]
-                end
-            end
-        end
+    # This is annoying, but there really aren't that many options,
+    # and this *is* built into Ruby.
+    def section
+      unless defined?(@resource_type)
+        raise Puppet::DevError,
+          "Cannot determine Etc section without a resource type"
 
-        def verify(name, error, &block)
-            name = name.intern if name.is_a? String
-            @checks[name] = {:error => error, :block => block}
-        end
+      end
 
-        private
+      if @resource_type.name == :group
+        "gr"
+      else
+        "pw"
+      end
+    end
 
-        def op(property)
-            @ops[property.name] || ("-" + property.name)
-        end
+    def validate(name, value)
+      name = name.intern if name.is_a? String
+      if @checks.include? name
+        block = @checks[name][:block]
+        raise ArgumentError, "Invalid value #{value}: #{@checks[name][:error]}" unless block.call(value)
+      end
     end
 
-    # Autogenerate a value.  Mostly used for uid/gid, but also used heavily
-    # with DirectoryServices, because DirectoryServices is stupid.
-    def autogen(field)
-        field = symbolize(field)
-        id_generators = {:user => :uid, :group => :gid}
-        if id_generators[@resource.class.name] == field
-            return autogen_id(field)
-        else
-            if value = self.class.autogen_default(field)
-                return value
-            elsif respond_to?("autogen_%s" % [field])
-                return send("autogen_%s" % field)
-            else
-                return nil
-            end
-        end
+    def verify(name, error, &block)
+      name = name.intern if name.is_a? String
+      @checks[name] = {:error => error, :block => block}
     end
 
-    # Autogenerate either a uid or a gid.  This is hard-coded: we can only
-    # generate one field type per class.
-    def autogen_id(field)
-        highest = 0
-
-        group = method = nil
-        case @resource.class.name
-        when :user; group = :passwd; method = :uid
-        when :group; group = :group; method = :gid
-        else
-            raise Puppet::DevError, "Invalid resource name %s" % resource
-        end
+    private
 
-        # Make sure we don't use the same value multiple times
-        if defined? @@prevauto
-            @@prevauto += 1
-        else
-            Etc.send(group) { |obj|
-                if obj.gid > highest
-                    unless obj.send(method) > 65000
-                        highest = obj.send(method)
-                    end
-                end
-            }
-
-            @@prevauto = highest + 1
-        end
-
-        return @@prevauto
+    def op(property)
+      @ops[property.name] || ("-#{property.name}")
+    end
+  end
+
+  # Autogenerate a value.  Mostly used for uid/gid, but also used heavily
+  # with DirectoryServices, because DirectoryServices is stupid.
+  def autogen(field)
+    field = symbolize(field)
+    id_generators = {:user => :uid, :group => :gid}
+    if id_generators[@resource.class.name] == field
+      return autogen_id(field)
+    else
+      if value = self.class.autogen_default(field)
+        return value
+      elsif respond_to?("autogen_#{field}")
+        return send("autogen_#{field}")
+      else
+        return nil
+      end
+    end
+  end
+
+  # Autogenerate either a uid or a gid.  This is hard-coded: we can only
+  # generate one field type per class.
+  def autogen_id(field)
+    highest = 0
+
+    group = method = nil
+    case @resource.class.name
+    when :user; group = :passwd; method = :uid
+    when :group; group = :group; method = :gid
+    else
+      raise Puppet::DevError, "Invalid resource name #{resource}"
     end
 
-    def create
-       if exists?
-            info "already exists"
-            # The object already exists
-            return nil
+    # Make sure we don't use the same value multiple times
+    if defined?(@@prevauto)
+      @@prevauto += 1
+    else
+      Etc.send(group) { |obj|
+        if obj.gid > highest
+          highest = obj.send(method) unless obj.send(method) > 65000
         end
+      }
 
-        begin
-            execute(self.addcmd)
-        rescue Puppet::ExecutionFailure => detail
-            raise Puppet::Error, "Could not create %s %s: %s" %
-                [@resource.class.name, @resource.name, detail]
-        end
+      @@prevauto = highest + 1
     end
 
-    def delete
-        unless exists?
-            info "already absent"
-            # the object already doesn't exist
-            return nil
-        end
+    @@prevauto
+  end
 
-        begin
-            execute(self.deletecmd)
-        rescue Puppet::ExecutionFailure => detail
-            raise Puppet::Error, "Could not delete %s %s: %s" %
-                [@resource.class.name, @resource.name, detail]
-        end
+  def create
+    if exists?
+      info "already exists"
+      # The object already exists
+      return nil
     end
 
-    def ensure
-        if exists?
-            :present
-        else
-            :absent
-        end
+    begin
+      execute(self.addcmd)
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error, "Could not create #{@resource.class.name} #{@resource.name}: #{detail}"
     end
+  end
 
-    # Does our object exist?
-    def exists?
-        if getinfo(true)
-            return true
-        else
-            return false
-        end
+  def delete
+    unless exists?
+      info "already absent"
+      # the object already doesn't exist
+      return nil
     end
 
-    # Retrieve a specific value by name.
-    def get(param)
-        if hash = getinfo(false)
-            return hash[param]
-        else
-            return nil
-        end
+    begin
+      execute(self.deletecmd)
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error, "Could not delete #{@resource.class.name} #{@resource.name}: #{detail}"
     end
+  end
 
-    # Retrieve what we can about our object
-    def getinfo(refresh)
-        if @objectinfo.nil? or refresh == true
-            @etcmethod ||= ("get" + self.class.section().to_s + "nam").intern
-            begin
-                @objectinfo = Etc.send(@etcmethod, @resource[:name])
-            rescue ArgumentError => detail
-                @objectinfo = nil
-            end
-        end
-
-        # Now convert our Etc struct into a hash.
-        if @objectinfo
-            return info2hash(@objectinfo)
-        else
-            return nil
-        end
+  def ensure
+    if exists?
+      :present
+    else
+      :absent
+    end
+  end
+
+  # Does our object exist?
+  def exists?
+    !!getinfo(true)
+  end
+
+  # Retrieve a specific value by name.
+  def get(param)
+    (hash = getinfo(false)) ? hash[param] : nil
+  end
+
+  # Retrieve what we can about our object
+  def getinfo(refresh)
+    if @objectinfo.nil? or refresh == true
+      @etcmethod ||= ("get" + self.class.section.to_s + "nam").intern
+      begin
+        @objectinfo = Etc.send(@etcmethod, @resource[:name])
+      rescue ArgumentError => detail
+        @objectinfo = nil
+      end
     end
 
-    # The list of all groups the user is a member of.  Different
-    # user mgmt systems will need to override this method.
-    def groups
-        groups = []
-
-        # Reset our group list
-        Etc.setgrent
+    # Now convert our Etc struct into a hash.
+    @objectinfo ? info2hash(@objectinfo) : nil
+  end
 
-        user = @resource[:name]
+  # The list of all groups the user is a member of.  Different
+  # user mgmt systems will need to override this method.
+  def groups
+    groups = []
 
-        # Now iterate across all of the groups, adding each one our
-        # user is a member of
-        while group = Etc.getgrent
-            members = group.mem
+    # Reset our group list
+    Etc.setgrent
 
-            if members.include? user
-                groups << group.name
-            end
-        end
+    user = @resource[:name]
 
-        # We have to close the file, so each listing is a separate
-        # reading of the file.
-        Etc.endgrent
+    # Now iterate across all of the groups, adding each one our
+    # user is a member of
+    while group = Etc.getgrent
+      members = group.mem
 
-        groups.join(",")
+      groups << group.name if members.include? user
     end
 
-    # Convert the Etc struct into a hash.
-    def info2hash(info)
-        hash = {}
-        self.class.resource_type.validproperties.each do |param|
-            method = posixmethod(param)
-            if info.respond_to? method
-                hash[param] = info.send(posixmethod(param))
-            end
-        end
+    # We have to close the file, so each listing is a separate
+    # reading of the file.
+    Etc.endgrent
+
+    groups.join(",")
+  end
 
-        return hash
+  # Convert the Etc struct into a hash.
+  def info2hash(info)
+    hash = {}
+    self.class.resource_type.validproperties.each do |param|
+      method = posixmethod(param)
+      hash[param] = info.send(posixmethod(param)) if info.respond_to? method
     end
 
-    def initialize(resource)
-        super
+    hash
+  end
 
-        @objectinfo = nil
-    end
+  def initialize(resource)
+    super
 
-    def set(param, value)
-        self.class.validate(param, value)
-        cmd = modifycmd(param, value)
-        unless cmd.is_a?(Array)
-            raise Puppet::DevError, "Nameservice command must be an array"
-        end
-        begin
-            execute(cmd)
-        rescue Puppet::ExecutionFailure => detail
-            raise Puppet::Error, "Could not set %s on %s[%s]: %s" % [param, @resource.class.name, @resource.name, detail]
-        end
+    @objectinfo = nil
+  end
+
+  def set(param, value)
+    self.class.validate(param, value)
+    cmd = modifycmd(param, value)
+    raise Puppet::DevError, "Nameservice command must be an array" unless cmd.is_a?(Array)
+    begin
+      execute(cmd)
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error, "Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}"
     end
+  end
 end