RubyGems - bolt - Versions diffs - 0.19.1 → 0.20.0 - Mend

bolt 0.19.1 → 0.20.0

Potentially problematic release.

This version of bolt might be problematic. Click here for more details.

Files changed (1261) hide show

data/vendored/puppet/lib/puppet/provider/naginator.rb DELETED

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

data/vendored/puppet/lib/puppet/provider/nameservice.rb DELETED

@@ -1,325 +0,0 @@
-require 'puppet'
-# This is the parent class of all NSS classes.  They're very different in
-# their backend, but they're pretty similar on the front-end.  This class
-# provides a way for them all to be as similar as possible.
-class Puppet::Provider::NameService < Puppet::Provider
-  class << self
-    def autogen_default(param)
-      defined?(@autogen_defaults) ? @autogen_defaults[param.intern] : nil
-    end
-    def autogen_defaults(hash)
-      @autogen_defaults ||= {}
-      hash.each do |param, value|
-        @autogen_defaults[param.intern] = value
-      end
-    end
-    def initvars
-      @checks = {}
-      @options = {}
-      super
-    end
-    def instances
-      objects = []
-      begin
-        method = Puppet::Etc.method(:"get#{section}ent")
-        while ent = method.call
-          objects << new(:name => ent.name, :canonical_name => ent.canonical_name, :ensure => :present)
-        end
-      ensure
-        Puppet::Etc.send("end#{section}ent")
-      end
-      objects
-    end
-    def option(name, option)
-      name = name.intern if name.is_a? String
-      (defined?(@options) and @options.include? name and @options[name].include? option) ? @options[name][option] : nil
-    end
-    def options(name, hash)
-      unless resource_type.valid_parameter?(name)
-        raise Puppet::DevError, _("%{name} is not a valid attribute for %{resource_type}") % { name: name, resource_type: resource_type.name }
-      end
-      @options ||= {}
-      @options[name] ||= {}
-      # Set options individually, so we can call the options method
-      # multiple times.
-      hash.each do |param, value|
-        @options[name][param] = value
-      end
-    end
-    # List everything out by name.  Abstracted a bit so that it works
-    # for both users and groups.
-    def listbyname
-      Puppet.deprecation_warning(_("listbyname is deprecated and will be removed in a future release of Puppet. Please use `self.instances` to obtain a list of users."))
-      names = []
-      Puppet::Etc.send("set#{section()}ent")
-      begin
-        while ent = Puppet::Etc.send("get#{section()}ent")
-          names << ent.name
-          yield ent.name if block_given?
-        end
-      ensure
-        Puppet::Etc.send("end#{section()}ent")
-      end
-      names
-    end
-    def resource_type=(resource_type)
-      super
-      @resource_type.validproperties.each do |prop|
-        next if prop == :ensure
-        define_method(prop) { get(prop) || :absent} unless public_method_defined?(prop)
-        define_method(prop.to_s + "=") { |*vals| set(prop, *vals) } unless public_method_defined?(prop.to_s + "=")
-      end
-    end
-    # This is annoying, but there really aren't that many options,
-    # and this *is* built into Ruby.
-    def section
-      unless resource_type
-        raise Puppet::DevError,
-          "Cannot determine Etc section without a resource type"
-      end
-      if @resource_type.name == :group
-        "gr"
-      else
-        "pw"
-      end
-    end
-    def validate(name, value)
-      name = name.intern if name.is_a? String
-      if @checks.include? name
-        block = @checks[name][:block]
-        raise ArgumentError, _("Invalid value %{value}: %{error}") % { value: value, error: @checks[name][:error] } unless block.call(value)
-      end
-    end
-    def verify(name, error, &block)
-      name = name.intern if name.is_a? String
-      @checks[name] = {:error => error, :block => block}
-    end
-    private
-    def op(property)
-      @ops[property.name] || ("-#{property.name}")
-    end
-  end
-  # Autogenerate a value.  Mostly used for uid/gid, but also used heavily
-  # with DirectoryServices
-  def autogen(field)
-    field = field.intern
-    id_generators = {:user => :uid, :group => :gid}
-    if id_generators[@resource.class.name] == field
-      return self.class.autogen_id(field, @resource.class.name)
-    else
-      if value = self.class.autogen_default(field)
-        return value
-      elsif respond_to?("autogen_#{field}")
-        return send("autogen_#{field}")
-      else
-        return nil
-      end
-    end
-  end
-  # Autogenerate either a uid or a gid.  This is not very flexible: we can
-  # only generate one field type per class, and get kind of confused if asked
-  # for both.
-  def self.autogen_id(field, resource_type)
-    # Figure out what sort of value we want to generate.
-    case resource_type
-    when :user;   database = :passwd;  method = :uid
-    when :group;  database = :group;   method = :gid
-    else
-      #TRANSLATORS "autogen_id()" is a method name and should not be translated
-      raise Puppet::DevError, _("autogen_id() does not support auto generation of id for resource type %{resource_type}") % { resource_type: resource_type }
-    end
-    # Initialize from the data set, if needed.
-    unless @prevauto
-      # Sadly, Etc doesn't return an enumerator, it just invokes the block
-      # given, or returns the first record from the database.  There is no
-      # other, more convenient enumerator for these, so we fake one with this
-      # loop.  Thanks, Ruby, for your awesome abstractions. --daniel 2012-03-23
-      highest = []
-      Puppet::Etc.send(database) {|entry| highest << entry.send(method) }
-      highest = highest.reject {|x| x > 65000 }.max
-      @prevauto = highest || 1000
-    end
-    # ...and finally increment and return the next value.
-    @prevauto += 1
-  end
-  def create
-    if exists?
-      info _("already exists")
-      # The object already exists
-      return nil
-    end
-    begin
-      execute(self.addcmd, {:failonfail => true, :combine => true, :custom_environment => @custom_environment})
-      if feature?(:manages_password_age) && (cmd = passcmd)
-        execute(cmd, {:failonfail => true, :combine => true, :custom_environment => @custom_environment})
-      end
-    rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error, _("Could not create %{resource} %{name}: %{detail}") % { resource: @resource.class.name, name: @resource.name, detail: detail }, detail.backtrace
-    end
-  end
-  def delete
-    unless exists?
-      info _("already absent")
-      # the object already doesn't exist
-      return nil
-    end
-    begin
-      execute(self.deletecmd, {:failonfail => true, :combine => true, :custom_environment => @custom_environment})
-    rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error, _("Could not delete %{resource} %{name}: %{detail}") % { resource: @resource.class.name, name: @resource.name, detail: detail }, detail.backtrace
-    end
-  end
-  def ensure
-    if exists?
-      :present
-    else
-      :absent
-    end
-  end
-  # Does our object exist?
-  def exists?
-    !!getinfo(true)
-  end
-  # Retrieve a specific value by name.
-  def get(param)
-    (hash = getinfo(false)) ? unmunge(param, hash[param]) : nil
-  end
-  def munge(name, value)
-    if block = self.class.option(name, :munge) and block.is_a? Proc
-      block.call(value)
-    else
-      value
-    end
-  end
-  def unmunge(name, value)
-    if block = self.class.option(name, :unmunge) and block.is_a? Proc
-      block.call(value)
-    else
-      value
-    end
-  end
-  # Retrieve what we can about our object
-  def getinfo(refresh)
-    if @objectinfo.nil? or refresh == true
-      @etcmethod ||= ("get" + self.class.section.to_s + "nam").intern
-      begin
-        @objectinfo = Puppet::Etc.send(@etcmethod, @canonical_name)
-      rescue ArgumentError
-        @objectinfo = nil
-      end
-    end
-    # Now convert our Etc struct into a hash.
-    @objectinfo ? info2hash(@objectinfo) : nil
-  end
-  # The list of all groups the user is a member of.  Different
-  # user mgmt systems will need to override this method.
-  def groups
-    groups = []
-    # Reset our group list
-    Puppet::Etc.setgrent
-    user = @resource[:name]
-    # Now iterate across all of the groups, adding each one our
-    # user is a member of
-    while group = Puppet::Etc.getgrent
-      members = group.mem
-      groups << group.name if members.include? user
-    end
-    # We have to close the file, so each listing is a separate
-    # reading of the file.
-    Puppet::Etc.endgrent
-    uniq_groups = groups.uniq
-    if groups != uniq_groups
-      debug("Removing any duplicate group entries")
-    end
-    # remove any double listed groups
-    uniq_groups.join(",")
-  end
-  # Convert the Etc struct into a hash.
-  def info2hash(info)
-    hash = {}
-    self.class.resource_type.validproperties.each do |param|
-      method = posixmethod(param)
-      hash[param] = info.send(posixmethod(param)) if info.respond_to? method
-    end
-    hash
-  end
-  def initialize(resource)
-    super
-    @custom_environment = {}
-    @objectinfo = nil
-    if resource.is_a?(Hash) && !resource[:canonical_name].nil?
-      @canonical_name = resource[:canonical_name]
-    else
-      @canonical_name = resource[:name]
-    end
-  end
-  def set(param, value)
-    self.class.validate(param, value)
-    cmd = modifycmd(param, munge(param, value))
-    raise Puppet::DevError, _("Nameservice command must be an array") unless cmd.is_a?(Array)
-    begin
-      execute(cmd, {:failonfail => true, :combine => true, :custom_environment => @custom_environment})
-    rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error, _("Could not set %{param} on %{resource}[%{name}]: %{detail}") % { param: param, resource: @resource.class.name, name: @resource.name, detail: detail }, detail.backtrace
-    end
-  end
-  # From overriding Puppet::Property#insync? Ruby Etc::getpwnam < 2.1.0 always
-  # returns a struct with binary encoded string values, and >= 2.1.0 will return
-  # binary encoded strings for values incompatible with current locale charset,
-  # or Encoding.default_external if compatible. Compare a "should" value with
-  # encoding of "current" value, to avoid unnecessary property syncs and
-  # comparison of strings with different encodings. (PUP-6777)
-  #
-  # return basic string comparison after re-encoding (same as
-  # Puppet::Property#property_matches)
-  def comments_insync?(current, should)
-    # we're only doing comparison here so don't mutate the string
-    desired = should[0].to_s.dup
-    current == desired.force_encoding(current.encoding)
-  end
-end

data/vendored/puppet/lib/puppet/provider/nameservice/directoryservice.rb DELETED

@@ -1,508 +0,0 @@
-require 'puppet'
-require 'puppet/provider/nameservice'
-require 'puppet/util/plist' if Puppet.features.cfpropertylist?
-require 'fileutils'
-class Puppet::Provider::NameService::DirectoryService < Puppet::Provider::NameService
-  # JJM: Dive into the singleton_class
-  class << self
-    # JJM: This allows us to pass information when calling
-    #      Puppet::Type.type
-    #  e.g. Puppet::Type.type(:user).provide :directoryservice, :ds_path => "Users"
-    #  This is referenced in the get_ds_path class method
-    attr_writer :ds_path
-  end
-  initvars
-  commands :dscl => "/usr/bin/dscl"
-  commands :dseditgroup => "/usr/sbin/dseditgroup"
-  commands :sw_vers => "/usr/bin/sw_vers"
-  confine :operatingsystem => :darwin
-  confine :feature         => :cfpropertylist
-  defaultfor :operatingsystem => :darwin
-  # There is no generalized mechanism for provider cache management, but we can
-  # use post_resource_eval, which will be run for each suitable provider at the
-  # end of each transaction. Use this to clear @all_present after each run.
-  def self.post_resource_eval
-    @all_present = nil
-  end
-  # JJM 2007-07-25: This map is used to map NameService attributes to their
-  #     corresponding DirectoryService attribute names.
-  #     See: http://images.apple.com/server/docs.Open_Directory_v10.4.pdf
-  # JJM: Note, this is de-coupled from the Puppet::Type, and must
-  #     be actively maintained.  There may also be collisions with different
-  #     types (Users, Groups, Mounts, Hosts, etc...)
-  def ds_to_ns_attribute_map; self.class.ds_to_ns_attribute_map; end
-  def self.ds_to_ns_attribute_map
-    {
-      'RecordName' => :name,
-      'PrimaryGroupID' => :gid,
-      'NFSHomeDirectory' => :home,
-      'UserShell' => :shell,
-      'UniqueID' => :uid,
-      'RealName' => :comment,
-      'Password' => :password,
-      'GeneratedUID' => :guid,
-      'IPAddress'    => :ip_address,
-      'ENetAddress'  => :en_address,
-      'GroupMembership' => :members,
-    }
-  end
-  # JJM The same table as above, inverted.
-  def ns_to_ds_attribute_map; self.class.ns_to_ds_attribute_map end
-  def self.ns_to_ds_attribute_map
-    @ns_to_ds_attribute_map ||= ds_to_ns_attribute_map.invert
-  end
-  def self.password_hash_dir
-    '/var/db/shadow/hash'
-  end
-  def self.users_plist_dir
-    '/var/db/dslocal/nodes/Default/users'
-  end
-  def self.instances
-    # JJM Class method that provides an array of instance objects of this
-    #     type.
-    # JJM: Properties are dependent on the Puppet::Type we're managing.
-    type_property_array = [:name] + @resource_type.validproperties
-    # Create a new instance of this Puppet::Type for each object present
-    #    on the system.
-    list_all_present.collect do |name_string|
-      self.new(single_report(name_string, *type_property_array))
-    end
-  end
-  def self.get_ds_path
-    # JJM: 2007-07-24 This method dynamically returns the DS path we're concerned with.
-    #      For example, if we're working with an user type, this will be /Users
-    #      with a group type, this will be /Groups.
-    #   @ds_path is an attribute of the class itself.
-    return @ds_path if defined?(@ds_path)
-    # JJM: "Users" or "Groups" etc ...  (Based on the Puppet::Type)
-    #       Remember this is a class method, so self.class is Class
-    #       Also, @resource_type seems to be the reference to the
-    #       Puppet::Type this class object is providing for.
-    @resource_type.name.to_s.capitalize + "s"
-  end
-  def self.list_all_present
-    @all_present ||= begin
-      # JJM: List all objects of this Puppet::Type already present on the system.
-      begin
-        dscl_output = execute(get_exec_preamble("-list"))
-      rescue Puppet::ExecutionFailure
-        fail(_("Could not get %{resource} list from DirectoryService") % { resource: @resource_type.name })
-      end
-      dscl_output.split("\n")
-    end
-  end
-  def self.parse_dscl_plist_data(dscl_output)
-    Puppet::Util::Plist.parse_plist(dscl_output)
-  end
-  def self.generate_attribute_hash(input_hash, *type_properties)
-    attribute_hash = {}
-    input_hash.each_key do |key|
-      ds_attribute = key.sub("dsAttrTypeStandard:", "")
-      next unless (ds_to_ns_attribute_map.keys.include?(ds_attribute) and type_properties.include? ds_to_ns_attribute_map[ds_attribute])
-      ds_value = input_hash[key]
-      case ds_to_ns_attribute_map[ds_attribute]
-        when :members
-          ds_value = ds_value # only members uses arrays so far
-        when :gid, :uid
-          # OS X stores objects like uid/gid as strings.
-          # Try casting to an integer for these cases to be
-          # consistent with the other providers and the group type
-          # validation
-          begin
-            ds_value = Integer(ds_value[0])
-          rescue ArgumentError
-            ds_value = ds_value[0]
-          end
-        else ds_value = ds_value[0]
-      end
-      attribute_hash[ds_to_ns_attribute_map[ds_attribute]] = ds_value
-    end
-    # NBK: need to read the existing password here as it's not actually
-    # stored in the user record. It is stored at a path that involves the
-    # UUID of the user record for non-Mobile local accounts.
-    # Mobile Accounts are out of scope for this provider for now
-    attribute_hash[:password] = self.get_password(attribute_hash[:guid], attribute_hash[:name]) if @resource_type.validproperties.include?(:password) and Puppet.features.root?
-    attribute_hash
-  end
-  def self.single_report(resource_name, *type_properties)
-    # JJM 2007-07-24:
-    #     Given a the name of an object and a list of properties of that
-    #     object, return all property values in a hash.
-    #
-    #     This class method returns nil if the object doesn't exist
-    #     Otherwise, it returns a hash of the object properties.
-    all_present_str_array = list_all_present
-    # NBK: shortcut the process if the resource is missing
-    return nil unless all_present_str_array.include? resource_name
-    dscl_vector = get_exec_preamble("-read", resource_name)
-    begin
-      dscl_output = execute(dscl_vector)
-    rescue Puppet::ExecutionFailure
-      fail(_("Could not get report.  command execution failed."))
-    end
-    dscl_plist = self.parse_dscl_plist_data(dscl_output)
-    self.generate_attribute_hash(dscl_plist, *type_properties)
-  end
-  def self.get_exec_preamble(ds_action, resource_name = nil)
-    # JJM 2007-07-24
-    #     DSCL commands are often repetitive and contain the same positional
-    #     arguments over and over. See https://developer.apple.com/documentation/Porting/Conceptual/PortingUnix/additionalfeatures/chapter_10_section_9.html
-    #     for an example of what I mean.
-    #     This method spits out proper DSCL commands for us.
-    #     We EXPECT name to be @resource[:name] when called from an instance object.
-    command_vector = [ command(:dscl), "-plist", "." ]
-    # JJM: The actual action to perform. See "man dscl".
-    #      Common actions: -create, -delete, -merge, -append, -passwd
-    command_vector << ds_action
-    # JJM: get_ds_path will spit back "Users" or "Groups",
-    # etc...  Depending on the Puppet::Type of our self.
-    if resource_name
-      command_vector << "/#{get_ds_path}/#{resource_name}"
-    else
-      command_vector << "/#{get_ds_path}"
-    end
-    # JJM:  This returns most of the preamble of the command.
-    #       e.g. 'dscl / -create /Users/mccune'
-    command_vector
-  end
-  def self.set_password(resource_name, guid, password_hash)
-    # 10.7 uses salted SHA512 password hashes which are 128 characters plus
-    # an 8 character salt. Previous versions used a SHA1 hash padded with
-    # zeroes. If someone attempts to use a password hash that worked with
-    # a previous version of OS X, we will fail early and warn them.
-    if password_hash.length != 136
-      #TRANSLATORS 'OS X 10.7' is an operating system and should not be translated, 'Salted SHA512' is the name of a hashing algorithm
-      fail(_("OS X 10.7 requires a Salted SHA512 hash password of 136 characters.") +
-           ' ' + _("Please check your password and try again."))
-    end
-    plist_file = "#{users_plist_dir}/#{resource_name}.plist"
-    if Puppet::FileSystem.exist?(plist_file)
-      # If a plist already exists in /var/db/dslocal/nodes/Default/users, then
-      # we will need to extract the binary plist from the 'ShadowHashData'
-      # key, log the new password into the resultant plist's 'SALTED-SHA512'
-      # key, and then save the entire structure back.
-      users_plist = Puppet::Util::Plist.read_plist_file(plist_file)
-      # users_plist['ShadowHashData'][0] is actually a binary plist
-      # that's nested INSIDE the user's plist (which itself is a binary
-      # plist). If we encounter a user plist that DOESN'T have a
-      # ShadowHashData field, create one.
-      if users_plist['ShadowHashData']
-        password_hash_plist = users_plist['ShadowHashData'][0]
-        converted_hash_plist = convert_binary_to_hash(password_hash_plist)
-      else
-        users_plist['ShadowHashData'] = ''
-        converted_hash_plist = {'SALTED-SHA512' => ''}
-      end
-      # converted_hash_plist['SALTED-SHA512'] expects a Base64 encoded
-      # string. The password_hash provided as a resource attribute is a
-      # hex value. We need to convert the provided hex value to a Base64
-      # encoded string to nest it in the converted hash plist.
-      converted_hash_plist['SALTED-SHA512'] = \
-        password_hash.unpack('a2'*(password_hash.size/2)).collect { |i| i.hex.chr }.join
-      # Finally, we can convert the nested plist back to binary, embed it
-      # into the user's plist, and convert the resultant plist back to
-      # a binary plist.
-      changed_plist = convert_hash_to_binary(converted_hash_plist)
-      users_plist['ShadowHashData'][0] = changed_plist
-      Puppet::Util::Plist.write_plist_file(users_plist, plist_file, :binary)
-    end
-  end
-  def self.get_password(guid, username)
-    plist_file = "#{users_plist_dir}/#{username}.plist"
-    if Puppet::FileSystem.exist?(plist_file)
-      # If a plist exists in /var/db/dslocal/nodes/Default/users, we will
-      # extract the binary plist from the 'ShadowHashData' key, decode the
-      # salted-SHA512 password hash, and then return it.
-      users_plist = Puppet::Util::Plist.read_plist_file(plist_file)
-      if users_plist['ShadowHashData']
-        # users_plist['ShadowHashData'][0] is actually a binary plist
-        # that's nested INSIDE the user's plist (which itself is a binary
-        # plist).
-        password_hash_plist = users_plist['ShadowHashData'][0]
-        converted_hash_plist = convert_binary_to_hash(password_hash_plist)
-        # converted_hash_plist['SALTED-SHA512'] is a Base64 encoded
-        # string. The password_hash provided as a resource attribute is a
-        # hex value. We need to convert the Base64 encoded string to a
-        # hex value and provide it back to Puppet.
-        password_hash = converted_hash_plist['SALTED-SHA512'].unpack("H*")[0]
-        password_hash
-      end
-    end
-  end
-  # This method will accept a hash and convert it to a binary plist (string value).
-  def self.convert_hash_to_binary(plist_data)
-    Puppet.debug('Converting plist hash to binary')
-    Puppet::Util::Plist.dump_plist(plist_data, :binary)
-  end
-  # This method will accept a binary plist (as a string) and convert it to a hash.
-  def self.convert_binary_to_hash(plist_data)
-    Puppet.debug('Converting binary plist to hash')
-    Puppet::Util::Plist.parse_plist(plist_data)
-  end
-  # Unlike most other *nixes, OS X doesn't provide built in functionality
-  # for automatically assigning uids and gids to accounts, so we set up these
-  # methods for consumption by functionality like --mkusers
-  # By default we restrict to a reasonably sane range for system accounts
-  def self.next_system_id(id_type, min_id=20)
-    dscl_args = ['.', '-list']
-    if id_type == 'uid'
-      dscl_args << '/Users' << 'uid'
-    elsif id_type == 'gid'
-      dscl_args << '/Groups' << 'gid'
-    else
-      fail(_("Invalid id_type %{id_type}. Only 'uid' and 'gid' supported") % { id_type: id_type })
-    end
-    dscl_out = dscl(dscl_args)
-    # We're ok with throwing away negative uids here.
-    ids = dscl_out.split.compact.collect { |l| l.to_i if l.match(/^\d+$/) }
-    ids.compact!.sort! { |a,b| a.to_f <=> b.to_f }
-    # We're just looking for an unused id in our sorted array.
-    ids.each_index do |i|
-      next_id = ids[i] + 1
-      return next_id if ids[i+1] != next_id and next_id >= min_id
-    end
-  end
-  def ensure=(ensure_value)
-    super
-    # We need to loop over all valid properties for the type we're
-    # managing and call the method which sets that property value
-    # dscl can't create everything at once unfortunately.
-    if ensure_value == :present
-      @resource.class.validproperties.each do |name|
-        next if name == :ensure
-        # LAK: We use property.sync here rather than directly calling
-        # the settor method because the properties might do some kind
-        # of conversion.  In particular, the user gid property might
-        # have a string and need to convert it to a number
-        if @resource.should(name)
-          @resource.property(name).sync
-        elsif value = autogen(name)
-          self.send(name.to_s + "=", value)
-        else
-          next
-        end
-      end
-    end
-  end
-  def password=(passphrase)
-    exec_arg_vector = self.class.get_exec_preamble("-read", @resource.name)
-    exec_arg_vector << ns_to_ds_attribute_map[:guid]
-    begin
-      guid_output = execute(exec_arg_vector)
-      guid_plist = Puppet::Util::Plist.parse_plist(guid_output)
-      # Although GeneratedUID like all DirectoryService values can be multi-valued
-      # according to the schema, in practice user accounts cannot have multiple UUIDs
-      # otherwise Bad Things Happen, so we just deal with the first value.
-      guid = guid_plist["dsAttrTypeStandard:#{ns_to_ds_attribute_map[:guid]}"][0]
-      self.class.set_password(@resource.name, guid, passphrase)
-    rescue Puppet::ExecutionFailure => detail
-      fail(_("Could not set %{param} on %{resource}[%{name}]: %{detail}") % { param: param, resource: @resource.class.name, name: @resource.name, detail: detail })
-    end
-  end
-  # NBK: we override @parent.set as we need to execute a series of commands
-  # to deal with array values, rather than the single command nameservice.rb
-  # expects to be returned by modifycmd. Thus we don't bother defining modifycmd.
-  def set(param, value)
-    self.class.validate(param, value)
-    current_members = @property_value_cache_hash[:members]
-    if param == :members
-      # If we are meant to be authoritative for the group membership
-      # then remove all existing members who haven't been specified
-      # in the manifest.
-      remove_unwanted_members(current_members, value) if @resource[:auth_membership] and not current_members.nil?
-      # if they're not a member, make them one.
-      add_members(current_members, value)
-    else
-      exec_arg_vector = self.class.get_exec_preamble("-create", @resource[:name])
-      # JJM: The following line just maps the NS name to the DS name
-      #      e.g. { :uid => 'UniqueID' }
-      exec_arg_vector << ns_to_ds_attribute_map[param.intern]
-      # JJM: The following line sends the actual value to set the property to
-      exec_arg_vector << value.to_s
-      begin
-        execute(exec_arg_vector)
-      rescue Puppet::ExecutionFailure => detail
-        fail(_("Could not set %{param} on %{resource}[%{name}]: %{detail}") % { param: param, resource: @resource.class.name, name: @resource.name, detail: detail })
-      end
-    end
-  end
-  # NBK: we override @parent.create as we need to execute a series of commands
-  # to create objects with dscl, rather than the single command nameservice.rb
-  # expects to be returned by addcmd. Thus we don't bother defining addcmd.
-  def create
-    if exists?
-      info _("already exists")
-      return nil
-    end
-    # NBK: First we create the object with a known guid so we can set the contents
-    # of the password hash if required
-    # Shelling out sucks, but for a single use case it doesn't seem worth
-    # requiring people install a UUID library that doesn't come with the system.
-    # This should be revisited if Puppet starts managing UUIDs for other platform
-    # user records.
-    guid = %x{/usr/bin/uuidgen}.chomp
-    exec_arg_vector = self.class.get_exec_preamble("-create", @resource[:name])
-    exec_arg_vector << ns_to_ds_attribute_map[:guid] << guid
-    begin
-      execute(exec_arg_vector)
-    rescue Puppet::ExecutionFailure => detail
-      fail(_("Could not set GeneratedUID for %{resource} %{name}: %{detail}") % { resource: @resource.class.name, name: @resource.name, detail: detail })
-    end
-    if value = @resource.should(:password) and value != ""
-      self.class.set_password(@resource[:name], guid, value)
-    end
-    # Now we create all the standard properties
-    Puppet::Type.type(@resource.class.name).validproperties.each do |property|
-      next if property == :ensure
-      value = @resource.should(property)
-      if property == :gid and value.nil?
-        value = self.class.next_system_id('gid')
-      end
-      if property == :uid and value.nil?
-        value = self.class.next_system_id('uid')
-      end
-      if value != "" and not value.nil?
-        if property == :members
-          add_members(nil, value)
-        else
-          exec_arg_vector = self.class.get_exec_preamble("-create", @resource[:name])
-          exec_arg_vector << ns_to_ds_attribute_map[property.intern]
-          next if property == :password  # skip setting the password here
-          exec_arg_vector << value.to_s
-          begin
-            execute(exec_arg_vector)
-          rescue Puppet::ExecutionFailure => detail
-            fail(_("Could not create %{resource} %{name}: %{detail}") % { resource: @resource.class.name, name: @resource.name, detail: detail })
-          end
-        end
-      end
-    end
-  end
-  def remove_unwanted_members(current_members, new_members)
-    current_members.each do |member|
-      if not new_members.flatten.include?(member)
-        cmd = [:dseditgroup, "-o", "edit", "-n", ".", "-d", member, @resource[:name]]
-        begin
-          execute(cmd)
-        rescue Puppet::ExecutionFailure
-          # TODO: We're falling back to removing the member using dscl due to rdar://8481241
-          # This bug causes dseditgroup to fail to remove a member if that member doesn't exist
-          cmd = [:dscl, ".", "-delete", "/Groups/#{@resource.name}", "GroupMembership", member]
-          begin
-            execute(cmd)
-          rescue Puppet::ExecutionFailure => detail
-            fail(_("Could not remove %{member} from group: %{resource}, %{detail}") % { member: member, resource: @resource.name, detail: detail })
-          end
-        end
-      end
-    end
-  end
-  def add_members(current_members, new_members)
-    new_members.flatten.each do |new_member|
-      if current_members.nil? or not current_members.include?(new_member)
-        cmd = [:dseditgroup, "-o", "edit", "-n", ".", "-a", new_member, @resource[:name]]
-        begin
-          execute(cmd)
-        rescue Puppet::ExecutionFailure => detail
-          fail(_("Could not add %{new_member} to group: %{name}, %{detail}") % { new_member: new_member, name: @resource.name, detail: detail })
-        end
-      end
-    end
-  end
-  def deletecmd
-    # JJM: Like addcmd, only called when deleting the object itself
-    #    Note, this isn't used to delete properties of the object,
-    #    at least that's how I understand it...
-    self.class.get_exec_preamble("-delete", @resource[:name])
-  end
-  def getinfo(refresh = false)
-    # JJM 2007-07-24:
-    #      Override the getinfo method, which is also defined in nameservice.rb
-    #      This method returns and sets @infohash
-    # I'm not re-factoring the name "getinfo" because this method will be
-    # most likely called by nameservice.rb, which I didn't write.
-    if refresh or (! defined?(@property_value_cache_hash) or ! @property_value_cache_hash)
-      # JJM 2007-07-24: OK, there's a bit of magic that's about to
-      # happen... Let's see how strong my grip has become... =)
-      #
-      # self is a provider instance of some Puppet::Type, like
-      # Puppet::Type::User::ProviderDirectoryservice for the case of the
-      # user type and this provider.
-      #
-      # self.class looks like "user provider directoryservice", if that
-      # helps you ...
-      #
-      # self.class.resource_type is a reference to the Puppet::Type class,
-      # probably Puppet::Type::User or Puppet::Type::Group, etc...
-      #
-      # self.class.resource_type.validproperties is a class method,
-      # returning an Array of the valid properties of that specific
-      # Puppet::Type.
-      #
-      # So... something like [:comment, :home, :password, :shell, :uid,
-      # :groups, :ensure, :gid]
-      #
-      # Ultimately, we add :name to the list, delete :ensure from the
-      # list, then report on the remaining list. Pretty whacky, ehh?
-      type_properties = [:name] + self.class.resource_type.validproperties
-      type_properties.delete(:ensure) if type_properties.include? :ensure
-      type_properties << :guid  # append GeneratedUID so we just get the report here
-      @property_value_cache_hash = self.class.single_report(@resource[:name], *type_properties)
-      [:uid, :gid].each do |param|
-        @property_value_cache_hash[param] = @property_value_cache_hash[param].to_i if @property_value_cache_hash and @property_value_cache_hash.include?(param)
-      end
-    end
-    @property_value_cache_hash
-  end
-end