puppet 0.25.5 → 2.6.0

data/lib/puppet/provider/user/hpux.rb

@@ -1,30 +1,30 @@
 Puppet::Type.type(:user).provide :hpuxuseradd, :parent => :useradd do
-    desc "User management for hp-ux! Undocumented switch to special usermod because HP-UX regular usermod is TOO STUPID to change stuff while the user is logged in."
+  desc "User management for hp-ux! Undocumented switch to special usermod because HP-UX regular usermod is TOO STUPID to change stuff while the user is logged in."
 
-    defaultfor :operatingsystem => "hp-ux"
-    confine :operatingsystem => "hp-ux"
+  defaultfor :operatingsystem => "hp-ux"
+  confine :operatingsystem => "hp-ux"
 
-    commands :modify => "/usr/sam/lbin/usermod.sam", :delete => "/usr/sam/lbin/userdel.sam", :add => "/usr/sbin/useradd"
-    options :comment, :method => :gecos
-    options :groups, :flag => "-G"
-    options :home, :flag => "-d", :method => :dir
+  commands :modify => "/usr/sam/lbin/usermod.sam", :delete => "/usr/sam/lbin/userdel.sam", :add => "/usr/sbin/useradd"
+  options :comment, :method => :gecos
+  options :groups, :flag => "-G"
+  options :home, :flag => "-d", :method => :dir
 
-    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
 
-    verify :groups, "Groups must be comma-separated" do |value|
-        value !~ /\s/
-    end
+  verify :groups, "Groups must be comma-separated" do |value|
+    value !~ /\s/
+  end
 
-    has_features :manages_homedir, :allows_duplicates
+  has_features :manages_homedir, :allows_duplicates
 
-    def deletecmd
-        super.insert(1,"-F")
-    end
+  def deletecmd
+    super.insert(1,"-F")
+  end
 
-    def modifycmd(param,value)
-        super.insert(1,"-F")
-    end
+  def modifycmd(param,value)
+    super.insert(1,"-F")
+  end
 
 end

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

@@ -1,133 +1,129 @@
 require 'puppet/provider/ldap'
 
 Puppet::Type.type(:user).provide :ldap, :parent => Puppet::Provider::Ldap do
-    desc "User 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 UID for you if
-        you do not specify one, but it is a potentially expensive operation,
-        as it iterates across all existing users to pick the appropriate next
-        one."
-
-    confine :feature => :ldap, :false => (Puppet[:ldapuser] == "")
-
-    has_feature :manages_passwords
-
-    manages(:posixAccount, :person).at("ou=People").named_by(:uid).and.maps :name => :uid,
-        :password => :userPassword,
-        :comment => :cn,
-        :uid => :uidNumber,
-        :gid => :gidNumber,
-        :home => :homeDirectory,
-        :shell => :loginShell
-
-    # Use the last field of a space-separated array as
-    # the sn.  LDAP requires a surname, for some stupid reason.
-    manager.generates(:sn).from(:cn).with do |cn|
-        x = 1
-        cn[0].split(/\s+/)[-1]
+  desc "User 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 UID for you if
+    you do not specify one, but it is a potentially expensive operation,
+    as it iterates across all existing users to pick the appropriate next
+    one."
+
+  confine :feature => :ldap, :false => (Puppet[:ldapuser] == "")
+
+  has_feature :manages_passwords
+
+  manages(:posixAccount, :person).at("ou=People").named_by(:uid).and.maps :name => :uid,
+    :password => :userPassword,
+    :comment => :cn,
+    :uid => :uidNumber,
+    :gid => :gidNumber,
+    :home => :homeDirectory,
+    :shell => :loginShell
+
+  # Use the last field of a space-separated array as
+  # the sn.  LDAP requires a surname, for some stupid reason.
+  manager.generates(:sn).from(:cn).with do |cn|
+    x = 1
+    cn[0].split(/\s+/)[-1]
+  end
+
+  # Find the next uid after the current largest uid.
+  provider = self
+  manager.generates(:uidNumber).with do
+    largest = 500
+    if existing = provider.manager.search
+      existing.each do |hash|
+        next unless value = hash[:uid]
+        num = value[0].to_i
+        largest = num if num > largest
+      end
     end
-
-    # Find the next uid after the current largest uid.
-    provider = self
-    manager.generates(:uidNumber).with do
-        largest = 500
-        if existing = provider.manager.search
-            existing.each do |hash|
-                next unless value = hash[:uid]
-                num = value[0].to_i
-                if num > largest
-                    largest = num
-                end
-            end
-        end
-        largest + 1
+    largest + 1
+  end
+
+  # Convert our gid to a group name, if necessary.
+  def gid=(value)
+    value = group2id(value) unless [Fixnum, Bignum].include?(value.class)
+
+    @property_hash[:gid] = value
+  end
+
+  # Find all groups this user is a member of in ldap.
+  def groups
+    # We want to cache the current result, so we know if we
+    # have to remove old values.
+    unless @property_hash[:groups]
+      unless result = group_manager.search("memberUid=#{name}")
+        return @property_hash[:groups] = :absent
+      end
+
+      return @property_hash[:groups] = result.collect { |r| r[:name] }.sort.join(",")
     end
+    @property_hash[:groups]
+  end
 
-    # Convert our gid to a group name, if necessary.
-    def gid=(value)
-        unless [Fixnum, Bignum].include?(value.class)
-            value = group2id(value)
-        end
+  # Manage the list of groups this user is a member of.
+  def groups=(values)
+    should = values.split(",")
 
-        @property_hash[:gid] = value
+    if groups == :absent
+      is = []
+    else
+      is = groups.split(",")
     end
 
-    # Find all groups this user is a member of in ldap.
-    def groups
-        # We want to cache the current result, so we know if we
-        # have to remove old values.
-        unless @property_hash[:groups]
-            unless result = group_manager.search("memberUid=%s" % name)
-                return @property_hash[:groups] = :absent
-            end
+    modes = {}
+    [is, should].flatten.uniq.each do |group|
+      # Skip it when they're in both
+      next if is.include?(group) and should.include?(group)
 
-            return @property_hash[:groups] = result.collect { |r| r[:name] }.join(",")
-        end
-        return @property_hash[:groups]
-    end
+      # We're adding a group.
+      modes[group] = :add and next unless is.include?(group)
 
-    # Manage the list of groups this user is a member of.
-    def groups=(values)
-        should = values.split(",")
-
-        if groups() == :absent
-            is = []
-        else
-            is = groups().split(",")
-        end
+      # We're removing a group.
+      modes[group] = :remove and next unless should.include?(group)
+    end
 
-        modes = {}
-        [is, should].flatten.uniq.each do |group|
-            # Skip it when they're in both
-            next if is.include?(group) and should.include?(group)
+    modes.each do |group, form|
+      self.fail "Could not find ldap group #{group}" unless ldap_group = group_manager.find(group)
 
-            # We're adding a group.
-            modes[group] = :add and next unless is.include?(group)
+      current = ldap_group[:members]
 
-            # We're removing a group.
-            modes[group] = :remove and next unless should.include?(group)
+      if form == :add
+        if current.is_a?(Array) and ! current.empty?
+          new = current + [name]
+        else
+          new = [name]
         end
+      else
+        new = current - [name]
+        new = :absent if new.empty?
+      end
 
-        modes.each do |group, form|
-            self.fail "Could not find ldap group %s" % group unless ldap_group = group_manager.find(group)
-
-            current = ldap_group[:members]
-
-            if form == :add
-                if current.is_a?(Array) and ! current.empty?
-                    new = current + [name]
-                else
-                    new = [name]
-                end
-            else
-                new = current - [name]
-                new = :absent if new.empty?
-            end
-
-            group_manager.update(group, {:ensure => :present, :members => current}, {:ensure => :present, :members => new})
-        end
+      group_manager.update(group, {:ensure => :present, :members => current}, {:ensure => :present, :members => new})
     end
+  end
 
-    # Convert a gropu name to an id.
-    def group2id(group)
-        Puppet::Type.type(:group).provider(:ldap).name2id(group)
-    end
+  # Convert a gropu name to an id.
+  def group2id(group)
+    Puppet::Type.type(:group).provider(:ldap).name2id(group)
+  end
 
-    private
+  private
 
-    def group_manager
-        Puppet::Type.type(:group).provider(:ldap).manager
-    end
+  def group_manager
+    Puppet::Type.type(:group).provider(:ldap).manager
+  end
 
-    def group_properties(values)
-        if values.empty? or values == :absent
-            {:ensure => :present}
-        else
-            {:ensure => :present, :members => values}
-        end
+  def group_properties(values)
+    if values.empty? or values == :absent
+      {:ensure => :present}
+    else
+      {:ensure => :present, :members => values}
     end
+  end
 end

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

@@ -1,45 +1,41 @@
 require 'puppet/provider/nameservice/pw'
 
 Puppet::Type.type(:user).provide :pw, :parent => Puppet::Provider::NameService::PW do
-    desc "User management via ``pw`` on FreeBSD."
-
-    commands :pw => "pw"
-    has_features :manages_homedir, :allows_duplicates
-
-    defaultfor :operatingsystem => :freebsd
-
-    options :home, :flag => "-d", :method => :dir
-    options :comment, :method => :gecos
-    options :groups, :flag => "-G"
-
-    verify :gid, "GID must be an integer" do |value|
-        value.is_a? Integer
+  desc "User management via ``pw`` on FreeBSD."
+
+  commands :pw => "pw"
+  has_features :manages_homedir, :allows_duplicates
+
+  defaultfor :operatingsystem => :freebsd
+
+  options :home, :flag => "-d", :method => :dir
+  options :comment, :method => :gecos
+  options :groups, :flag => "-G"
+
+  verify :gid, "GID must be an integer" do |value|
+    value.is_a? Integer
+  end
+
+  verify :groups, "Groups must be comma-separated" do |value|
+    value !~ /\s/
+  end
+
+  def addcmd
+    cmd = [command(:pw), "useradd", @resource[:name]]
+    @resource.class.validproperties.each do |property|
+      next if property == :ensure
+      # the value needs to be quoted, mostly because -c might
+      # have spaces in it
+      if value = @resource.should(property) and value != ""
+        cmd << flag(property) << value
+      end
     end
 
-    verify :groups, "Groups must be comma-separated" do |value|
-        value !~ /\s/
-    end
+    cmd << "-o" if @resource.allowdupe?
 
-    def addcmd
-        cmd = [command(:pw), "useradd", @resource[:name]]
-        @resource.class.validproperties.each do |property|
-            next if property == :ensure
-            # the value needs to be quoted, mostly because -c might
-            # have spaces in it
-            if value = @resource.should(property) and value != ""
-                cmd << flag(property) << value
-            end
-        end
-
-        if @resource.allowdupe?
-            cmd << "-o"
-        end
-
-        if @resource.managehome?
-            cmd << "-m"
-        end
-
-        return cmd
-    end
+    cmd << "-m" if @resource.managehome?
+
+    cmd
+  end
 end
 

data/lib/puppet/provider/user/user_role_add.rb

@@ -2,192 +2,177 @@ require 'puppet/util/user_attr'
 
 Puppet::Type.type(:user).provide :user_role_add, :parent => :useradd, :source => :useradd do
 
-    desc "User management inherits ``useradd`` and adds logic to manage roles on Solaris using roleadd."
-
-    defaultfor :operatingsystem => :solaris
-
-    commands :add => "useradd", :delete => "userdel", :modify => "usermod", :role_add => "roleadd", :role_delete => "roledel", :role_modify => "rolemod"
-    options :home, :flag => "-d", :method => :dir
-    options :comment, :method => :gecos
-    options :groups, :flag => "-G"
-    options :roles, :flag => "-R"
-    options :auths, :flag => "-A"
-    options :profiles, :flag => "-P"
-
-    verify :gid, "GID must be an integer" do |value|
-        value.is_a? Integer
-    end
-
-    verify :groups, "Groups must be comma-separated" do |value|
-        value !~ /\s/
-    end
-
-    has_features :manages_homedir, :allows_duplicates, :manages_solaris_rbac, :manages_passwords
-
-    #must override this to hand the keyvalue pairs
-    def add_properties
-        cmd = []
-        Puppet::Type.type(:user).validproperties.each do |property|
-            #skip the password because we can't create it with the solaris useradd
-            next if [:ensure, :password].include?(property)
-            # 1680 Now you can set the hashed passwords on solaris:lib/puppet/provider/user/user_role_add.rb
-            # the value needs to be quoted, mostly because -c might
-            # have spaces in it
-            if value = @resource.should(property) and value != ""
-                if property == :keys
-                    cmd += build_keys_cmd(value)
-                else
-                    cmd << flag(property) << value
-                end
-            end
-        end
-        cmd
-    end
-
-    def user_attributes
-        @user_attributes ||= UserAttr.get_attributes_by_name(@resource[:name])
-    end
-
-    def flush
-        @user_attributes = nil
-    end
-
-    def command(cmd)
-        if is_role? or (!exists? and @resource[:ensure] == :role)
-            cmd = ("role_" + cmd.to_s).intern
-        end
-        super(cmd)
-    end
-
-    def is_role?
-        user_attributes and user_attributes[:type] == "role"
-    end
-
-    def run(cmd, msg)
-        begin
-            execute(cmd)
-        rescue Puppet::ExecutionFailure => detail
-            raise Puppet::Error, "Could not %s %s %s: %s" %
-                [msg, @resource.class.name, @resource.name, detail]
-        end
-    end
-
-    def transition(type)
-        cmd = [command(:modify)]
-        cmd << "-K" << "type=#{type}"
-        cmd += add_properties
-        cmd << @resource[:name]
-    end
-
-    def create
-        if is_role?
-            run(transition("normal"), "transition role to")
-        else
-            run(addcmd, "create")
-        end
-        # added to handle case when password is specified
-        if @resource[:password]
-            self.password = @resource[:password]
-        end
-    end
-
-    def destroy
-        run(deletecmd, "delete "+ (is_role? ? "role" : "user"))
-    end
-
-    def create_role
-        if exists? and !is_role?
-            run(transition("role"), "transition user to")
+  desc "User management inherits ``useradd`` and adds logic to manage roles on Solaris using roleadd."
+
+  defaultfor :operatingsystem => :solaris
+
+  commands :add => "useradd", :delete => "userdel", :modify => "usermod", :role_add => "roleadd", :role_delete => "roledel", :role_modify => "rolemod"
+  options :home, :flag => "-d", :method => :dir
+  options :comment, :method => :gecos
+  options :groups, :flag => "-G"
+  options :roles, :flag => "-R"
+  options :auths, :flag => "-A"
+  options :profiles, :flag => "-P"
+
+  verify :gid, "GID must be an integer" do |value|
+    value.is_a? Integer
+  end
+
+  verify :groups, "Groups must be comma-separated" do |value|
+    value !~ /\s/
+  end
+
+  has_features :manages_homedir, :allows_duplicates, :manages_solaris_rbac, :manages_passwords
+
+  #must override this to hand the keyvalue pairs
+  def add_properties
+    cmd = []
+    Puppet::Type.type(:user).validproperties.each do |property|
+      #skip the password because we can't create it with the solaris useradd
+      next if [:ensure, :password].include?(property)
+      # 1680 Now you can set the hashed passwords on solaris:lib/puppet/provider/user/user_role_add.rb
+      # the value needs to be quoted, mostly because -c might
+      # have spaces in it
+      if value = @resource.should(property) and value != ""
+        if property == :keys
+          cmd += build_keys_cmd(value)
         else
-            run(addcmd, "create role")
-        end
-    end
-
-    def roles
-        if user_attributes
-            user_attributes[:roles]
-        end
-    end
-
-    def auths
-        if user_attributes
-            user_attributes[:auths]
-        end
-    end
-
-    def profiles
-        if user_attributes
-            user_attributes[:profiles]
-        end
-    end
-
-    def project
-        if user_attributes
-            user_attributes[:project]
+          cmd << flag(property) << value
         end
-    end
-
-    def managed_attributes
-        [:name, :type, :roles, :auths, :profiles, :project]
-    end
-
-    def remove_managed_attributes
-        managed = managed_attributes
-        user_attributes.select { |k,v| !managed.include?(k) }.inject({}) { |hash, array| hash[array[0]] = array[1]; hash }
-    end
-
-    def keys
-        if user_attributes
-            #we have to get rid of all the keys we are managing another way
-            remove_managed_attributes
-        end
-    end
-
-    def build_keys_cmd(keys_hash)
-        cmd = []
-        keys_hash.each do |k,v|
-            cmd << "-K" << "#{k}=#{v}"
-        end
-        cmd
-    end
-
-    def keys=(keys_hash)
-        run([command(:modify)] + build_keys_cmd(keys_hash) << @resource[:name], "modify attribute key pairs")
-    end
-
-    #Read in /etc/shadow, find the line for this user (skipping comments, because who knows) and return the hashed pw (the second entry)
-    #No abstraction, all esoteric knowledge of file formats, yay
-    def password
-        #got perl?
-        if ary = File.readlines("/etc/shadow").reject { |r| r =~ /^[^\w]/}.collect { |l| l.split(':')[0..1] }.find { |user, passwd| user == @resource[:name] }
-            pass = ary[1]
-        end
-        pass
-    end
-
-    #Read in /etc/shadow, find the line for our used and rewrite it with the new pw
-    #Smooth like 80 grit
-    def password=(cryptopw)
-        begin
-            File.open("/etc/shadow", "r") do |shadow|
-                File.open("/etc/shadow_tmp", "w", 0600) do |shadow_tmp|
-                    while line = shadow.gets do
-                        line_arr = line.split(':')
-                        if line_arr[0] == @resource[:name]
-                            line_arr[1] = cryptopw
-                            line = line_arr.join(':')
-                        end
-                        shadow_tmp.print line
-                    end
-                end
+      end
+    end
+    cmd
+  end
+
+  def user_attributes
+    @user_attributes ||= UserAttr.get_attributes_by_name(@resource[:name])
+  end
+
+  def flush
+    @user_attributes = nil
+  end
+
+  def command(cmd)
+    cmd = ("role_#{cmd}").intern if is_role? or (!exists? and @resource[:ensure] == :role)
+    super(cmd)
+  end
+
+  def is_role?
+    user_attributes and user_attributes[:type] == "role"
+  end
+
+  def run(cmd, msg)
+      execute(cmd)
+  rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error, "Could not #{msg} #{@resource.class.name} #{@resource.name}: #{detail}"
+  end
+
+  def transition(type)
+    cmd = [command(:modify)]
+    cmd << "-K" << "type=#{type}"
+    cmd += add_properties
+    cmd << @resource[:name]
+  end
+
+  def create
+    if is_role?
+      run(transition("normal"), "transition role to")
+    else
+      run(addcmd, "create")
+    end
+    # added to handle case when password is specified
+    self.password = @resource[:password] if @resource[:password]
+  end
+
+  def destroy
+    run(deletecmd, "delete "+ (is_role? ? "role" : "user"))
+  end
+
+  def create_role
+    if exists? and !is_role?
+      run(transition("role"), "transition user to")
+    else
+      run(addcmd, "create role")
+    end
+  end
+
+  def roles
+    user_attributes[:roles] if user_attributes
+  end
+
+  def auths
+    user_attributes[:auths] if user_attributes
+  end
+
+  def profiles
+    user_attributes[:profiles] if user_attributes
+  end
+
+  def project
+    user_attributes[:project] if user_attributes
+  end
+
+  def managed_attributes
+    [:name, :type, :roles, :auths, :profiles, :project]
+  end
+
+  def remove_managed_attributes
+    managed = managed_attributes
+    user_attributes.select { |k,v| !managed.include?(k) }.inject({}) { |hash, array| hash[array[0]] = array[1]; hash }
+  end
+
+  def keys
+    if user_attributes
+      #we have to get rid of all the keys we are managing another way
+      remove_managed_attributes
+    end
+  end
+
+  def build_keys_cmd(keys_hash)
+    cmd = []
+    keys_hash.each do |k,v|
+      cmd << "-K" << "#{k}=#{v}"
+    end
+    cmd
+  end
+
+  def keys=(keys_hash)
+    run([command(:modify)] + build_keys_cmd(keys_hash) << @resource[:name], "modify attribute key pairs")
+  end
+
+  #Read in /etc/shadow, find the line for this user (skipping comments, because who knows) and return the hashed pw (the second entry)
+  #No abstraction, all esoteric knowledge of file formats, yay
+  def password
+    #got perl?
+    if ary = File.readlines("/etc/shadow").reject { |r| r =~ /^[^\w]/}.collect { |l| l.split(':')[0..1] }.find { |user, passwd| user == @resource[:name] }
+      pass = ary[1]
+    end
+    pass
+  end
+
+  #Read in /etc/shadow, find the line for our used and rewrite it with the new pw
+  #Smooth like 80 grit
+  def password=(cryptopw)
+    begin
+      File.open("/etc/shadow", "r") do |shadow|
+        File.open("/etc/shadow_tmp", "w", 0600) do |shadow_tmp|
+          while line = shadow.gets
+            line_arr = line.split(':')
+            if line_arr[0] == @resource[:name]
+              line_arr[1] = cryptopw
+              line = line_arr.join(':')
             end
-            File.rename("/etc/shadow_tmp", "/etc/shadow")
-        rescue => detail
-            fail "Could not write temporary shadow file: %s" % detail
-        ensure
-            # Make sure this *always* gets deleted
-            File.unlink("/etc/shadow_tmp") if File.exist?("/etc/shadow_tmp")
+            shadow_tmp.print line
+          end
         end
-    end
+      end
+      File.rename("/etc/shadow_tmp", "/etc/shadow")
+    rescue => detail
+      fail "Could not write temporary shadow file: #{detail}"
+    ensure
+      # Make sure this *always* gets deleted
+      File.unlink("/etc/shadow_tmp") if File.exist?("/etc/shadow_tmp")
+    end
+  end
 end