puppet 0.25.5 → 2.6.0

data/lib/puppet/indirector/key/ca.rb

@@ -2,11 +2,11 @@ require 'puppet/indirector/ssl_file'
 require 'puppet/ssl/key'
 
 class Puppet::SSL::Key::Ca < Puppet::Indirector::SslFile
-    desc "Manage the CA's private on disk.  This terminus *only* works
-        with the CA key, because that's the only key that the CA ever interacts
-        with."
+  desc "Manage the CA's private on disk.  This terminus *only* works
+    with the CA key, because that's the only key that the CA ever interacts
+    with."
 
-    store_in :privatekeydir
+  store_in :privatekeydir
 
-    store_ca_at :cakey
+  store_ca_at :cakey
 end

data/lib/puppet/indirector/key/file.rb

@@ -2,41 +2,41 @@ require 'puppet/indirector/ssl_file'
 require 'puppet/ssl/key'
 
 class Puppet::SSL::Key::File < Puppet::Indirector::SslFile
-    desc "Manage SSL private and public keys on disk."
-
-    store_in :privatekeydir
-    store_ca_at :cakey
-
-    # Where should we store the public key?
-    def public_key_path(name)
-        if ca?(name)
-            Puppet[:capub]
-        else
-            File.join(Puppet[:publickeydir], name.to_s + ".pem")
-        end
+  desc "Manage SSL private and public keys on disk."
+
+  store_in :privatekeydir
+  store_ca_at :cakey
+
+  # Where should we store the public key?
+  def public_key_path(name)
+    if ca?(name)
+      Puppet[:capub]
+    else
+      File.join(Puppet[:publickeydir], name.to_s + ".pem")
     end
+  end
 
-    # Remove the public key, in addition to the private key
-    def destroy(request)
-        super
+  # Remove the public key, in addition to the private key
+  def destroy(request)
+    super
 
-        return unless FileTest.exist?(public_key_path(request.key))
+    return unless FileTest.exist?(public_key_path(request.key))
 
-        begin
-            File.unlink(public_key_path(request.key))
-        rescue => detail
-            raise Puppet::Error, "Could not remove %s public key: %s" % [request.key, detail]
-        end
+    begin
+      File.unlink(public_key_path(request.key))
+    rescue => detail
+      raise Puppet::Error, "Could not remove #{request.key} public key: #{detail}"
     end
+  end
 
-    # Save the public key, in addition to the private key.
-    def save(request)
-        super
+  # Save the public key, in addition to the private key.
+  def save(request)
+    super
 
-        begin
-            Puppet.settings.writesub(:publickeydir, public_key_path(request.key)) { |f| f.print request.instance.content.public_key.to_pem }
-        rescue => detail
-            raise Puppet::Error, "Could not write %s: %s" % [request.key, detail]
-        end
+    begin
+      Puppet.settings.writesub(:publickeydir, public_key_path(request.key)) { |f| f.print request.instance.content.public_key.to_pem }
+    rescue => detail
+      raise Puppet::Error, "Could not write #{request.key}: #{detail}"
     end
+  end
 end

data/lib/puppet/indirector/ldap.rb

@@ -2,79 +2,77 @@ require 'puppet/indirector/terminus'
 require 'puppet/util/ldap/connection'
 
 class Puppet::Indirector::Ldap < Puppet::Indirector::Terminus
-    # Perform our ldap search and process the result.
-    def find(request)
-        return ldapsearch(search_filter(request.key)) { |entry| return process(entry) } || nil
-    end
+  # Perform our ldap search and process the result.
+  def find(request)
+    ldapsearch(search_filter(request.key)) { |entry| return process(entry) } || nil
+  end
 
-    # Process the found entry.  We assume that we don't just want the
-    # ldap object.
-    def process(entry)
-        raise Puppet::DevError, "The 'process' method has not been overridden for the LDAP terminus for %s" % self.name
-    end
+  # Process the found entry.  We assume that we don't just want the
+  # ldap object.
+  def process(entry)
+    raise Puppet::DevError, "The 'process' method has not been overridden for the LDAP terminus for #{self.name}"
+  end
 
-    # Default to all attributes.
-    def search_attributes
-        nil
-    end
+  # Default to all attributes.
+  def search_attributes
+    nil
+  end
 
-    def search_base
-        Puppet[:ldapbase]
-    end
+  def search_base
+    Puppet[:ldapbase]
+  end
 
-    # The ldap search filter to use.
-    def search_filter(name)
-        raise Puppet::DevError, "No search string set for LDAP terminus for %s" % self.name
-    end
-
-    # Find the ldap node, return the class list and parent node specially,
-    # and everything else in a parameter hash.
-    def ldapsearch(filter)
-        raise ArgumentError.new("You must pass a block to ldapsearch") unless block_given?
+  # The ldap search filter to use.
+  def search_filter(name)
+    raise Puppet::DevError, "No search string set for LDAP terminus for #{self.name}"
+  end
 
-        found = false
-        count = 0
+  # Find the ldap node, return the class list and parent node specially,
+  # and everything else in a parameter hash.
+  def ldapsearch(filter)
+    raise ArgumentError.new("You must pass a block to ldapsearch") unless block_given?
 
-        begin
-            connection.search(search_base, 2, filter, search_attributes) do |entry|
-                found = true
-                yield entry
-            end
-        rescue SystemExit,NoMemoryError
-            raise
-        rescue Exception => detail
-            if count == 0
-                # Try reconnecting to ldap if we get an exception and we haven't yet retried.
-                count += 1
-                @connection = nil
-                Puppet.warning "Retrying LDAP connection"
-                retry
-            else
-                error = Puppet::Error.new("LDAP Search failed")
-                error.set_backtrace(detail.backtrace)
-                raise error
-            end
-        end
+    found = false
+    count = 0
 
-        return found
+    begin
+      connection.search(search_base, 2, filter, search_attributes) do |entry|
+        found = true
+        yield entry
+      end
+    rescue SystemExit,NoMemoryError
+      raise
+    rescue Exception => detail
+      if count == 0
+        # Try reconnecting to ldap if we get an exception and we haven't yet retried.
+        count += 1
+        @connection = nil
+        Puppet.warning "Retrying LDAP connection"
+        retry
+      else
+        error = Puppet::Error.new("LDAP Search failed")
+        error.set_backtrace(detail.backtrace)
+        raise error
+      end
     end
 
-    # Create an ldap connection.
-    def connection
-        unless defined? @connection and @connection
-            unless Puppet.features.ldap?
-                raise Puppet::Error, "Could not set up LDAP Connection: Missing ruby/ldap libraries"
-            end
-            begin
-                conn = Puppet::Util::Ldap::Connection.instance
-                conn.start
-                @connection = conn.connection
-            rescue => detail
-                puts detail.backtrace if Puppet[:trace]
-                raise Puppet::Error, "Could not connect to LDAP: %s" % detail
-            end
-        end
+    found
+  end
 
-        return @connection
+  # Create an ldap connection.
+  def connection
+    unless @connection
+      raise Puppet::Error, "Could not set up LDAP Connection: Missing ruby/ldap libraries" unless Puppet.features.ldap?
+      begin
+        conn = Puppet::Util::Ldap::Connection.instance
+        conn.start
+        @connection = conn.connection
+      rescue => detail
+        puts detail.backtrace if Puppet[:trace]
+        raise Puppet::Error, "Could not connect to LDAP: #{detail}"
+      end
     end
+
+    @connection
+  end
 end

data/lib/puppet/indirector/memory.rb

@@ -2,20 +2,20 @@ require 'puppet/indirector/terminus'
 
 # Manage a memory-cached list of instances.
 class Puppet::Indirector::Memory < Puppet::Indirector::Terminus
-    def initialize
-        @instances = {}
-    end
+  def initialize
+    @instances = {}
+  end
 
-    def destroy(request)
-        raise ArgumentError.new("Could not find %s to destroy" % request.key) unless @instances.include?(request.key)
-        @instances.delete(request.key)
-    end
+  def destroy(request)
+    raise ArgumentError.new("Could not find #{request.key} to destroy") unless @instances.include?(request.key)
+    @instances.delete(request.key)
+  end
 
-    def find(request)
-        @instances[request.key]
-    end
+  def find(request)
+    @instances[request.key]
+  end
 
-    def save(request)
-        @instances[request.key] = request.instance
-    end
+  def save(request)
+    @instances[request.key] = request.instance
+  end
 end

data/lib/puppet/indirector/node/active_record.rb

@@ -3,11 +3,11 @@ require 'puppet/indirector/active_record'
 require 'puppet/node'
 
 class Puppet::Node::ActiveRecord < Puppet::Indirector::ActiveRecord
-    use_ar_model Puppet::Rails::Host
+  use_ar_model Puppet::Rails::Host
 
-    def find(request)
-        node = super
-        node.fact_merge
-        node
-    end
+  def find(request)
+    node = super
+    node.fact_merge
+    node
+  end
 end

data/lib/puppet/indirector/node/exec.rb

@@ -2,51 +2,47 @@ require 'puppet/node'
 require 'puppet/indirector/exec'
 
 class Puppet::Node::Exec < Puppet::Indirector::Exec
-    desc "Call an external program to get node information.  See
-    the `ExternalNodes`:trac: page for more information."
-    include Puppet::Util
-
-    def command
-        command = Puppet[:external_nodes]
-        unless command != "none"
-            raise ArgumentError, "You must set the 'external_nodes' parameter to use the external node terminus"
-        end
-        command.split
+  desc "Call an external program to get node information.  See
+  the `ExternalNodes`:trac: page for more information."
+  include Puppet::Util
+
+  def command
+    command = Puppet[:external_nodes]
+    raise ArgumentError, "You must set the 'external_nodes' parameter to use the external node terminus" unless command != "none"
+    command.split
+  end
+
+  # Look for external node definitions.
+  def find(request)
+    output = super or return nil
+
+    # Translate the output to ruby.
+    result = translate(request.key, output)
+
+    create_node(request.key, result)
+  end
+
+  private
+
+  # Turn our outputted objects into a Puppet::Node instance.
+  def create_node(name, result)
+    node = Puppet::Node.new(name)
+    set = false
+    [:parameters, :classes, :environment].each do |param|
+      if value = result[param]
+        node.send(param.to_s + "=", value)
+        set = true
+      end
     end
 
-    # Look for external node definitions.
-    def find(request)
-        output = super or return nil
+    node.fact_merge
+    node
+  end
 
-        # Translate the output to ruby.
-        result = translate(request.key, output)
-
-        return create_node(request.key, result)
-    end
-
-    private
-
-    # Turn our outputted objects into a Puppet::Node instance.
-    def create_node(name, result)
-        node = Puppet::Node.new(name)
-        set = false
-        [:parameters, :classes, :environment].each do |param|
-            if value = result[param]
-                node.send(param.to_s + "=", value)
-                set = true
-            end
-        end
-
-        node.fact_merge
-        return node
-    end
-
-    # Translate the yaml string into Ruby objects.
-    def translate(name, output)
-        begin
-            YAML.load(output).inject({}) { |hash, data| hash[symbolize(data[0])] = data[1]; hash }
-        rescue => detail
-            raise Puppet::Error, "Could not load external node results for %s: %s" % [name, detail]
-        end
-    end
+  # Translate the yaml string into Ruby objects.
+  def translate(name, output)
+      YAML.load(output).inject({}) { |hash, data| hash[symbolize(data[0])] = data[1]; hash }
+  rescue => detail
+      raise Puppet::Error, "Could not load external node results for #{name}: #{detail}"
+  end
 end

data/lib/puppet/indirector/node/ldap.rb

@@ -2,265 +2,299 @@ require 'puppet/node'
 require 'puppet/indirector/ldap'
 
 class Puppet::Node::Ldap < Puppet::Indirector::Ldap
-    desc "Search in LDAP for node configuration information.  See
-    the `LdapNodes`:trac: page for more information.  This will first
-    search for whatever the certificate name is, then (if that name
-    contains a '.') for the short name, then 'default'."
-
-    # The attributes that Puppet class information is stored in.
-    def class_attributes
-        # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
-        x = Puppet[:ldapclassattrs].split(/\s*,\s*/)
+  desc "Search in LDAP for node configuration information.  See
+  the `LdapNodes`:trac: page for more information.  This will first
+  search for whatever the certificate name is, then (if that name
+  contains a '.') for the short name, then 'default'."
+
+  # The attributes that Puppet class information is stored in.
+  def class_attributes
+    # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
+    x = Puppet[:ldapclassattrs].split(/\s*,\s*/)
+  end
+
+  # Separate this out so it's relatively atomic.  It's tempting to call
+  # process instead of name2hash() here, but it ends up being
+  # difficult to test because all exceptions get caught by ldapsearch.
+  # LAK:NOTE Unfortunately, the ldap support is too stupid to throw anything
+  # but LDAP::ResultError, even on bad connections, so we are rough handed
+  # with our error handling.
+  def name2hash(name,name_env,node_type)
+    info = nil
+    ldapsearch(search_filter(name)) {
+      |entry| info = entry2hash(entry)
+      if info[:environment]
+        if name_env == info[:environment]
+          return info
+          else
+            info = nil
+          end
+          else
+          info_env = "production"
+          if name_env == info[:environment]
+            return info
+          else
+            info = nil
+          end
+          end
+        }
+    if node_type == 'parent'
+      raise Puppet::Error.new("Could not find node '#{name}' with environment '#{name_env}'")
     end
 
-    # Separate this out so it's relatively atomic.  It's tempting to call
-    # process() instead of name2hash() here, but it ends up being
-    # difficult to test because all exceptions get caught by ldapsearch.
-    # LAK:NOTE Unfortunately, the ldap support is too stupid to throw anything
-    # but LDAP::ResultError, even on bad connections, so we are rough handed
-    # with our error handling.
-    def name2hash(name)
-        info = nil
-        ldapsearch(search_filter(name)) { |entry| info = entry2hash(entry) }
-        return info
+    info = name2hash('default',name_env,'parent')
+  end
+
+  # Look for our node in ldap.
+  def find(request)
+    names = [request.key]
+    names << request.key.sub(/\..+/, '') if request.key.include?(".") # we assume it's an fqdn
+    names << "default"
+
+    node = nil
+    names.each do |name|
+      facts = Puppet::Node::Facts.find(name)
+      if facts.values["environment"]
+        name_env = facts.values["environment"]
+      else
+        name_env = "production"
+      end
+      info = name2hash(name,name_env,'child')
+      next if info == nil
+
+      if info
+        break if node = info2node(request.key, info)
+      end
     end
 
-    # Look for our node in ldap.
-    def find(request)
-        names = [request.key]
-        if request.key.include?(".") # we assume it's an fqdn
-            names << request.key.sub(/\..+/, '')
-        end
-        names << "default"
-
-        node = nil
-        names.each do |name|
-            next unless info = name2hash(name)
-
-            break if node = info2node(request.key, info)
-        end
-
-        return node
+    node
+  end
+
+  # Find more than one node.  LAK:NOTE This is a bit of a clumsy API, because the 'search'
+  # method currently *requires* a key.  It seems appropriate in some cases but not others,
+  # and I don't really know how to get rid of it as a requirement but allow it when desired.
+  def search(request)
+    if classes = request.options[:class]
+      classes = [classes] unless classes.is_a?(Array)
+      filter = "(&(objectclass=puppetClient)(puppetclass=" + classes.join(")(puppetclass=") + "))"
+    else
+      filter = "(objectclass=puppetClient)"
     end
 
-    # Find more than one node.  LAK:NOTE This is a bit of a clumsy API, because the 'search'
-    # method currently *requires* a key.  It seems appropriate in some cases but not others,
-    # and I don't really know how to get rid of it as a requirement but allow it when desired.
-    def search(request)
-        if classes = request.options[:class]
-            classes = [classes] unless classes.is_a?(Array)
-            filter = "(&(objectclass=puppetClient)(puppetclass=" + classes.join(")(puppetclass=") + "))"
-        else
-            filter = "(objectclass=puppetClient)"
-        end
-
-        infos = []
-        ldapsearch(filter) { |entry| infos << entry2hash(entry, request.options[:fqdn]) }
+    infos = []
+    ldapsearch(filter) { |entry| infos << entry2hash(entry, request.options[:fqdn]) }
 
-        return infos.collect do |info|
-            info2node(info[:name], info)
-        end
+    return infos.collect do |info|
+      info2node(info[:name], info)
     end
-
-    # The parent attribute, if we have one.
-    def parent_attribute
-        if pattr = Puppet[:ldapparentattr] and ! pattr.empty?
-            pattr
-        else
-            nil
-        end
+  end
+
+  # The parent attribute, if we have one.
+  def parent_attribute
+    if pattr = Puppet[:ldapparentattr] and ! pattr.empty?
+      pattr
+    else
+      nil
     end
-
-    # The attributes that Puppet will stack as array over the full
-    # hierarchy.
-    def stacked_attributes(dummy_argument=:work_arround_for_ruby_GC_bug)
-        Puppet[:ldapstackedattrs].split(/\s*,\s*/)
+  end
+
+  # The attributes that Puppet will stack as array over the full
+  # hierarchy.
+  def stacked_attributes(dummy_argument=:work_arround_for_ruby_GC_bug)
+    Puppet[:ldapstackedattrs].split(/\s*,\s*/)
+  end
+
+  # Convert the found entry into a simple hash.
+  def entry2hash(entry, fqdn = false)
+    result = {}
+
+    cn  = entry.dn[     /cn\s*=\s*([^,\s]+)/i,1]
+    dcs = entry.dn.scan(/dc\s*=\s*([^,\s]+)/i)
+    result[:name]    = fqdn ? ([cn]+dcs).join('.') : cn
+    result[:parent] = get_parent_from_entry(entry) if parent_attribute
+    result[:classes] = get_classes_from_entry(entry)
+    result[:stacked] = get_stacked_values_from_entry(entry)
+    result[:parameters] = get_parameters_from_entry(entry)
+
+    result[:environment] = result[:parameters]["environment"] if result[:parameters]["environment"]
+
+    result[:stacked_parameters] = {}
+
+    if result[:stacked]
+      result[:stacked].each do |value|
+        param = value.split('=', 2)
+        result[:stacked_parameters][param[0]] = param[1]
+      end
     end
 
-    # Convert the found entry into a simple hash.
-    def entry2hash(entry, fqdn = false)
-        result = {}
-
-        cn  = entry.dn[     /cn\s*=\s*([^,\s]+)/i,1]
-        dcs = entry.dn.scan(/dc\s*=\s*([^,\s]+)/i)
-        result[:name]    = fqdn ? ([cn]+dcs).join('.') : cn
-        result[:parent] = get_parent_from_entry(entry) if parent_attribute
-        result[:classes] = get_classes_from_entry(entry)
-        result[:stacked] = get_stacked_values_from_entry(entry)
-        result[:parameters] = get_parameters_from_entry(entry)
+    if result[:stacked_parameters]
+      result[:stacked_parameters].each do |param, value|
+        result[:parameters][param] = value unless result[:parameters].include?(param)
+      end
+    end
 
-        result[:environment] = result[:parameters]["environment"] if result[:parameters]["environment"]
+    result[:parameters] = convert_parameters(result[:parameters])
 
-        result[:stacked_parameters] = {}
+    result
+  end
 
-        if result[:stacked]
-            result[:stacked].each do |value|
-                param = value.split('=', 2)
-                result[:stacked_parameters][param[0]] = param[1]
-            end
-        end
+  # Default to all attributes.
+  def search_attributes
+    ldapattrs = Puppet[:ldapattrs]
 
-        if result[:stacked_parameters]
-            result[:stacked_parameters].each do |param, value|
-                result[:parameters][param] = value unless result[:parameters].include?(param)
-            end
-        end
+    # results in everything getting returned
+    return nil if ldapattrs == "all"
 
-        result[:parameters] = convert_parameters(result[:parameters])
+    search_attrs = class_attributes + ldapattrs.split(/\s*,\s*/)
 
-        result
+    if pattr = parent_attribute
+      search_attrs << pattr
     end
 
-    # Default to all attributes.
-    def search_attributes
-        ldapattrs = Puppet[:ldapattrs]
-
-        # results in everything getting returned
-        return nil if ldapattrs == "all"
+    search_attrs
+  end
 
-        search_attrs = class_attributes + ldapattrs.split(/\s*,\s*/)
-
-        if pattr = parent_attribute
-            search_attrs << pattr
-        end
+  # The ldap search filter to use.
+  def search_filter(name)
+    filter = Puppet[:ldapstring]
 
-        search_attrs
+    if filter.include? "%s"
+      # Don't replace the string in-line, since that would hard-code our node
+      # info.
+      filter = filter.gsub('%s', name)
     end
-
-    # The ldap search filter to use.
-    def search_filter(name)
-        filter = Puppet[:ldapstring]
-
-        if filter.include? "%s"
-            # Don't replace the string in-line, since that would hard-code our node
-            # info.
-            filter = filter.gsub('%s', name)
-        end
-        filter
+    filter
+  end
+
+  private
+
+  # Add our hash of ldap information to the node instance.
+  def add_to_node(node, information)
+    node.classes = information[:classes].uniq unless information[:classes].nil? or information[:classes].empty?
+    node.parameters = information[:parameters] unless information[:parameters].nil? or information[:parameters].empty?
+    node.environment = information[:environment] if information[:environment]
+  end
+
+  def convert_parameters(parameters)
+    result = {}
+    parameters.each do |param, value|
+      if value.is_a?(Array)
+        result[param] = value.collect { |v| convert(v) }
+      else
+        result[param] = convert(value)
+      end
     end
+    result
+  end
+
+  # Convert any values if necessary.
+  def convert(value)
+    case value
+    when Integer, Fixnum, Bignum; value
+    when "true"; true
+    when "false"; false
+    else
+      value
+    end
+  end
 
-    private
+  # Find information for our parent and merge it into the current info.
+  def find_and_merge_parent(parent, information)
 
-    # Add our hash of ldap information to the node instance.
-    def add_to_node(node, information)
-        node.classes = information[:classes].uniq unless information[:classes].nil? or information[:classes].empty?
-        node.parameters = information[:parameters] unless information[:parameters].nil? or information[:parameters].empty?
-        node.environment = information[:environment] if information[:environment]
+    if information[:environment]
+      name_env = information[:environment]
+    else
+      name_env = 'production'
     end
 
-    def convert_parameters(parameters)
-        result = {}
-        parameters.each do |param, value|
-            if value.is_a?(Array)
-                result[param] = value.collect { |v| convert(v) }
-            else
-                result[param] = convert(value)
-            end
-        end
-        result
+    parent_info = name2hash(parent,name_env,'parent')
+    if parent_info
+    information[:classes] += parent_info[:classes]
+    parent_info[:parameters].each do |param, value|
+      # Specifically test for whether it's set, so false values are handled
+      # correctly.
+      information[:parameters][param] = value unless information[:parameters].include?(param)
     end
 
-    # Convert any values if necessary.
-    def convert(value)
-        case value
-        when Integer, Fixnum, Bignum; value
-        when "true"; true
-        when "false"; false
-        else
-            value
-        end
+    information[:environment] ||= parent_info[:environment]
+    parent_info[:parent]
+    else
+    raise Puppet::Error.new("Could not find parent node '#{parent}'")
+    nil
     end
 
-    # Find information for our parent and merge it into the current info.
-    def find_and_merge_parent(parent, information)
-        unless parent_info = name2hash(parent)
-            raise Puppet::Error.new("Could not find parent node '%s'" % parent)
-        end
-        information[:classes] += parent_info[:classes]
-        parent_info[:parameters].each do |param, value|
-            # Specifically test for whether it's set, so false values are handled
-            # correctly.
-            information[:parameters][param] = value unless information[:parameters].include?(param)
-        end
+  end
 
-        information[:environment] ||= parent_info[:environment]
+  # Take a name and a hash, and return a node instance.
+  def info2node(name, info)
+    merge_parent(info) if info[:parent]
 
-        parent_info[:parent]
-    end
+    node = Puppet::Node.new(name)
 
-    # Take a name and a hash, and return a node instance.
-    def info2node(name, info)
-        merge_parent(info) if info[:parent]
+    add_to_node(node, info)
 
-        node = Puppet::Node.new(name)
+    node.fact_merge
 
-        add_to_node(node, info)
+    node
+  end
 
-        node.fact_merge
+  def merge_parent(info)
+    parent_info = nil
+    parent = info[:parent]
 
-        node
+    # Preload the parent array with the node name.
+    parents = [info[:name]]
+    while parent
+      raise ArgumentError, "Found loop in LDAP node parents; #{parent} appears twice" if parents.include?(parent)
+      parents << parent
+      parent = find_and_merge_parent(parent, info)
     end
 
-    def merge_parent(info)
-        parent_info = nil
-        parent = info[:parent]
-
-        # Preload the parent array with the node name.
-        parents = [info[:name]]
-        while parent
-            if parents.include?(parent)
-                raise ArgumentError, "Found loop in LDAP node parents; %s appears twice" % parent
-            end
-            parents << parent
-            parent = find_and_merge_parent(parent, info)
-        end
+    info
+  end
 
-        return info
+  def get_classes_from_entry(entry)
+    result = class_attributes.inject([]) do |array, attr|
+      if values = entry.vals(attr)
+        values.each do |v| array << v end
+      end
+      array
     end
-
-    def get_classes_from_entry(entry)
-        result = class_attributes.inject([]) do |array, attr|
-            if values = entry.vals(attr)
-                values.each do |v| array << v end
-            end
-            array
-        end
-        result.uniq
-    end
-
-    def get_parameters_from_entry(entry)
-        stacked_params = stacked_attributes
-        entry.to_hash.inject({}) do |hash, ary|
-            unless stacked_params.include?(ary[0]) # don't add our stacked parameters to the main param list
-                if ary[1].length == 1
-                    hash[ary[0]] = ary[1].shift
-                else
-                    hash[ary[0]] = ary[1]
-                end
-            end
-            hash
+    result.uniq
+  end
+
+  def get_parameters_from_entry(entry)
+    stacked_params = stacked_attributes
+    entry.to_hash.inject({}) do |hash, ary|
+      unless stacked_params.include?(ary[0]) # don't add our stacked parameters to the main param list
+        if ary[1].length == 1
+          hash[ary[0]] = ary[1].shift
+        else
+          hash[ary[0]] = ary[1]
         end
+      end
+      hash
     end
+  end
 
-    def get_parent_from_entry(entry)
-        pattr = parent_attribute
+  def get_parent_from_entry(entry)
+    pattr = parent_attribute
 
-        return nil unless values = entry.vals(pattr)
+    return nil unless values = entry.vals(pattr)
 
-        if values.length > 1
-            raise Puppet::Error,
-                "Node entry %s specifies more than one parent: %s" % [entry.dn, values.inspect]
-        end
-        return nil if values.empty?
-        return values.shift
+    if values.length > 1
+      raise Puppet::Error,
+        "Node entry #{entry.dn} specifies more than one parent: #{values.inspect}"
     end
-
-    def get_stacked_values_from_entry(entry)
-        stacked_attributes.inject([]) do |result, attr|
-            if values = entry.vals(attr)
-                result += values
-            end
-            result
-        end
+    return(values.empty? ? nil : values.shift)
+  end
+
+  def get_stacked_values_from_entry(entry)
+    stacked_attributes.inject([]) do |result, attr|
+      if values = entry.vals(attr)
+        result += values
+      end
+      result
     end
+  end
 end