class Object

    # File lib/puppet/type/file.rb
460 def self.[](path)
461   return nil unless path
462   super(path.gsub(/\/+/, '/').sub(/\/$/, ''))
463 end

   # File lib/puppet/provider/package/pkgutil.rb
64 def self.availlist
65   output = pkguti ["-a"]
66 
67   output.split("\n").collect do |line|
68     next if line =~ /^common\s+package/  # header of package list
69     next if noise?(line)
70 
71     if line =~ /\s*(\S+)\s+(\S+)\s+(.*)/
72       { :alias => $1, :name => $2, :avail => $3 }
73     else
74       Puppet.warning _("Cannot match %{line}") % { line: line }
75     end
76   end.reject { |h| h.nil? }
77 end

   # File lib/puppet/provider/package/blastwave.rb
36 def self.blastlist(hash)
37   command = ["-c"]
38 
39   command << hash[:justme] if hash[:justme]
40 
41   output = Puppet::Util.withenv(:PAGER => "/usr/bin/cat") { pkgget command }
42 
43   list = output.split("\n").collect do |line|
44     next if line =~ /^#/
45     next if line =~ /^WARNING/
46     next if line =~ /localrev\s+remoterev/
47 
48     blastsplit(line)
49   end.reject { |h| h.nil? }
50 
51   if hash[:justme]
52     return list[0]
53   else
54     list.reject! { |h|
55       h[:ensure] == :absent
56     }
57     return list
58   end
59 
60 end

   # File lib/puppet/provider/package/blastwave.rb
63 def self.blastsplit(line)
64   if line =~ /\s*(\S+)\s+((\[Not installed\])|(\S+))\s+(\S+)/
65     hash = {}
66     hash[:name] = $1
67     hash[:ensure] = if $2 == "[Not installed]"
68       :absent
69     else
70       $2
71     end
72     hash[:avail] = $5
73 
74     hash[:avail] = hash[:ensure] if hash[:avail] == "SAME"
75 
76     # Use the name method, so it works with subclasses.
77     hash[:provider] = self.name
78 
79     return hash
80   else
81     Puppet.warning _("Cannot match %{line}") % { line: line }
82     return nil
83   end
84 end

   # File lib/puppet/provider/package/pkgng.rb
25 def self.cached_version_list
26   @version_list ||= get_version_list
27 end

    # File lib/puppet/provider/package/yum.rb
110 def self.check_updates(disablerepo, enablerepo, disableexcludes)
111   args = [command(:cmd), 'check-update']
112   args.concat(disablerepo.map { |repo| ["--disablerepo=#{repo}"] }.flatten)
113   args.concat(enablerepo.map { |repo| ["--enablerepo=#{repo}"] }.flatten)
114   args.concat(disableexcludes.map { |repo| ["--disableexcludes=#{repo}"] }.flatten)
115 
116   output = Puppet::Util::Execution.execute(args, :failonfail => false, :combine => false)
117 
118   updates = {}
119   if output.exitstatus == 100
120     updates = parse_updates(output)
121   elsif output.exitstatus == 0
122     self.debug "#{command(:cmd)} check-update exited with 0; no package updates available."
123   else
124     self.warning _("Could not check for updates, '%{cmd} check-update' exited with %{status}") % { cmd: command(:cmd), status: output.exitstatus }
125   end
126   updates
127 end

    # File lib/puppet/provider/package/yum.rb
176 def self.clear
177   @latest_versions = nil
178 end

   # File lib/puppet/provider/package/pip.rb
38 def self.cmd
39   if Puppet::Util::Platform.windows?
40     ["pip.exe"]
41   else
42     ["pip", "pip-python", "pip2", "pip-2"]
43   end
44 end

    # File lib/puppet/provider/package/pip.rb
134 def self.compare_pip_versions(x, y)
135   begin
136     Puppet::Util::Package::Version::Pip.compare(x, y)
137   rescue PIP_VERSION::ValidationFailure => ex
138     Puppet.debug("Cannot compare #{x} and #{y}. #{ex.message} Falling through default comparison mechanism.")
139     Puppet::Util::Package.versioncmp(x, y)
140   end
141 end

    # File lib/puppet/provider/user/directoryservice.rb
194 def self.convert_binary_to_hash(plist_data)
195   Puppet.debug('Converting binary plist to hash')
196   Puppet::Util::Plist.parse_plist(plist_data)
197 end

    # File lib/puppet/provider/user/directoryservice.rb
188 def self.convert_hash_to_binary(plist_data)
189   Puppet.debug('Converting plist hash to binary')
190   Puppet::Util::Plist.dump_plist(plist_data, :binary)
191 end

   # File lib/puppet/provider/package/dnfmodule.rb
25 def self.current_version
26   @current_version ||= dnf('--version').split.first
27 end

   # File lib/puppet/provider/service/daemontools.rb
83 def self.daemondir
84   self.defpath
85 end

   # File lib/puppet/provider/package/apt.rb
31 def self.defaultto_allow_virtual
32   false
33 end

   # File lib/puppet/provider/service/bsd.rb
15 def self.defpath
16   superclass.defpath
17 end

   # File lib/puppet/reports/store.rb
48 def self.destroy(host)
49   validate_host(host)
50 
51   dir = File.join(Puppet[:reportdir], host)
52 
53   if Puppet::FileSystem.exist?(dir)
54     Dir.entries(dir).each do |file|
55       next if ['.','..'].include?(file)
56       file = File.join(dir, file)
57       Puppet::FileSystem.unlink(file) if File.file?(file)
58     end
59     Dir.rmdir(dir)
60   end
61 end

   # File lib/puppet/provider/package/dpkg.rb
21 def self.dpkgquery_piped(*args, &block)
22   cmd = args.unshift(command(:dpkgquery))
23   Puppet::Util::Execution.execpipe(cmd, &block)
24 end

   # File lib/puppet/provider/user/directoryservice.rb
44 def self.ds_to_ns_attribute_map
45   {
46     'RecordName'       => :name,
47     'PrimaryGroupID'   => :gid,
48     'NFSHomeDirectory' => :home,
49     'UserShell'        => :shell,
50     'UniqueID'         => :uid,
51     'RealName'         => :comment,
52     'Password'         => :password,
53     'GeneratedUID'     => :guid,
54     'IPAddress'        => :ip_address,
55     'ENetAddress'      => :en_address,
56     'GroupMembership'  => :members,
57   }
58 end

    # File lib/puppet/provider/package/portage.rb
292 def self.eix_install_versions_format
293   '{!first}{!last},{}{}{isstable}<version>{}'
294 end

    # File lib/puppet/provider/package/portage.rb
288 def self.eix_installed_versions_format
289   '{!first},{}<version>'
290 end

    # File lib/puppet/provider/package/portage.rb
296 def self.eix_limit
297   '0'
298 end

    # File lib/puppet/provider/package/portage.rb
275 def self.eix_result_fields
276   # ensure:[3.4.5], version_available:[3.5.2], installed_slots:[2.7.12:2.7,3.4.5:3.4], installable_versions:[2.7.10-r1,2.7.12,3.4.3-r1,3.4.5,3.5.2] slot_versions_available:[2.7.12:2.7,3.4.5:3.4,3.5.2:3.5]
277   [:category, :name, :ensure, :version_available, :installed_slots, :installed_versions, :installable_versions, :slot_versions_available, :vendor, :description]
278 end

    # File lib/puppet/provider/package/portage.rb
271 def self.eix_result_format
272   /^(\S+)\s+(\S+)\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+(\S+)\s+(.*)$/
273 end

    # File lib/puppet/provider/package/portage.rb
300 def self.eix_search_arguments
301   ['--nocolor', '--pure-packages', '--format', self.eix_search_format]
302 end

    # File lib/puppet/provider/package/portage.rb
267 def self.eix_search_format
268   "'<category> <name> [<installedversions:LASTVERSION>] [<bestversion:LASTVERSION>] [<installedversions:LASTSLOTVERSIONS>] [<installedversions:INSTALLEDVERSIONS>] [<availableversions:STABLEVERSIONS>] [<bestslotversions:LASTSLOTVERSIONS>] <homepage> <description>\n'"
269 end

    # File lib/puppet/provider/package/portage.rb
284 def self.eix_slot_versions_format
285   '{!first},{}<version>:<slot>'
286 end

    # File lib/puppet/provider/package/portage.rb
280 def self.eix_version_format
281   '{last}<version>{}'
282 end

   # File lib/puppet/provider/package/dnf.rb
47 def self.error_level
48   '1'
49 end

   # File lib/puppet/provider/service/init.rb
37 def self.excludes
38   excludes = []
39   # these exclude list was found with grep -L '\/sbin\/runscript' /etc/init.d/* on gentoo
40   excludes += %w{functions.sh reboot.sh shutdown.sh}
41   # this exclude list is all from /sbin/service (5.x), but I did not exclude kudzu
42   excludes += %w{functions halt killall single linuxconf reboot boot}
43   # 'wait-for-state' and 'portmap-wait' are excluded from instances here
44   # because they take parameters that have unclear meaning. It looks like
45   # 'wait-for-state' is a generic waiter mainly used internally for other
46   # upstart services as a 'sleep until something happens'
47   # (http://lists.debian.org/debian-devel/2012/02/msg01139.html), while
48   # 'portmap-wait' is a specific instance of a waiter. There is an open
49   # launchpad bug
50   # (https://bugs.launchpad.net/ubuntu/+source/upstart/+bug/962047) that may
51   # eventually explain how to use the wait-for-state service or perhaps why
52   # it should remain excluded. When that bug is addressed this should be
53   # reexamined.
54   excludes += %w{wait-for-state portmap-wait}
55   # these excludes were found with grep -r -L start /etc/init.d
56   excludes += %w{rcS module-init-tools}
57   # Prevent puppet failing on unsafe scripts from Yocto Linux
58   if Puppet.runtime[:facter].value('os.family') == "cisco-wrlinux"
59     excludes += %w{banner.sh bootmisc.sh checkroot.sh devpts.sh dmesg.sh
60                  hostname.sh mountall.sh mountnfs.sh populate-volatile.sh
61                  rmnologin.sh save-rtc.sh sendsigs sysfs.sh umountfs
62                  umountnfs.sh}
63   end
64   # Prevent puppet failing to get status of the new service introduced
65   # by the fix for this (bug https://bugs.launchpad.net/ubuntu/+source/lightdm/+bug/982889)
66   # due to puppet's inability to deal with upstart services with instances.
67   excludes += %w{plymouth-ready}
68   # Prevent puppet failing to get status of these services, which need parameters
69   # passed in (see https://bugs.launchpad.net/ubuntu/+source/puppet/+bug/1276766).
70   excludes += %w{idmapd-mounting startpar-bridge}
71   # Prevent puppet failing to get status of these services, additional upstart
72   # service with instances
73   excludes += %w{cryptdisks-udev}
74   excludes += %w{statd-mounting}
75   excludes += %w{gssd-mounting}
76   excludes
77 end

   # File lib/puppet/provider/package/gem.rb
73 def self.execute_gem_command(command, command_options, custom_environment = {})
74   validate_command(command)
75   cmd = [command] << command_options
76 
77   custom_environment = {'HOME'=>ENV['HOME']}.merge(custom_environment)
78 
79   if Puppet::Util::Platform.windows?
80     custom_environment[:PATH] = windows_path_without_puppet_bin
81   end
82 
83   execute(cmd, {:failonfail => true, :combine => true, :custom_environment => custom_environment})
84 end

    # File lib/puppet/provider/package/puppetserver_gem.rb
141 def self.execute_rubygems_list_command(command_options)
142   puppetserver_default_gem_home            = '/opt/puppetlabs/server/data/puppetserver/jruby-gems'
143   puppetserver_default_vendored_jruby_gems = '/opt/puppetlabs/server/data/puppetserver/vendored-jruby-gems'
144   puppet_default_vendor_gems               = '/opt/puppetlabs/puppet/lib/ruby/vendor_gems'
145   puppetserver_default_gem_path = [puppetserver_default_gem_home, puppetserver_default_vendored_jruby_gems, puppet_default_vendor_gems].join(':')
146 
147   pe_puppetserver_conf_file = '/etc/puppetlabs/puppetserver/conf.d/pe-puppet-server.conf'
148   os_puppetserver_conf_file = '/etc/puppetlabs/puppetserver/puppetserver.conf'
149   puppetserver_conf_file = Puppet.runtime[:facter].value(:pe_server_version) ? pe_puppetserver_conf_file : os_puppetserver_conf_file
150   puppetserver_conf = Hocon.load(puppetserver_conf_file)
151 
152   gem_env = {}
153   if puppetserver_conf.empty? || puppetserver_conf.key?('jruby-puppet') == false
154     gem_env['GEM_HOME'] = puppetserver_default_gem_home
155     gem_env['GEM_PATH'] = puppetserver_default_gem_path
156   else
157     gem_env['GEM_HOME'] = puppetserver_conf['jruby-puppet'].key?('gem-home') ? puppetserver_conf['jruby-puppet']['gem-home'] : puppetserver_default_gem_home
158     gem_env['GEM_PATH'] = puppetserver_conf['jruby-puppet'].key?('gem-path') ? puppetserver_conf['jruby-puppet']['gem-path'].join(':') : puppetserver_default_gem_path
159   end
160   gem_env['GEM_SPEC_CACHE'] = "/tmp/#{$$}"
161 
162   # Remove the 'gem' from the command_options
163   command_options.shift
164   gem_out = execute_gem_command(Puppet::Type::Package::ProviderPuppet_gem.provider_command, command_options, gem_env)
165 
166   # There is no method exclude default gems from the local gem list,
167   # for example: psych (default: 2.2.2)
168   # but default gems should not be managed by this (or any) provider.
169   gem_list = gem_out.lines.reject { |gem| gem =~ / \(default\: / }
170   gem_list.join("\n")
171 end

   # File lib/puppet/provider/user/aix.rb
65 def expires_to_expiry(provider, expires)
66   return :absent if expires == '0'
67 
68   unless (match_obj = /\A(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)\z/.match(expires))
69     #TRANSLATORS 'AIX' is the name of an operating system and should not be translated
70     Puppet.warning(_("Could not convert AIX expires date '%{expires}' on %{class_name}[%{resource_name}]") % { expires: expires, class_name: provider.resource.class.name, resource_name: provider.resource.name })
71     return :absent
72   end
73 
74   month, day, year = match_obj[1], match_obj[2], match_obj[-1]
75   return "20#{year}-#{month}-#{day}"
76 end

   # File lib/puppet/provider/user/aix.rb
58 def expiry_to_expires(expiry)
59   return '0' if expiry == "0000-00-00" || expiry.to_sym == :absent
60   
61   DateTime.parse(expiry, "%Y-%m-%d %H:%M")
62     .strftime("%m%d%H%M%y")
63 end

   # File lib/puppet/provider/package/blastwave.rb
16 def self.extended(mod)
17   unless command(:pkgget) != "pkg-get"
18     raise Puppet::Error,
19       _("The pkg-get command is missing; blastwave packaging unavailable")
20   end
21 
22   unless Puppet::FileSystem.exist?("/var/pkg-get/admin")
23     Puppet.notice _("It is highly recommended you create '/var/pkg-get/admin'.")
24     Puppet.notice _("See /var/pkg-get/admin-fullauto")
25   end
26 end

   # File lib/puppet/provider/group/aix.rb
33 def find(group, ia_module_args = [])
34   groups = list_all(ia_module_args)
35 
36   id_property = mappings[:puppet_property][:id]
37 
38   if group.is_a?(String)
39     # Find by name
40     group_hash = groups.find { |cur_group| cur_group[:name] == group }
41   else
42     # Find by gid
43     group_hash = groups.find do |cur_group|
44       id_property.convert_attribute_value(cur_group[:id]) == group
45     end
46   end
47 
48   unless group_hash
49     raise ArgumentError, _("No AIX group exists with a group name or gid of %{group}!") % { group: group }
50   end
51 
52   # Convert :id => :gid
53   id = group_hash.delete(:id)
54   group_hash[:gid] = id_property.convert_attribute_value(id)
55 
56   group_hash
57 end

    # File lib/puppet/provider/package/gem.rb
102 def self.gemlist(options)
103   command_options = ["list"]
104 
105   if options[:local]
106     command_options << "--local"
107   else
108     command_options << "--remote"
109   end
110   if options[:source]
111     command_options << "--source" << options[:source]
112   end
113   name = options[:justme]
114   if name
115     command_options << '\A' + name + '\z'
116   end
117 
118   begin
119     list = execute_gem_command(options[:command], command_options).lines.
120       map {|set| gemsplit(set) }.
121       reject {|x| x.nil? }
122   rescue Puppet::ExecutionFailure => detail
123     raise Puppet::Error, _("Could not list gems: %{detail}") % { detail: detail }, detail.backtrace
124   end
125 
126   if options[:justme]
127     return list.shift
128   else
129     return list
130   end
131 end

    # File lib/puppet/provider/package/gem.rb
133 def self.gemsplit(desc)
134   # `gem list` when output console has a line like:
135   # *** LOCAL GEMS ***
136   # but when it's not to the console that line
137   # and all blank lines are stripped
138   # so we don't need to check for them
139 
140   if desc =~ /^(\S+)\s+\((.+)\)/
141     gem_name = $1
142     versions = $2.sub('default: ', '').split(/,\s*/)
143     {
144       :name     => gem_name,
145       :ensure   => versions.map{|v| v.split[0]},
146       :provider => name
147     }
148   else
149     Puppet.warning _("Could not match %{desc}") % { desc: desc } unless desc.chomp.empty?
150     nil
151   end
152 end

    # File lib/puppet/provider/user/directoryservice.rb
103 def self.generate_attribute_hash(input_hash)
104   attribute_hash = {}
105   input_hash.each_key do |key|
106     ds_attribute = key.sub("dsAttrTypeStandard:", "")
107     next unless ds_to_ns_attribute_map.keys.include?(ds_attribute)
108     ds_value = input_hash[key]
109     case ds_to_ns_attribute_map[ds_attribute]
110       when :gid, :uid
111         # OS X stores objects like uid/gid as strings.
112         # Try casting to an integer for these cases to be
113         # consistent with the other providers and the group type
114         # validation
115         begin
116           ds_value = Integer(ds_value[0])
117         rescue ArgumentError
118           ds_value = ds_value[0]
119         end
120       else ds_value = ds_value[0]
121     end
122     attribute_hash[ds_to_ns_attribute_map[ds_attribute]] = ds_value
123   end
124   attribute_hash[:ensure]         = :present
125   attribute_hash[:provider]       = :directoryservice
126   attribute_hash[:shadowhashdata] = input_hash['dsAttrTypeNative:ShadowHashData']
127 
128   ##############
129   # Get Groups #
130   ##############
131   groups_array = []
132   get_list_of_groups.each do |group|
133     if group["dsAttrTypeStandard:GroupMembership"] and group["dsAttrTypeStandard:GroupMembership"].include?(attribute_hash[:name])
134       groups_array << group["dsAttrTypeStandard:RecordName"][0]
135     end
136 
137     if group["dsAttrTypeStandard:GroupMembers"] and group["dsAttrTypeStandard:GroupMembers"].include?(attribute_hash[:guid])
138       groups_array << group["dsAttrTypeStandard:RecordName"][0]
139     end
140   end
141   attribute_hash[:groups] = groups_array.uniq.sort.join(',')
142 
143   ################################
144   # Get Password/Salt/Iterations #
145   ################################
146   if attribute_hash[:shadowhashdata].nil? or attribute_hash[:shadowhashdata].empty?
147     attribute_hash[:password] = '*'
148   else
149     embedded_binary_plist = get_embedded_binary_plist(attribute_hash[:shadowhashdata])
150     if embedded_binary_plist['SALTED-SHA512-PBKDF2']
151       attribute_hash[:password]   = get_salted_sha512_pbkdf2('entropy', embedded_binary_plist, attribute_hash[:name])
152       attribute_hash[:salt]       = get_salted_sha512_pbkdf2('salt', embedded_binary_plist, attribute_hash[:name])
153       attribute_hash[:iterations] = get_salted_sha512_pbkdf2('iterations', embedded_binary_plist, attribute_hash[:name])
154     elsif embedded_binary_plist['SALTED-SHA512']
155       attribute_hash[:password] = get_salted_sha512(embedded_binary_plist)
156     end
157   end
158 
159   attribute_hash
160 end

   # File lib/puppet/provider/user/directoryservice.rb
95 def self.get_all_users
96   Puppet::Util::Plist.parse_plist(dscl '-plist', '.', 'readall', '/Users')
97 end

    # File lib/puppet/provider/user/directoryservice.rb
175 def self.get_attribute_from_dscl(path, username, keyname)
176   Puppet::Util::Plist.parse_plist(dscl '-plist', '.', 'read', "/#{path}/#{username}", keyname)
177 end

    # File lib/puppet/provider/user/directoryservice.rb
182 def self.get_embedded_binary_plist(shadow_hash_data)
183   embedded_binary_plist = Array(shadow_hash_data[0].delete(' ')).pack('H*')
184   convert_binary_to_hash(embedded_binary_plist)
185 end

    # File lib/puppet/provider/package/pacman.rb
 97 def self.get_installed_groups(installed_packages, filter = nil)
 98   groups = {}
 99   begin
100     # Build a hash of group name => list of packages
101     command = [command(:pacman), "-Sgg"]
102     command << filter if filter
103     execpipe(command) do |pipe|
104       pipe.each_line do |line|
105         name, package = line.split
106         packages = (groups[name] ||= [])
107         packages << package
108       end
109     end
110 
111     # Remove any group that doesn't have all its packages installed
112     groups.delete_if do |_, packages|
113       !packages.all? { |package| installed_packages[package] }
114     end
115 
116     # Replace the list of packages with a version string consisting of packages that make up the group
117     groups.each do |name, packages|
118       groups[name] = packages.sort.map {|package| "#{package} #{installed_packages[package]}"}.join ', '
119     end
120   rescue Puppet::ExecutionFailure
121     # pacman returns an expected non-zero exit code when the filter name is not a group
122     raise unless filter
123   end
124   groups
125 end

   # File lib/puppet/provider/package/pacman.rb
75 def self.get_installed_packages
76   begin
77     packages = {}
78     execpipe([command(:pacman), "-Q"]) do |pipe|
79       # pacman -Q output is 'packagename version-rel'
80       regex = %r{^(\S+)\s(\S+)}
81       pipe.each_line do |line|
82         match = regex.match(line)
83         if match
84           packages[match.captures[0]] = match.captures[1]
85         else
86           warning(_("Failed to match line '%{line}'") % { line: line })
87         end
88       end
89     end
90     packages
91   rescue Puppet::ExecutionFailure
92     fail(_("Error getting installed packages"))
93   end
94 end

   # File lib/puppet/provider/package/pkgng.rb
33 def self.get_latest_version(origin)
34   latest_version = cached_version_list.lines.find { |l| l =~ /^#{origin} / }
35   if latest_version
36     _name, compare, status = latest_version.chomp.split(' ', 3)
37     if ['!', '?'].include?(compare)
38       return nil
39     end
40     latest_version = status.split(' ').last.split(')').first
41     return latest_version
42   end
43   nil
44 end

    # File lib/puppet/provider/user/directoryservice.rb
168 def self.get_list_of_groups
169   @groups ||= Puppet::Util::Plist.parse_plist(dscl '-plist', '.', 'readall', '/Groups')
170 end

   # File lib/puppet/provider/service/launchd.rb
73 def self.get_os_version
74   @os_version ||= Facter.value('os.release.major').to_i
75 end

   # File lib/puppet/provider/package/pkgng.rb
17 def self.get_query
18   pkg(['query', '-a', '%n %v %o'])
19 end

   # File lib/puppet/provider/package/pkgng.rb
21 def self.get_resource_info(name)
22   pkg(['query', '%n %v %o', name])
23 end

    # File lib/puppet/provider/user/directoryservice.rb
201 def self.get_salted_sha512(embedded_binary_plist)
202   embedded_binary_plist['SALTED-SHA512'].unpack("H*")[0]
203 end

    # File lib/puppet/provider/user/directoryservice.rb
209 def self.get_salted_sha512_pbkdf2(field, embedded_binary_plist, user_name = "")
210   case field
211   when 'salt', 'entropy'
212     value = embedded_binary_plist['SALTED-SHA512-PBKDF2'][field]
213     if value == nil
214       raise Puppet::Error, "Invalid #{field} given for user #{user_name}"
215     end
216     value.unpack('H*').first
217   when 'iterations'
218     Integer(embedded_binary_plist['SALTED-SHA512-PBKDF2'][field])
219   else
220     raise Puppet::Error, "Puppet has tried to read an incorrect value from the user #{user_name} in the SALTED-SHA512-PBKDF2 hash. Acceptable fields are 'salt', 'entropy', or 'iterations'."
221   end
222 end

    # File lib/puppet/provider/service/init.rb
 84 def self.get_services(defpath, exclude = self.excludes)
 85   defpath = [defpath] unless defpath.is_a? Array
 86   instances = []
 87   defpath.each do |path|
 88     unless Puppet::FileSystem.directory?(path)
 89       Puppet.debug "Service path #{path} does not exist"
 90       next
 91     end
 92 
 93     check = [:ensure]
 94 
 95     check << :enable if public_method_defined? :enabled?
 96 
 97     Dir.entries(path).each do |name|
 98       fullpath = File.join(path, name)
 99       next if name =~ /^\./
100       next if exclude.include? name
101       next if Puppet::FileSystem.directory?(fullpath)
102       next unless Puppet::FileSystem.executable?(fullpath)
103       next unless is_init?(fullpath)
104       instances << new(:name => name, :path => path, :hasstatus => true)
105     end
106   end
107   instances
108 end

    # File lib/puppet/provider/package/portage.rb
156 def self.get_sets
157   @sets ||= begin
158     @sets = emerge(*(['--list-sets']))
159   end
160 end

    # File lib/puppet/provider/user/directoryservice.rb
226 def self.get_sha1(guid)
227   password_hash = nil
228   password_hash_file = "#{password_hash_dir}/#{guid}"
229   if Puppet::FileSystem.exist?(password_hash_file) and File.file?(password_hash_file)
230     raise Puppet::Error, "Could not read password hash file at #{password_hash_file}" if not File.readable?(password_hash_file)
231     f = File.new(password_hash_file)
232     password_hash = f.read
233     f.close
234   end
235   password_hash
236 end

   # File lib/puppet/provider/package/pkgng.rb
29 def self.get_version_list
30   @version_list = pkg(['version', '-voRL='])
31 end

   # File lib/puppet/provider/user/aix.rb
46 def gid_to_pgrp(provider, gid)
47   group = group_provider.find(gid, provider.ia_module_args)
48 
49   group[:name]
50 end

   # File lib/puppet/provider/package/pacman.rb
29 def self.group?(name)
30   begin
31     !pacman("-Sg", name).empty?
32   rescue Puppet::ExecutionFailure
33     # pacman returns an expected non-zero exit code when the name is not a group
34     false
35   end
36 end

   # File lib/puppet/provider/user/aix.rb
39 def group_provider
40   @group_provider ||= Puppet::Type.type(:group).provider(:aix)
41 end

   # File lib/puppet/provider/user/aix.rb
96 def groups_attribute_to_property(provider, _groups)
97   Puppet::Util::POSIX.groups_of(provider.resource[:name]).join(',')
98 end

   # File lib/puppet/provider/user/aix.rb
82 def groups_property_to_attribute(groups)
83   if groups =~ /\s/
84     raise ArgumentError, _("Invalid value %{groups}: Groups must be comma separated!") % { groups: groups }
85   end
86 
87   groups
88 end

   # File lib/puppet/provider/service/upstart.rb
34 def self.has_initctl?
35   # Puppet::Util::Execution.execute does not currently work on jRuby.
36   # Unfortunately, since this confine is invoked whenever we check for
37   # provider suitability and since provider suitability is still checked
38   # on the master, this confine will still be invoked on the master. Thus
39   # to avoid raising an exception, we do an early return if we're running
40   # on jRuby.
41   return false if Puppet::Util::Platform.jruby?
42 
43   begin
44     initctl('version', '--quiet')
45     true
46   rescue
47     false
48   end
49 end

   # File lib/puppet/provider/package/macports.rb
40 def self.hash_from_line(line, regex, fields)
41   hash = {}
42   match = regex.match(line)
43   if match
44     fields.zip(match.captures) { |field, value|
45       hash[field] = value
46     }
47     hash[:provider] = self.name
48     return hash
49   end
50   nil
51 end

   # File lib/puppet/provider/package/pkgutil.rb
17 def self.healthcheck()
18   unless Puppet::FileSystem.exist?("/var/opt/csw/pkgutil/admin")
19     Puppet.notice _("It is highly recommended you create '/var/opt/csw/pkgutil/admin'.")
20     Puppet.notice _("See /var/opt/csw/pkgutil")
21   end
22 
23   correct_wgetopts = false
24   [ "/opt/csw/etc/pkgutil.conf", "/etc/opt/csw/pkgutil.conf" ].each do |confpath|
25     File.open(confpath) do |conf|
26       conf.each_line {|line| correct_wgetopts = true if line =~ /^\s*wgetopts\s*=.*(-nv|-q|--no-verbose|--quiet)/ }
27     end
28   end
29   if ! correct_wgetopts
30     Puppet.notice _("It is highly recommended that you set 'wgetopts=-nv' in your pkgutil.conf.")
31   end
32 end

   # File lib/puppet/provider/package/pkg.rb
46 def self.ifo_flag(flags)
47   (
48     case flags[0..0]
49     when 'i'
50       {:status => 'installed'}
51     when '-'
52       {:status => 'known'}
53     else
54       raise ArgumentError, _('Unknown format %{resource_name}: %{full_flags}[%{bad_flag}]') %
55           { resource_name: self.name, full_flags: flags, bad_flag: flags[0..0] }
56     end
57   ).merge(
58     case flags[1..1]
59     when 'f'
60       {:mark => :hold}
61     when '-'
62       {}
63     else
64       raise ArgumentError, _('Unknown format %{resource_name}: %{full_flags}[%{bad_flag}]') %
65           { resource_name: self.name, full_flags: flags, bad_flag: flags[1..1] }
66     end
67   )
68 end

   # File lib/puppet/provider/package/appdmg.rb
45 def self.installapp(source, name, orig_source)
46   appname = File.basename(source);
47   ditto "--rsrc", source, "/Applications/#{appname}"
48   Puppet::FileSystem.open("/var/db/.puppet_appdmg_installed_#{name}", nil, "w:UTF-8") do |t|
49     t.print "name: '#{name}'\n"
50     t.print "source: '#{orig_source}'\n"
51   end
52 end

   # File lib/puppet/provider/package/pkgdmg.rb
63 def self.installpkg(source, name, orig_source)
64   installer "-pkg", source, "-target", "/"
65   # Non-zero exit status will throw an exception.
66   Puppet::FileSystem.open("/var/db/.puppet_pkgdmg_installed_#{name}", nil, "w:UTF-8") do |t|
67     t.print "name: '#{name}'\n"
68     t.print "source: '#{orig_source}'\n"
69   end
70 end

   # File lib/puppet/provider/package/appdmg.rb
54 def self.installpkgdmg(source, name)
55   require 'open-uri'
56   cached_source = source
57   tmpdir = Dir.mktmpdir
58   begin
59     if %r{\A[A-Za-z][A-Za-z0-9+\-\.]*://} =~ cached_source
60       cached_source = File.join(tmpdir, name)
61       begin
62         curl "-o", cached_source, "-C", "-", "-L", "-s", "--url", source
63         Puppet.debug "Success: curl transferred [#{name}]"
64       rescue Puppet::ExecutionFailure
65         Puppet.debug "curl did not transfer [#{name}].  Falling back to slower open-uri transfer methods."
66         cached_source = source
67       end
68     end
69 
70     open(cached_source) do |dmg|
71       xml_str = hdiutil "mount", "-plist", "-nobrowse", "-readonly", "-mountrandom", "/tmp", dmg.path
72         ptable = Puppet::Util::Plist::parse_plist(xml_str)
73         # JJM Filter out all mount-paths into a single array, discard the rest.
74         mounts = ptable['system-entities'].collect { |entity|
75           entity['mount-point']
76         }.select { |mountloc|; mountloc }
77         begin
78           found_app = false
79           mounts.each do |fspath|
80             Dir.entries(fspath).select { |f|
81               f =~ /\.app$/i
82             }.each do |pkg|
83               found_app = true
84               installapp("#{fspath}/#{pkg}", name, source)
85             end
86           end
87           Puppet.debug "Unable to find .app in .appdmg. #{name} will not be installed." if !found_app
88         ensure
89           hdiutil "eject", mounts[0]
90         end
91     end
92   ensure
93     FileUtils.remove_entry_secure(tmpdir, true)
94   end
95 end

   # File lib/puppet/provider/package/apple.rb
25 def self.instance_by_name
26   Dir.entries("/Library/Receipts").find_all { |f|
27     f =~ /\.pkg$/
28   }.collect { |f|
29     name = f.sub(/\.pkg/, '')
30     yield name if block_given?
31 
32     name
33   }
34 end

    # File lib/puppet/provider/group/windows_adsi.rb
111 def self.instances
112   Puppet::Util::Windows::ADSI::Group.map { |g| new(:ensure => :present, :name => g.name) }
113 end

   # File lib/puppet/provider/package/appdmg.rb
29 def self.instances_by_name
30   Dir.entries("/var/db").find_all { |f|
31     f =~ /^\.puppet_appdmg_installed_/
32   }.collect do |f|
33     name = f.sub(/^\.puppet_appdmg_installed_/, '')
34     yield name if block_given?
35     name
36   end
37 end

    # File lib/puppet/provider/service/init.rb
191 def self.is_init?(script = initscript)
192   file = Puppet::FileSystem.pathname(script)
193   !Puppet::FileSystem.symlink?(file) || Puppet::FileSystem.readlink(file) != "/lib/init/upstart-job"
194 end

    # File lib/puppet/provider/service/launchd.rb
181 def self.job_list
182   @job_list = Hash.new
183   begin
184     output = launchctl :list
185     raise Puppet::Error.new("launchctl list failed to return any data.") if output.nil?
186     output.split("\n").each do |line|
187       @job_list[line.split(/\s/).last] = :running
188     end
189   rescue Puppet::ExecutionFailure
190     raise Puppet::Error.new("Unable to determine status of #{resource[:name]}", $!)
191   end
192   @job_list
193 end

    # File lib/puppet/provider/service/launchd.rb
158 def self.jobsearch(label=nil)
159   by_label = make_label_to_path_map
160 
161   if label
162     if by_label.has_key? label
163       return { label => by_label[label] }
164     else
165       # try refreshing the map, in case a plist has been added in the interim
166       by_label = make_label_to_path_map(true)
167       if by_label.has_key? label
168         return { label => by_label[label] }
169       else
170         raise Puppet::Error, "Unable to find launchd plist for job: #{label}"
171       end
172     end
173   else
174     # caller wants the whole map
175     by_label
176   end
177 end

   # File lib/puppet/provider/package/yum.rb
87 def self.latest_package_version(package, disablerepo, enablerepo, disableexcludes)
88 
89   key = [disablerepo, enablerepo, disableexcludes]
90 
91   @latest_versions ||= {}
92   if @latest_versions[key].nil?
93     @latest_versions[key] = check_updates(disablerepo, enablerepo, disableexcludes)
94   end
95 
96   if @latest_versions[key][package]
97     @latest_versions[key][package].first
98   end
99 end

   # File lib/puppet/provider/service/launchd.rb
83 def self.launchd_overrides
84   if self.get_os_version < 14
85     "/var/db/launchd.db/com.apple.launchd/overrides.plist"
86   else
87     "/var/db/com.apple.xpc.launchd/disabled.plist"
88   end
89 end

   # File lib/puppet/provider/service/launchd.rb
59 def self.launchd_paths
60   [
61     "/Library/LaunchAgents",
62     "/Library/LaunchDaemons",
63     "/System/Library/LaunchAgents",
64     "/System/Library/LaunchDaemons"
65   ]
66 end

   # File lib/puppet/provider/package/zypper.rb
31 def self.list_updates
32   output = zypper 'list-updates'
33 
34   avail_updates = {}
35 
36   # split up columns
37   output.lines.each do |line|
38     pkg_ver = line.split(/\s*\|\s*/)
39     # ignore zypper headers
40     next unless pkg_ver[0] == 'v'
41     avail_updates[pkg_ver[2]] = pkg_ver[4]
42   end
43 
44   avail_updates
45 end

   # File lib/puppet/provider/package/freebsd.rb
15 def self.listcmd
16   command(:pkginfo)
17 end

    # File lib/puppet/provider/service/launchd.rb
134 def self.make_label_to_path_map(refresh=false)
135   return @label_to_path_map if @label_to_path_map and not refresh
136   @label_to_path_map = {}
137   launchd_paths.each do |path|
138     return_globbed_list_of_file_paths(path).each do |filepath|
139       Puppet.debug("Reading launchd plist #{filepath}")
140       job = read_plist(filepath)
141       next if job.nil?
142       if job.respond_to?(:key) && job.key?("Label")
143         @label_to_path_map[job["Label"]] = filepath
144       else
145         #TRANSLATORS 'plist' and label' should not be translated
146         Puppet.debug(_("The %{file} plist does not contain a 'label' key; Puppet is skipping it") % { file: filepath })
147         next
148       end
149     end
150   end
151   @label_to_path_map
152 end

   # File lib/puppet/util/log/destinations.rb
50 def self.match?(obj)
51   obj.is_a?(String) && Puppet::Util.absolute_path?(obj)
52 end

   # File lib/puppet/provider/group/aix.rb
62 def members_to_users(provider, members)
63   members = members.split(',') if members.is_a?(String)
64   unless provider.resource[:auth_membership]
65     current_members = provider.members
66     current_members = [] if current_members == :absent
67     members = (members + current_members).uniq
68   end
69 
70   members.join(',')
71 end

   # File lib/puppet/provider/group/ldap.rb
41 def self.name2id(group)
42   result = manager.search("cn=#{group}")
43   return nil unless result and result.length > 0
44 
45   # Only use the first result.
46   group = result[0]
47   group[:gid][0]
48 end

   # File lib/puppet/provider/package/sun.rb
33 def self.namemap(hash)
34   self::Namemap.keys.inject({}) do |hsh,k|
35     hsh.merge(self::Namemap[k] => hash[k])
36   end
37 end

    # File lib/puppet/provider/package/rpm.rb
202 def self.nevra_to_hash(line)
203   line.strip!
204   hash = {}
205 
206   match = self::NEVRA_REGEX.match(line)
207   if match
208     self::NEVRA_FIELDS.zip(match.captures) { |f, v| hash[f] = v }
209     hash[:provider] = self.name
210     hash[:ensure] = "#{hash[:version]}-#{hash[:release]}"
211     hash[:ensure].prepend("#{hash[:epoch]}:") if hash[:epoch] != '0'
212   else
213     Puppet.debug("Failed to match rpm line #{line}")
214   end
215 
216   return hash
217 end

    # File lib/puppet/provider/package/rpm.rb
223 def self.nevra_to_multiversion_hash(multiline)
224   list = []
225   multiversion_hash = {}
226   multiline.each_line do |line|
227     hash = self.nevra_to_hash(line)
228     if !hash.empty?
229       if multiversion_hash.empty?
230         multiversion_hash = hash.dup
231         next
232       end
233 
234       if multiversion_hash[:name] != hash[:name]
235         list << multiversion_hash
236         multiversion_hash = hash.dup
237         next
238       end
239 
240       if !multiversion_hash[:ensure].include?(hash[:ensure])
241         multiversion_hash[:ensure].concat("#{self::MULTIVERSION_SEPARATOR}#{hash[:ensure]}")
242       end
243     end
244   end
245   list << multiversion_hash if multiversion_hash
246   if list.size == 1
247     return list[0]
248   end
249   return list
250 end

   # File lib/puppet/functions/match.rb
49 def initialize(closure_scope, loader)
50   super
51 
52   # Make this visitor shared among all instantiations of this function since it is faster.
53   # This can be used because it is not possible to replace
54   # a puppet runtime (where this function is) without a reboot. If you model a function in a module after
55   # this class, use a regular instance variable instead to enable reloading of the module without reboot
56   #
57   @@match_visitor   ||= Puppet::Pops::Visitor.new(self, "match", 1, 1)
58 end

   # File lib/puppet/provider/package/rpm.rb
55 def self.nodigest
56   '--nodigest' unless Puppet::Util::Package.versioncmp(current_version, '4.0.2') < 0
57 end

    # File lib/puppet/provider/package/pkgutil.rb
116 def self.noise?(line)
117   true if line =~ /^#/
118   true if line =~ /^Checking integrity / # use_gpg
119   true if line =~ /^gpg: /               # gpg verification
120   true if line =~ /^=+> /                # catalog fetch
121   true if line =~ /\d+:\d+:\d+ URL:/     # wget without -q
122   false
123 end

   # File lib/puppet/provider/package/rpm.rb
50 def self.nosignature
51   '--nosignature' unless Puppet::Util::Package.versioncmp(current_version, '4.1') < 0
52 end

   # File lib/puppet/provider/user/directoryservice.rb
60 def self.ns_to_ds_attribute_map
61   @ns_to_ds_attribute_map ||= ds_to_ns_attribute_map.invert
62 end

    # File lib/puppet/provider/package/pip.rb
103 def self.parse(line)
104   if line.chomp =~ /^([^=]+)===?([^=]+)$/
105     {:ensure => $2, :name => $1, :provider => name}
106   end
107 end

   # File lib/puppet/provider/package/macports.rb
34 def self.parse_info_query_line(line)
35   regex = /(\S+)\s+(\S+)/
36   fields = [:version, :revision]
37   hash_from_line(line, regex, fields)
38 end

   # File lib/puppet/provider/package/macports.rb
28 def self.parse_installed_query_line(line)
29   regex = /(\S+)\s+@(\S+)_(\d+).*\(active\)/
30   fields = [:name, :ensure, :revision]
31   hash_from_line(line, regex, fields)
32 end

   # File lib/puppet/provider/package/dpkg.rb
60 def self.parse_line(line, regex=self::FIELDS_REGEX)
61   hash = nil
62 
63   match = regex.match(line)
64   if match
65     hash = {}
66 
67     self::FIELDS.zip(match.captures) do |field,value|
68       hash[field] = value
69     end
70 
71     hash[:provider] = self.name
72 
73     if hash[:status] == 'not-installed'
74       hash[:ensure] = :purged
75     elsif ['config-files', 'half-installed', 'unpacked', 'half-configured'].include?(hash[:status])
76       hash[:ensure] = :absent
77     end
78     hash[:mark] = hash[:desired] == 'hold' ? :hold : :none
79   else
80     Puppet.debug("Failed to match dpkg-query line #{line.inspect}")
81   end
82 
83   return hash
84 end

   # File lib/puppet/provider/package/pkgng.rb
46 def self.parse_pkg_query_line(line)
47   name, version, origin = line.chomp.split(' ', 3)
48   latest_version  = get_latest_version(origin) || version
49 
50   {
51     :ensure   => version,
52     :name     => name,
53     :provider => self.name,
54     :origin   => origin,
55     :version  => version,
56     :latest   => latest_version
57   }
58 end

   # File lib/puppet/provider/package/pkgin.rb
13 def self.parse_pkgin_line(package)
14 
15   # e.g.
16   #   vim-7.2.446;Vim editor (vi clone) without GUI
17   match, name, version, status = *package.match(/([^\s;]+)-([^\s;]+)[;\s](=|>|<)?.+$/)
18   if match
19     {
20       :name     => name,
21       :status   => status,
22       :ensure   => version
23     }
24   end
25 end

   # File lib/puppet/provider/package/sun.rb
39 def self.parse_pkginfo(out)
40   # collect all the lines with : in them, and separate them out by ^$
41   pkgs = []
42   pkg = {}
43   out.each_line do |line|
44     case line.chomp
45     when /^\s*$/
46       pkgs << pkg unless pkg.empty?
47       pkg = {}
48     when /^\s*([^:]+):\s+(.+)$/
49       pkg[$1] = $2
50     end
51   end
52   pkgs << pkg unless pkg.empty?
53   pkgs
54 end

    # File lib/puppet/provider/package/pkgutil.rb
 88 def self.parse_pkglist(output, hash = {})
 89   output = output.split("\n")
 90 
 91   if output[-1] == "Not in catalog"
 92     Puppet.warning _("Package not in pkgutil catalog: %{package}") % { package: hash[:justme] }
 93     return nil
 94   end
 95 
 96   list = output.collect do |line|
 97     next if line =~ /installed\s+catalog/  # header of package list
 98     next if noise?(line)
 99 
100     pkgsplit(line)
101   end.reject { |h| h.nil? }
102 
103   if hash[:justme]
104     # Single queries may have been for an alias so return the name requested
105     if list.any?
106       list[-1][:name] = hash[:justme]
107       return list[-1]
108     end
109   else
110     list.reject! { |h| h[:ensure] == :absent }
111     return list
112   end
113 end

    # File lib/puppet/provider/package/yum.rb
129 def self.parse_updates(str)
130   # Strip off all content that contains Obsoleting, Security: or Update
131   body = str.partition(/^(Obsoleting|Security:|Update)/).first
132 
133   updates = Hash.new { |h, k| h[k] = [] }
134 
135   body.split(/^\s*\n/).each do |line|
136     line.split.each_slice(3) do |tuple|
137       next unless tuple[0].include?('.') && tuple[1] =~ VERSION_REGEX
138 
139       hash = update_to_hash(*tuple[0..1])
140       # Create entries for both the package name without a version and a
141       # version since yum considers those as mostly interchangeable.
142       short_name = hash[:name]
143       long_name  = "#{hash[:name]}.#{hash[:arch]}"
144       updates[short_name] << hash
145       updates[long_name] << hash
146     end
147   end
148   updates
149 end

    # File lib/puppet/provider/user/directoryservice.rb
483 def self.password_hash_dir
484   '/var/db/shadow/hash'
485 end

   # File lib/puppet/provider/user/aix.rb
52 def pgrp_to_gid(provider, pgrp)
53   group = group_provider.find(pgrp, provider.ia_module_args)
54 
55   group[:gid]
56 end

   # File lib/puppet/provider/package/pip.rb
46 def self.pip_version(command)
47   version = nil
48   execpipe [quote(command), '--version'] do |process|
49     process.collect do |line|
50       md = line.strip.match(/^pip (\d+\.\d+\.?\d*).*$/)
51       if md
52         version = md[1]
53         break
54       end
55     end
56   end
57 
58   raise Puppet::Error, _("Cannot resolve pip version") unless version
59 
60   version
61 end

   # File lib/puppet/provider/package/pkg.rb
88 def self.pkg_state(state)
89   case state
90   when /installed/
91     {:status => 'installed'}
92   when /known/
93     {:status => 'known'}
94   else
95     raise ArgumentError, _('Unknown format %{resource_name}: %{state}') % { resource_name: self.name, state: state }
96   end
97 end

    # File lib/puppet/provider/package/aix.rb
117 def self.pkglist(hash = {})
118   cmd = [command(:lslpp), "-qLc"]
119 
120   name = hash[:pkgname]
121   if name
122     cmd << name
123   end
124 
125   begin
126     list = execute(cmd).scan(/^[^#][^:]*:([^:]*):([^:]*):[^:]*:[^:]*:([^:])/).collect { |n,e,s|
127       e = :absent if [:broken, :inconsistent].include?(STATE_CODE[s])
128       { :name => n, :ensure => e, :status => STATE_CODE[s], :provider => self.name }
129     }
130   rescue Puppet::ExecutionFailure => detail
131     if hash[:pkgname]
132       return nil
133     else
134       raise Puppet::Error, _("Could not list installed Packages: %{detail}") % { detail: detail }, detail.backtrace
135     end
136   end
137 
138   if hash[:pkgname]
139     return list.shift
140   else
141     return list
142   end
143 end

    # File lib/puppet/provider/package/pkgutil.rb
126 def self.pkgsplit(line)
127   if line =~ /\s*(\S+)\s+(\S+)\s+(.*)/
128     hash = {}
129     hash[:name] = $1
130     hash[:ensure] = if $2 == "notinst"
131       :absent
132     else
133       $2
134     end
135     hash[:avail] = $3
136 
137     if hash[:avail] =~ /^SAME\s*$/
138       hash[:avail] = hash[:ensure]
139     end
140 
141     # Use the name method, so it works with subclasses.
142     hash[:provider] = self.name
143 
144     return hash
145   else
146     Puppet.warning _("Cannot match %{line}") % { line: line }
147     return nil
148   end
149 end

   # File lib/puppet/provider/file/posix.rb
14 def self.post_resource_eval
15   Selinux.matchpathcon_fini if Puppet::Util::SELinux.selinux_support?
16 end

   # File lib/puppet/provider/package/aix.rb
46 def self.prefetch(packages)
47   raise Puppet::Error, _("The aix provider can only be used by root") if Process.euid != 0
48 
49   return unless packages.detect { |name, package| package.should(:ensure) == :latest }
50 
51   sources = packages.collect { |name, package| package[:source] }.uniq.compact
52 
53   updates = {}
54   sources.each do |source|
55     execute(self.srclistcmd(source)).each_line do |line|
56       if line =~ /^[^#][^:]*:([^:]*):([^:]*)/
57         current = {}
58         current[:name]    = $1
59         current[:version] = $2
60         current[:source]  = source
61 
62         if updates.key?(current[:name])
63           previous = updates[current[:name]]
64 
65           updates[current[:name]] = current unless Puppet::Util::Package.versioncmp(previous[:version], current[:version]) == 1
66 
67         else
68           updates[current[:name]] = current
69         end
70       end
71     end
72   end
73 
74   packages.each do |name, package|
75     if updates.key?(name)
76       package.provider.latest_info = updates[name]
77     end
78   end
79 end

   # File lib/puppet/provider/package/gem.rb
39 def self.provider_command
40   if Puppet::Util::Platform.windows?
41     Puppet::Util.withenv(PATH: windows_path_without_puppet_bin) { command(:gemcmd) }
42   else
43     command(:gemcmd)
44   end
45 end

    # File lib/puppet/provider/package/pip.rb
327 def self.quote(path)
328   if path.include?(" ")
329     "\"#{path}\""
330   else
331     path
332   end
333 end

    # File lib/puppet/provider/service/launchd.rb
202 def self.read_overrides
203   i = 1
204   overrides = nil
205   loop do
206     Puppet.debug(_("Reading overrides plist, attempt %{i}") % {i: i}) if i > 1
207     overrides = read_plist(launchd_overrides)
208     break unless overrides.nil?
209     raise Puppet::Error.new(_('Unable to read overrides plist, too many attempts')) if i == 20
210     Puppet.info(_('Overrides file could not be read, trying again.'))
211     Kernel.sleep(0.1)
212     i += 1
213   end
214   overrides
215 end

    # File lib/puppet/provider/service/launchd.rb
197 def self.read_plist(path)
198   Puppet::Util::Plist.read_plist_file(path)
199 end

    # File lib/puppet/type/file.rb
656 def self.remove_less_specific_files(files, parent_path, existing_files, &block)
657   # REVISIT: is this Windows safe?  AltSeparator?
658   mypath = parent_path.split(::File::Separator)
659   other_paths = existing_files.
660     select { |r| (yield r) != parent_path}.
661     collect { |r| (yield r).split(::File::Separator) }.
662     select  { |p| p[0,mypath.length]  == mypath }
663 
664   return files if other_paths.empty?
665 
666   files.reject { |file|
667     path = (yield file).split(::File::Separator)
668     other_paths.any? { |p| path[0,p.length] == p }
669     }
670 end

   # File lib/puppet/provider/package/zypper.rb
19 def self.reset!
20   @latest_versions = nil
21 end

    # File lib/puppet/type/resources.rb
184 def self.reset_system_users_max_uid!
185   @system_users_max_uid = nil
186 end

    # File lib/puppet/provider/service/launchd.rb
123 def self.return_globbed_list_of_file_paths(path)
124   array_of_files = Dir.glob(File.join(path, '*')).collect do |filepath|
125     File.file?(filepath) ? filepath : nil
126   end
127   array_of_files.compact
128 end

   # File lib/puppet/provider/package/gem.rb
27 def self.specificity
28   match = default_match
29   length = match ? match.length : 0
30 
31   return 1 if length == 0
32 
33   super
34 end

   # File lib/puppet/provider/package/aix.rb
42 def self.srclistcmd(source)
43   [ command(:installp), "-L", "-d", source ]
44 end

  # File lib/puppet/util/log/destinations.rb
3 def self.suitable?(obj)
4   Puppet.features.syslog?
5 end

    # File lib/puppet/type/resources.rb
163 def self.system_users_max_uid
164   return @system_users_max_uid if @system_users_max_uid
165 
166   # First try to read the minimum user id from login.defs
167   if Puppet::FileSystem.exist?('/etc/login.defs')
168     @system_users_max_uid = Puppet::FileSystem.each_line '/etc/login.defs' do |line|
169       break $1.to_i - 1 if line =~ /^\s*UID_MIN\s+(\d+)(\s*#.*)?$/
170     end
171   end
172 
173   # Otherwise, use a sensible default based on the OS family
174   @system_users_max_uid ||= case Puppet.runtime[:facter].value('os.family')
175     when 'OpenBSD', 'FreeBSD'
176       999
177     else
178       499
179   end
180 
181   @system_users_max_uid
182 end

   # File lib/puppet/type/file.rb
45 def self.title_patterns
46   # strip trailing slashes from path but allow the root directory, including
47   # for example "/" or "C:/"
48   [ [ %r{^(/|.+:/|.*[^/])/*\Z}m, [ [ :path ] ] ] ]
49 end

   # File lib/puppet/provider/package/windows.rb
57 def self.to_hash(pkg)
58   {
59     :name     => pkg.name,
60     :ensure   => pkg.version || :installed,
61     :provider => :windows
62   }
63 end

    # File lib/puppet/provider/package/pacman.rb
187 def self.to_resource_hash(name, version)
188   {
189     :name     => name,
190     :ensure   => version,
191     :provider => self.name
192   }
193 end

   # File lib/puppet/provider/package/pkg.rb
78 def self.ufoxi_flag(flags)
79   {}
80 end

   # File lib/puppet/provider/package/dnf.rb
37 def self.update_command
38   # In DNF, update is deprecated for upgrade
39   'upgrade'
40 end

    # File lib/puppet/provider/package/yum.rb
151 def self.update_to_hash(pkgname, pkgversion)
152 
153   # The pkgname string has two parts: name, and architecture. Architecture
154   # is the portion of the string following the last "." character. All
155   # characters preceding the final dot are the package name. Parse out
156   # these two pieces of component data.
157   name, _, arch = pkgname.rpartition('.')
158   if name.empty?
159     raise _("Failed to parse package name and architecture from '%{pkgname}'") % { pkgname: pkgname }
160   end
161 
162   match = pkgversion.match(VERSION_REGEX)
163   epoch = match[1] || '0'
164   version = match[2]
165   release = match[3]
166 
167   {
168     :name => name,
169     :epoch => epoch,
170     :version => version,
171     :release => release,
172     :arch    => arch,
173   }
174 end

   # File lib/puppet/provider/group/aix.rb
73 def users_to_members(users)
74   users.split(',')
75 end

   # File lib/puppet/provider/package/puppet_gem.rb
10 def self.windows_gemcmd
11   puppet_dir = ENV['PUPPET_DIR']
12   if puppet_dir
13     File.join(ENV['PUPPET_DIR'].to_s, 'bin', 'gem.bat')
14   else
15     File.join(Gem.default_bindir, 'gem.bat')
16   end
17 end

   # File lib/puppet/provider/package/gem.rb
58 def self.windows_path_without_puppet_bin
59   @path ||= ENV['PATH'].split(File::PATH_SEPARATOR)
60                        .reject { |dir| dir =~ /puppet\\bin$/ }
61                        .join(File::PATH_SEPARATOR)
62 end

   # File lib/puppet/provider/package/pacman.rb
13 def self.yaourt?
14   @yaourt ||= Puppet::FileSystem.exist?('/usr/bin/yaourt')
15 end

   # File lib/puppet/type/component.rb
17 def [](param)
18   return super if self.class.valid_parameter?(param)
19   @extra_parameters[param.to_sym]
20 end

   # File lib/puppet/type/component.rb
24 def []=(param, value)
25   return super if self.class.valid_parameter?(param)
26   @extra_parameters[param.to_sym] = value
27 end

  # File lib/puppet/gettext/stubs.rb
5 def _(msg)
6   msg
7 end

    # File lib/puppet/type/resources.rb
107 def able_to_ensure_absent?(resource)
108     resource[:ensure] = :absent
109 rescue ArgumentError, Puppet::Error
110     err _("The 'ensure' attribute on %{name} resources does not accept 'absent' as a value") % { name: self[:name] }
111     false
112 end

    # File lib/puppet/provider/service/upstart.rb
367 def add_default_start_to(text)
368   text + "\nstart on runlevel [2,3,4,5]"
369 end

   # File lib/puppet/provider/user/user_role_add.rb
49 def add_properties
50   cmd = []
51   Puppet::Type.type(:user).validproperties.each do |property|
52     #skip the password because we can't create it with the solaris useradd
53     next if [:ensure, :password, :password_min_age, :password_max_age, :password_warn_days].include?(property)
54     # 1680 Now you can set the hashed passwords on solaris:lib/puppet/provider/user/user_role_add.rb
55     # the value needs to be quoted, mostly because -c might
56     # have spaces in it
57     value = @resource.should(property)
58     if value && value != ""
59       if property == :keys
60         cmd += build_keys_cmd(value)
61       else
62         cmd << flag(property) << value
63       end
64     end
65   end
66   cmd
67 end

   # File lib/puppet/provider/group/groupadd.rb
61 def addcmd
62   if @resource.forcelocal?
63     cmd = [command(:localadd)]
64     @custom_environment = Puppet::Util::Libuser.getenv
65   else
66     cmd = [command(:add)]
67   end
68 
69   gid = @resource.should(:gid)
70   if gid
71     unless gid == :absent
72       cmd << flag(:gid) << gid
73     end
74   end
75   cmd += check_allow_dup
76   cmd << "-r" if @resource.system? and self.class.system_groups?
77   cmd << @resource[:name]
78   cmd
79 end

   # File lib/puppet/functions/alert.rb
12 def alert(scope, *values)
13   Puppet::Util::Log.log_func(scope, :alert, values)
14 end

   # File lib/puppet/functions/all.rb
92 def all_Enumerable_1(enumerable)
93   Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable).all? { |e| yield(e) }
94 end

    # File lib/puppet/functions/all.rb
 96 def all_Enumerable_2(enumerable)
 97   enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
 98   if enum.hash_style?
 99     enum.all? { |entry| yield(*entry) }
100   else
101     enum.each_with_index { |e, i| return false unless yield(i, e) }
102     true
103   end
104 end

   # File lib/puppet/functions/all.rb
84 def all_Hash_1(hash)
85   hash.each_pair.all? { |x| yield(x) }
86 end

   # File lib/puppet/functions/all.rb
88 def all_Hash_2(hash)
89   hash.each_pair.all? { |x,y| yield(x,y) }
90 end

    # File lib/puppet/face/help.rb
161 def all_application_summaries()
162   available_application_names_special_sort().inject([]) do |result, appname|
163     next result if exclude_from_docs?(appname)
164 
165     if (appname == COMMON || appname == SPECIALIZED || appname == BLANK)
166       result << appname
167     elsif (is_face_app?(appname))
168       begin
169         face = Puppet::Face[appname, :current]
170         # Add deprecation message to summary if the face is deprecated
171         summary = face.deprecated? ? face.summary + ' ' + _("(Deprecated)") : face.summary
172         result << [appname, summary, '  ']
173       rescue StandardError, LoadError
174         error_message = _("!%{sub_command}! Subcommand unavailable due to error.") % { sub_command: appname }
175         error_message += ' ' + _("Check error logs.")
176         result << [ error_message, '', '  ' ]
177       end
178     else
179       begin
180         summary = Puppet::Application[appname].summary
181         if summary.empty?
182           summary = horribly_extract_summary_from(appname)
183         end
184         result << [appname, summary, '  ']
185       rescue StandardError, LoadError
186         error_message = _("!%{sub_command}! Subcommand unavailable due to error.") % { sub_command: appname }
187         error_message += ' ' + _("Check error logs.")
188         result << [ error_message, '', '  ' ]
189       end
190     end
191   end
192 end

   # File lib/puppet/network/formats.rb
27 def allowed_yaml_classes
28   @allowed_yaml_classes ||= [
29     Puppet::Node::Facts,
30     Puppet::Node,
31     Puppet::Transaction::Report,
32     Puppet::Resource,
33     Puppet::Resource::Catalog
34   ]
35 end

    # File lib/puppet/type/file.rb
537 def ancestors
538   ancestors = Pathname.new(self[:path]).enum_for(:ascend).map(&:to_s)
539   ancestors.delete(self[:path])
540   ancestors
541 end

   # File lib/puppet/functions/annotate.rb
90 def annotate(type, value, &block)
91   type.implementation_class.annotate(value, &block)
92 end

    # File lib/puppet/functions/annotate.rb
106 def annotate_multi(type, value, annotations)
107   type.implementation_class.annotate(value, annotations)
108 end

    # File lib/puppet/functions/annotate.rb
 98 def annotate_new(type, value, annotation_hash)
 99   type.implementation_class.annotate_new(value, annotation_hash)
100 end

   # File lib/puppet/functions/any.rb
97 def any_Enumerable_1(enumerable)
98   Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable).any? { |e| yield(e) }
99 end

    # File lib/puppet/functions/any.rb
101 def any_Enumerable_2(enumerable)
102   enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
103   if enum.hash_style?
104     enum.any? { |entry| yield(*entry) }
105   else
106     enum.each_with_index { |e, i| return true if yield(i, e) }
107     false
108   end
109 end

   # File lib/puppet/functions/any.rb
89 def any_Hash_1(hash)
90   hash.each_pair.any? { |x| yield(x) }
91 end

   # File lib/puppet/functions/any.rb
93 def any_Hash_2(hash)
94   hash.each_pair.any? { |x,y| yield(x, y) }
95 end

   # File lib/puppet/provider/package/aptitude.rb
12 def aptget(*args)
13   args.flatten!
14   # Apparently aptitude hasn't always supported a -q flag.
15   args.delete("-q") if args.include?("-q")
16   args.delete("--force-yes") if args.include?("--force-yes")
17   output = aptitude(*args)
18 
19   # Yay, stupid aptitude doesn't throw an error when the package is missing.
20   if args.include?(:install) and output.to_s =~ /Couldn't find any package/
21     raise Puppet::Error.new(
22       _("Could not find package %{name}") % { name: self.name }
23     )
24   end
25 end

    # File lib/puppet/functions/max.rb
247 def assert_arg_count(args)
248   raise(ArgumentError, 'max(): Wrong number of arguments need at least one') if args.empty?
249 end

    # File lib/puppet/provider/user/directoryservice.rb
471 def assert_full_pbkdf2_password
472   missing = [:password, :salt, :iterations].select { |parameter| @resource[parameter].nil? }
473 
474   if !missing.empty?
475      raise Puppet::Error, "OS X versions > 10\.7 use PBKDF2 password hashes, which requires all three of salt, iterations, and password hash. This resource is missing: #{missing.join(', ')}."
476   end
477 end

   # File lib/puppet/functions/assert_type.rb
70 def assert_type(type, value)
71   unless Puppet::Pops::Types::TypeCalculator.instance?(type,value)
72     inferred_type = Puppet::Pops::Types::TypeCalculator.infer_set(value)
73     if block_given?
74       # Give the inferred type to allow richer comparison in the given block (if generalized
75       # information is lost).
76       #
77       value = yield(type, inferred_type)
78     else
79       raise Puppet::Pops::Types::TypeAssertionError.new(
80         Puppet::Pops::Types::TypeMismatchDescriber.singleton.describe_mismatch('assert_type():', type, inferred_type),
81         type, inferred_type)
82     end
83   end
84   value
85 end