puppet 0.25.5 → 2.6.0

data/lib/puppet/provider/file/win32.rb

@@ -0,0 +1,74 @@
+Puppet::Type.type(:file).provide :microsoft_windows do
+  desc "Uses Microsoft Windows functionality to manage file's users and rights."
+
+  confine :feature => :microsoft_windows
+
+  include Puppet::Util::Warnings
+
+  require 'sys/admin' if Puppet.features.microsoft_windows?
+
+  def id2name(id)
+    return id.to_s if id.is_a?(Symbol)
+    return nil if id > Puppet[:maximum_uid].to_i
+    # should translate ID numbers to usernames
+    id
+  end
+
+  def insync?(current, should)
+    return true unless should
+
+    should.each do |value|
+      if value =~ /^\d+$/
+        uid = Integer(value)
+      elsif value.is_a?(String)
+        fail "Could not find user #{value}" unless uid = uid(value)
+      else
+        uid = value
+      end
+
+      return true if uid == current
+    end
+
+    unless Puppet.features.root?
+      warnonce "Cannot manage ownership unless running as root"
+      return true
+    end
+
+    false
+  end
+
+  # Determine if the user is valid, and if so, return the UID
+  def validuser?(value)
+    info "Is '#{value}' a valid user?"
+    return 0
+    begin
+      number = Integer(value)
+      return number
+    rescue ArgumentError
+      number = nil
+    end
+    (number = uid(value)) && number
+  end
+
+  def retrieve(resource)
+    unless stat = resource.stat(false)
+      return :absent
+    end
+
+    currentvalue = stat.uid
+
+    # On OS X, files that are owned by -2 get returned as really
+    # large UIDs instead of negative ones.  This isn't a Ruby bug,
+    # it's an OS X bug, since it shows up in perl, too.
+    if currentvalue > Puppet[:maximum_uid].to_i
+      self.warning "Apparently using negative UID (#{currentvalue}) on a platform that does not consistently handle them"
+      currentvalue = :silly
+    end
+
+    currentvalue
+  end
+
+  def sync(path, links, should)
+    info("should set '%s'%%owner to '%s'" % [path, should])
+  end
+end

data/lib/puppet/provider/group/directoryservice.rb

@@ -15,12 +15,12 @@
 require 'puppet/provider/nameservice/directoryservice'
 
 Puppet::Type.type(:group).provide :directoryservice, :parent => Puppet::Provider::NameService::DirectoryService do
-    desc "Group management using DirectoryService on OS X.
+  desc "Group management using DirectoryService on OS X.
 
-    "
+  "
 
-    commands :dscl => "/usr/bin/dscl"
-    confine :operatingsystem => :darwin
-    defaultfor :operatingsystem => :darwin
-    has_feature :manages_members
+  commands :dscl => "/usr/bin/dscl"
+  confine :operatingsystem => :darwin
+  defaultfor :operatingsystem => :darwin
+  has_feature :manages_members
 end

data/lib/puppet/provider/group/groupadd.rb

@@ -1,31 +1,29 @@
 require 'puppet/provider/nameservice/objectadd'
 
 Puppet::Type.type(:group).provide :groupadd, :parent => Puppet::Provider::NameService::ObjectAdd do
-    desc "Group management via ``groupadd`` and its ilk.
+  desc "Group management via ``groupadd`` and its ilk.
 
-    The default for most platforms
+  The default for most platforms
 
-    "
+  "
 
-    commands :add => "groupadd", :delete => "groupdel", :modify => "groupmod"
+  commands :add => "groupadd", :delete => "groupdel", :modify => "groupmod"
 
-    verify :gid, "GID must be an integer" do |value|
-        value.is_a? Integer
-    end
+  verify :gid, "GID must be an integer" do |value|
+    value.is_a? Integer
+  end
 
-    def addcmd
-        cmd = [command(:add)]
-        if gid = @resource.should(:gid)
-            unless gid == :absent
-                cmd << flag(:gid) << gid
-            end
-        end
-        if @resource.allowdupe?
-            cmd << "-o"
-        end
-        cmd << @resource[:name]
-
-        return cmd
+  def addcmd
+    cmd = [command(:add)]
+    if gid = @resource.should(:gid)
+      unless gid == :absent
+        cmd << flag(:gid) << gid
+      end
     end
+    cmd << "-o" if @resource.allowdupe?
+    cmd << @resource[:name]
+
+    cmd
+  end
 end
 

data/lib/puppet/provider/group/ldap.rb

@@ -1,50 +1,47 @@
 require 'puppet/provider/ldap'
 
 Puppet::Type.type(:group).provide :ldap, :parent => Puppet::Provider::Ldap do
-    desc "Group management via ``ldap``.
-
-    This provider requires that you have valid values for all of the
-    ldap-related settings, including ``ldapbase``.  You will also almost
-    definitely need settings for ``ldapuser`` and ``ldappassword``, so that
-    your clients can write to ldap.
-
-    Note that this provider will automatically generate a GID for you if you do
-    not specify one, but it is a potentially expensive operation, as it
-    iterates across all existing groups to pick the appropriate next one.
-
-    "
-
-    confine :true => Puppet.features.ldap?, :false => (Puppet[:ldapuser] == "")
-
-    # We're mapping 'members' here because we want to make it
-    # easy for the ldap user provider to manage groups.  This
-    # way it can just use the 'update' method in the group manager,
-    # whereas otherwise it would need to replicate that code.
-    manages(:posixGroup).at("ou=Groups").and.maps :name => :cn, :gid => :gidNumber, :members => :memberUid
-
-    # Find the next gid after the current largest gid.
-    provider = self
-    manager.generates(:gidNumber).with do
-        largest = 500
-        if existing = provider.manager.search
-                existing.each do |hash|
-                next unless value = hash[:gid]
-                num = value[0].to_i
-                if num > largest
-                    largest = num
-                end
-            end
-        end
-        largest + 1
+  desc "Group management via ``ldap``.
+
+  This provider requires that you have valid values for all of the
+  ldap-related settings, including ``ldapbase``.  You will also almost
+  definitely need settings for ``ldapuser`` and ``ldappassword``, so that
+  your clients can write to ldap.
+
+  Note that this provider will automatically generate a GID for you if you do
+  not specify one, but it is a potentially expensive operation, as it
+  iterates across all existing groups to pick the appropriate next one.
+
+  "
+
+  confine :true => Puppet.features.ldap?, :false => (Puppet[:ldapuser] == "")
+
+  # We're mapping 'members' here because we want to make it
+  # easy for the ldap user provider to manage groups.  This
+  # way it can just use the 'update' method in the group manager,
+  # whereas otherwise it would need to replicate that code.
+  manages(:posixGroup).at("ou=Groups").and.maps :name => :cn, :gid => :gidNumber, :members => :memberUid
+
+  # Find the next gid after the current largest gid.
+  provider = self
+  manager.generates(:gidNumber).with do
+    largest = 500
+    if existing = provider.manager.search
+        existing.each do |hash|
+        next unless value = hash[:gid]
+        num = value[0].to_i
+        largest = num if num > largest
+      end
     end
+    largest + 1
+  end
 
-    # Convert a group name to an id.
-    def self.name2id(group)
-        return nil unless result = manager.search("cn=%s" % group) and result.length > 0
+  # Convert a group name to an id.
+  def self.name2id(group)
+    return nil unless result = manager.search("cn=#{group}") and result.length > 0
 
-        # Only use the first result.
-        group = result[0]
-        gid = group[:gid][0]
-        return gid
-    end
+    # Only use the first result.
+    group = result[0]
+    gid = group[:gid][0]
+  end
 end

data/lib/puppet/provider/group/pw.rb

@@ -1,34 +1,34 @@
 require 'puppet/provider/nameservice/pw'
 
 Puppet::Type.type(:group).provide :pw, :parent => Puppet::Provider::NameService::PW do
-    desc "Group management via ``pw``.
+  desc "Group management via ``pw``.
 
-    Only works on FreeBSD.
+  Only works on FreeBSD.
 
-    "
+  "
 
-    commands :pw => "/usr/sbin/pw"
-    defaultfor :operatingsystem => :freebsd
+  commands :pw => "/usr/sbin/pw"
+  defaultfor :operatingsystem => :freebsd
 
-    verify :gid, "GID must be an integer" do |value|
-        value.is_a? Integer
-    end
+  verify :gid, "GID must be an integer" do |value|
+    value.is_a? Integer
+  end
 
-    def addcmd
-        cmd = [command(:pw), "groupadd", @resource[:name]]
-        if gid = @resource.should(:gid)
-            unless gid == :absent
-                cmd << flag(:gid) << gid
-            end
-        end
-
-        # Apparently, contrary to the man page, groupadd does
-        # not accept -o.
-        #if @parent[:allowdupe] == :true
-        #    cmd << "-o"
-        #end
-
-        return cmd
+  def addcmd
+    cmd = [command(:pw), "groupadd", @resource[:name]]
+    if gid = @resource.should(:gid)
+      unless gid == :absent
+        cmd << flag(:gid) << gid
+      end
     end
+
+    # Apparently, contrary to the man page, groupadd does
+    # not accept -o.
+    #if @parent[:allowdupe] == :true
+    #    cmd << "-o"
+    #end
+
+    cmd
+  end
 end
 

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

@@ -4,69 +4,70 @@ hosts = nil
 case Facter.value(:operatingsystem)
 when "Solaris"; hosts = "/etc/inet/hosts"
 else
-    hosts = "/etc/hosts"
+  hosts = "/etc/hosts"
 end
 
-Puppet::Type.type(:host).provide(:parsed,
-    :parent => Puppet::Provider::ParsedFile,
-    :default_target => hosts,
-    :filetype => :flat
-) do
-    confine :exists => hosts
 
-    text_line :comment, :match => /^#/
-    text_line :blank, :match => /^\s*$/
+      Puppet::Type.type(:host).provide(
+        :parsed,
+  :parent => Puppet::Provider::ParsedFile,
+  :default_target => hosts,
+        
+  :filetype => :flat
+) do
+  confine :exists => hosts
 
-    record_line :parsed, :fields => %w{ip name host_aliases},
-        :optional => %w{host_aliases},
-        :rts => true do |line|
-        hash = {}
-        if line.sub!(/^(\S+)\s+(\S+)\s*/, '')
-            hash[:ip] = $1
-            hash[:name] = $2
+  text_line :comment, :match => /^#/
+  text_line :blank, :match => /^\s*$/
 
-            unless line == ""
-                line.sub!(/\s*/, '')
-                line.sub!(/^([^#]+)\s*/) do |value|
-                    aliases = $1
-                    unless aliases =~ /^\s*$/
-                        hash[:host_aliases] = aliases.split(/\s+/)
-                    end
+  record_line :parsed, :fields => %w{ip name host_aliases},
+    :optional => %w{host_aliases},
+    :rts => true do |line|
+    hash = {}
+    if line.sub!(/^(\S+)\s+(\S+)\s*/, '')
+      hash[:ip] = $1
+      hash[:name] = $2
 
-                    ""
-                end
-            end
-        else
-            raise Puppet::Error, "Could not match '%s'" % line
-        end
+      if line.empty?
+        hash[:host_aliases] = []
+      else
+        line.sub!(/\s*/, '')
+        line.sub!(/^([^#]+)\s*/) do |value|
+          aliases = $1
+          unless aliases =~ /^\s*$/
+            hash[:host_aliases] = aliases.split(/\s+/)
+          end
 
-        if hash[:host_aliases] == ""
-            hash.delete(:host_aliases)
+          ""
         end
-
-        return hash
+      end
+    else
+      raise Puppet::Error, "Could not match '#{line}'"
     end
 
-    # Convert the current object into a host-style string.
-    def self.to_line(hash)
-        return super unless hash[:record_type] == :parsed
-        [:ip, :name].each do |n|
-            unless hash[n] and hash[n] != :absent
-                raise ArgumentError, "%s is a required attribute for hosts" % n
-            end
-        end
+    hash[:host_aliases] = [] if hash[:host_aliases] == ""
 
-        str = "%s\t%s" % [hash[:ip], hash[:name]]
+    return hash
+  end
 
-        if hash.include? :host_aliases
-            if hash[:host_aliases].is_a? Array
-                str += "\t%s" % hash[:host_aliases].join("\t")
-            else
-                raise ArgumentError, "Host aliases must be specified as an array"
-            end
-        end
+  # Convert the current object into a host-style string.
+  def self.to_line(hash)
+    return super unless hash[:record_type] == :parsed
+    [:ip, :name].each do |n|
+      raise ArgumentError, "#{n} is a required attribute for hosts" unless hash[n] and hash[n] != :absent
+    end
 
-        str
+    str = "#{hash[:ip]}\t#{hash[:name]}"
+
+    if hash.include? :host_aliases and !hash[:host_aliases].empty?
+      if hash[:host_aliases].is_a? Array
+        str += "\t#{hash[:host_aliases].join("\t")}"
+      else
+        raise ArgumentError, "Host aliases must be specified as an array"
+      end
     end
+
+    str
+  end
 end
 

data/lib/puppet/provider/ldap.rb

@@ -2,134 +2,132 @@ require 'puppet/provider'
 
 # The base class for LDAP providers.
 class Puppet::Provider::Ldap < Puppet::Provider
-    require 'puppet/util/ldap/manager'
-
-    class << self
-        attr_reader :manager
+  require 'puppet/util/ldap/manager'
+
+  class << self
+    attr_reader :manager
+  end
+
+  # Look up all instances at our location.  Yay.
+  def self.instances
+    return [] unless list = manager.search
+
+    list.collect { |entry| new(entry) }
+  end
+
+  # Specify the ldap manager for this provider, which is
+  # used to figure out how we actually interact with ldap.
+  def self.manages(*args)
+    @manager = Puppet::Util::Ldap::Manager.new
+    @manager.manages(*args)
+
+    # Set up our getter/setter methods.
+    mk_resource_methods
+    @manager
+  end
+
+  # Query all of our resources from ldap.
+  def self.prefetch(resources)
+    resources.each do |name, resource|
+      if result = manager.find(name)
+        result[:ensure] = :present
+        resource.provider = new(result)
+      else
+        resource.provider = new(:ensure => :absent)
+      end
     end
-
-    # Look up all instances at our location.  Yay.
-    def self.instances
-        return [] unless list = manager.search
-
-        list.collect { |entry| new(entry) }
+  end
+
+  def manager
+    self.class.manager
+  end
+
+  def create
+    @property_hash[:ensure] = :present
+    self.class.resource_type.validproperties.each do |property|
+      if val = resource.should(property)
+        @property_hash[property] = val
+      end
     end
-
-    # Specify the ldap manager for this provider, which is
-    # used to figure out how we actually interact with ldap.
-    def self.manages(*args)
-        @manager = Puppet::Util::Ldap::Manager.new
-        @manager.manages(*args)
-
-        # Set up our getter/setter methods.
-        mk_resource_methods
-        return @manager
+  end
+
+  def delete
+    @property_hash[:ensure] = :absent
+  end
+
+  def exists?
+    @property_hash[:ensure] != :absent
+  end
+
+  # Apply our changes to ldap, yo.
+  def flush
+    # Just call the manager's update() method.
+    @property_hash.delete(:groups)
+    @ldap_properties.delete(:groups)
+    manager.update(name, ldap_properties, properties)
+    @property_hash.clear
+    @ldap_properties.clear
+  end
+
+  def initialize(*args)
+    raise(Puppet::DevError, "No LDAP Configuration defined for #{self.class}") unless self.class.manager
+    raise(Puppet::DevError, "Invalid LDAP Configuration defined for #{self.class}") unless self.class.manager.valid?
+    super
+
+    @property_hash = @property_hash.inject({}) do |result, ary|
+      param, values = ary
+
+      # Skip any attributes we don't manage.
+      next result unless self.class.resource_type.valid_parameter?(param)
+
+      paramclass = self.class.resource_type.attrclass(param)
+
+      unless values.is_a?(Array)
+        result[param] = values
+        next result
+      end
+
+      # Only use the first value if the attribute class doesn't manage
+      # arrays of values.
+      if paramclass.superclass == Puppet::Parameter or paramclass.array_matching == :first
+        result[param] = values[0]
+      else
+        result[param] = values
+      end
+      result
     end
 
-    # Query all of our resources from ldap.
-    def self.prefetch(resources)
-        resources.each do |name, resource|
-            if result = manager.find(name)
-                result[:ensure] = :present
-                resource.provider = new(result)
-            else
-                resource.provider = new(:ensure => :absent)
-            end
-        end
+    # Make a duplicate, so that we have a copy for comparison
+    # at the end.
+    @ldap_properties = @property_hash.dup
+  end
+
+  # Return the current state of ldap.
+  def ldap_properties
+    @ldap_properties.dup
+  end
+
+  # Return (and look up if necessary) the desired state.
+  def properties
+    if @property_hash.empty?
+      @property_hash = query || {:ensure => :absent}
+      @property_hash[:ensure] = :absent if @property_hash.empty?
     end
-
-    def manager
-        self.class.manager
+    @property_hash.dup
+  end
+
+  # Collect the current attributes from ldap.  Returns
+  # the results, but also stores the attributes locally,
+  # so we have something to compare against when we update.
+  # LAK:NOTE This is normally not used, because we rely on prefetching.
+  def query
+    # Use the module function.
+    unless attributes = manager.find(name)
+      @ldap_properties = {}
+      return nil
     end
 
-    def create
-        @property_hash[:ensure] = :present
-        self.class.resource_type.validproperties.each do |property|
-            if val = resource.should(property)
-                @property_hash[property] = val
-            end
-        end
-    end
-
-    def delete
-        @property_hash[:ensure] = :absent
-    end
-
-    def exists?
-        @property_hash[:ensure] != :absent
-    end
-
-    # Apply our changes to ldap, yo.
-    def flush
-        # Just call the manager's update() method.
-        @property_hash.delete(:groups)
-        @ldap_properties.delete(:groups)
-        manager.update(name, ldap_properties, properties)
-        @property_hash.clear
-        @ldap_properties.clear
-    end
-
-    def initialize(*args)
-        raise(Puppet::DevError, "No LDAP Configuration defined for %s" % self.class) unless self.class.manager
-        raise(Puppet::DevError, "Invalid LDAP Configuration defined for %s" % self.class) unless self.class.manager.valid?
-        super
-
-        @property_hash = @property_hash.inject({}) do |result, ary|
-            param, values = ary
-
-            # Skip any attributes we don't manage.
-            next result unless self.class.resource_type.validattr?(param)
-
-            paramclass = self.class.resource_type.attrclass(param)
-
-            unless values.is_a?(Array)
-                result[param] = values
-                next result
-            end
-
-            # Only use the first value if the attribute class doesn't manage
-            # arrays of values.
-            if paramclass.superclass == Puppet::Parameter or paramclass.array_matching == :first
-                result[param] = values[0]
-            else
-                result[param] = values
-            end
-            result
-        end
-
-        # Make a duplicate, so that we have a copy for comparison
-        # at the end.
-        @ldap_properties = @property_hash.dup
-    end
-
-    # Return the current state of ldap.
-    def ldap_properties
-        @ldap_properties.dup
-    end
-
-    # Return (and look up if necessary) the desired state.
-    def properties
-        if @property_hash.empty?
-            @property_hash = query || {:ensure => :absent}
-            if @property_hash.empty?
-                @property_hash[:ensure] = :absent
-            end
-        end
-        @property_hash.dup
-    end
-
-    # Collect the current attributes from ldap.  Returns
-    # the results, but also stores the attributes locally,
-    # so we have something to compare against when we update.
-    # LAK:NOTE This is normally not used, because we rely on prefetching.
-    def query
-        # Use the module function.
-        unless attributes = manager.find(name)
-            @ldap_properties = {}
-            return nil
-        end
-
-        @ldap_properties = attributes
-        return @ldap_properties.dup
-    end
+    @ldap_properties = attributes
+    @ldap_properties.dup
+  end
 end