Module: Puppet::Util::POSIX

Included in:
Puppet::Util
Defined in:
lib/vendor/puppet/util/posix.rb

Overview

Utility methods for interacting with POSIX objects; mostly user and group

Instance Method Summary collapse

Instance Method Details

#get_posix_field(space, field, id) ⇒ Object

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

Raises:



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/vendor/puppet/util/posix.rb', line 9

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 #{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
end

#gid(group) ⇒ Object

Get the GID of a given group, provided either a GID or a name



92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/vendor/puppet/util/posix.rb', line 92

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

#idfield(space) ⇒ Object

Determine what the field name is for users and groups.



62
63
64
65
66
67
68
69
 
# File 'lib/vendor/puppet/util/posix.rb', line 62

def idfield(space)
  case space.intern
  when :gr, :group; return :gid
  when :pw, :user, :passwd; return :uid
  else
    raise ArgumentError.new("Can only handle users and groups")
  end
end

#methodbyid(space) ⇒ Object

Determine what the method is to get users and groups by id



72
73
74
75
76
77
78
79
 
# File 'lib/vendor/puppet/util/posix.rb', line 72

def methodbyid(space)
  case space.intern
  when :gr, :group; return :getgrgid
  when :pw, :user, :passwd; return :getpwuid
  else
    raise ArgumentError.new("Can only handle users and groups")
  end
end

#methodbyname(space) ⇒ Object

Determine what the method is to get users and groups by name



82
83
84
85
86
87
88
89
 
# File 'lib/vendor/puppet/util/posix.rb', line 82

def methodbyname(space)
  case space.intern
  when :gr, :group; return :getgrnam
  when :pw, :user, :passwd; return :getpwnam
  else
    raise ArgumentError.new("Can only handle users and groups")
  end
end

#search_posix_field(type, field, id) ⇒ Object

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.



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/vendor/puppet/util/posix.rb', line 33

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

  # 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

#uid(user) ⇒ Object

Get the UID of a given user, whether a UID or name is provided



115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/vendor/puppet/util/posix.rb', line 115

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