puppet 0.25.5 → 2.6.0

data/lib/puppet/indirector/status.rb

@@ -0,0 +1,3 @@
+# A stub class, so our constants work.
+class Puppet::Indirector::Status
+end

data/lib/puppet/indirector/status/local.rb

@@ -0,0 +1,7 @@
+require 'puppet/indirector/status'
+
+class Puppet::Indirector::Status::Local < Puppet::Indirector::Code
+  def find( *anything )
+    model.new
+  end
+end

data/lib/puppet/indirector/status/rest.rb

@@ -0,0 +1,5 @@
+require 'puppet/indirector/status'
+require 'puppet/indirector/rest'
+
+class Puppet::Indirector::Status::Rest < Puppet::Indirector::REST
+end

data/lib/puppet/indirector/terminus.rb

@@ -4,149 +4,145 @@ require 'puppet/util/instance_loader'
 
 # A simple class that can function as the base class for indirected types.
 class Puppet::Indirector::Terminus
-    require 'puppet/util/docs'
-    extend Puppet::Util::Docs
-
-    class << self
-        include Puppet::Util::InstanceLoader
-
-        attr_accessor :name, :terminus_type
-        attr_reader :abstract_terminus, :indirection
-
-        # Are we an abstract terminus type, rather than an instance with an
-        # associated indirection?
-        def abstract_terminus?
-            abstract_terminus
-        end
-
-        # Convert a constant to a short name.
-        def const2name(const)
-            const.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_" + i.downcase }.intern
-        end
-
-        # Look up the indirection if we were only provided a name.
-        def indirection=(name)
-            if name.is_a?(Puppet::Indirector::Indirection)
-                @indirection = name
-            elsif ind = Puppet::Indirector::Indirection.instance(name)
-                @indirection = ind
-            else
-                raise ArgumentError, "Could not find indirection instance %s for %s" % [name, self.name]
-            end
-        end
-
-        def indirection_name
-            @indirection.name
-        end
-
-        # Register our subclass with the appropriate indirection.
-        # This follows the convention that our terminus is named after the
-        # indirection.
-        def inherited(subclass)
-            longname = subclass.to_s
-            if longname =~ /#<Class/
-                raise Puppet::DevError, "Terminus subclasses must have associated constants"
-            end
-            names = longname.split("::")
-
-            # Convert everything to a lower-case symbol, converting camelcase to underscore word separation.
-            name = names.pop.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_" + i.downcase }.intern
-
-            subclass.name = name
-
-            # Short-circuit the abstract types, which are those that directly subclass
-            # the Terminus class.
-            if self == Puppet::Indirector::Terminus
-                subclass.mark_as_abstract_terminus
-                return
-            end
-
-            # Set the terminus type to be the name of the abstract terminus type.
-            # Yay, class/instance confusion.
-            subclass.terminus_type = self.name
-
-            # Our subclass is specifically associated with an indirection.
-            raise("Invalid name %s" % longname) unless names.length > 0
-            indirection_name = names.pop.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_" + i.downcase }.intern
-
-            if indirection_name == "" or indirection_name.nil?
-                raise Puppet::DevError, "Could not discern indirection model from class constant"
-            end
-
-            # This will throw an exception if the indirection instance cannot be found.
-            # Do this last, because it also registers the terminus type with the indirection,
-            # which needs the above information.
-            subclass.indirection = indirection_name
-
-            # And add this instance to the instance hash.
-            Puppet::Indirector::Terminus.register_terminus_class(subclass)
-        end
-
-        # Mark that this instance is abstract.
-        def mark_as_abstract_terminus
-            @abstract_terminus = true
-        end
-
-        def model
-            indirection.model
-        end
-
-        # Convert a short name to a constant.
-        def name2const(name)
-            name.to_s.capitalize.sub(/_(.)/) { |i| $1.upcase }
-        end
-
-        # Register a class, probably autoloaded.
-        def register_terminus_class(klass)
-            setup_instance_loading klass.indirection_name
-            instance_hash(klass.indirection_name)[klass.name] = klass
-        end
-
-        # Return a terminus by name, using the autoloader.
-        def terminus_class(indirection_name, terminus_type)
-            setup_instance_loading indirection_name
-            loaded_instance(indirection_name, terminus_type)
-        end
-
-        # Return all terminus classes for a given indirection.
-        def terminus_classes(indirection_name)
-            setup_instance_loading indirection_name
-
-            # Load them all.
-            instance_loader(indirection_name).loadall
-
-            # And return the list of names.
-            loaded_instances(indirection_name)
-        end
-
-        private
-
-        def setup_instance_loading(type)
-            unless instance_loading?(type)
-                instance_load type, "puppet/indirector/%s" % type
-            end
-        end
+  require 'puppet/util/docs'
+  extend Puppet::Util::Docs
+
+  class << self
+    include Puppet::Util::InstanceLoader
+
+    attr_accessor :name, :terminus_type
+    attr_reader :abstract_terminus, :indirection
+
+    # Are we an abstract terminus type, rather than an instance with an
+    # associated indirection?
+    def abstract_terminus?
+      abstract_terminus
+    end
+
+    # Convert a constant to a short name.
+    def const2name(const)
+      const.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }.intern
+    end
+
+    # Look up the indirection if we were only provided a name.
+    def indirection=(name)
+      if name.is_a?(Puppet::Indirector::Indirection)
+        @indirection = name
+      elsif ind = Puppet::Indirector::Indirection.instance(name)
+        @indirection = ind
+      else
+        raise ArgumentError, "Could not find indirection instance #{name} for #{self.name}"
+      end
+    end
+
+    def indirection_name
+      @indirection.name
     end
 
-    def indirection
-        self.class.indirection
+    # Register our subclass with the appropriate indirection.
+    # This follows the convention that our terminus is named after the
+    # indirection.
+    def inherited(subclass)
+      longname = subclass.to_s
+      if longname =~ /#<Class/
+        raise Puppet::DevError, "Terminus subclasses must have associated constants"
+      end
+      names = longname.split("::")
+
+      # Convert everything to a lower-case symbol, converting camelcase to underscore word separation.
+      name = names.pop.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }.intern
+
+      subclass.name = name
+
+      # Short-circuit the abstract types, which are those that directly subclass
+      # the Terminus class.
+      if self == Puppet::Indirector::Terminus
+        subclass.mark_as_abstract_terminus
+        return
+      end
+
+      # Set the terminus type to be the name of the abstract terminus type.
+      # Yay, class/instance confusion.
+      subclass.terminus_type = self.name
+
+      # Our subclass is specifically associated with an indirection.
+      raise("Invalid name #{longname}") unless names.length > 0
+      indirection_name = names.pop.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }.intern
+
+      if indirection_name == "" or indirection_name.nil?
+        raise Puppet::DevError, "Could not discern indirection model from class constant"
+      end
+
+      # This will throw an exception if the indirection instance cannot be found.
+      # Do this last, because it also registers the terminus type with the indirection,
+      # which needs the above information.
+      subclass.indirection = indirection_name
+
+      # And add this instance to the instance hash.
+      Puppet::Indirector::Terminus.register_terminus_class(subclass)
     end
 
-    def initialize
-        if self.class.abstract_terminus?
-            raise Puppet::DevError, "Cannot create instances of abstract terminus types"
-        end
+    # Mark that this instance is abstract.
+    def mark_as_abstract_terminus
+      @abstract_terminus = true
     end
 
     def model
-        self.class.model
+      indirection.model
     end
 
-    def name
-        self.class.name
+    # Convert a short name to a constant.
+    def name2const(name)
+      name.to_s.capitalize.sub(/_(.)/) { |i| $1.upcase }
     end
 
-    def terminus_type
-        self.class.terminus_type
+    # Register a class, probably autoloaded.
+    def register_terminus_class(klass)
+      setup_instance_loading klass.indirection_name
+      instance_hash(klass.indirection_name)[klass.name] = klass
     end
+
+    # Return a terminus by name, using the autoloader.
+    def terminus_class(indirection_name, terminus_type)
+      setup_instance_loading indirection_name
+      loaded_instance(indirection_name, terminus_type)
+    end
+
+    # Return all terminus classes for a given indirection.
+    def terminus_classes(indirection_name)
+      setup_instance_loading indirection_name
+
+      # Load them all.
+      instance_loader(indirection_name).loadall
+
+      # And return the list of names.
+      loaded_instances(indirection_name)
+    end
+
+    private
+
+    def setup_instance_loading(type)
+      instance_load type, "puppet/indirector/#{type}" unless instance_loading?(type)
+    end
+  end
+
+  def indirection
+    self.class.indirection
+  end
+
+  def initialize
+    raise Puppet::DevError, "Cannot create instances of abstract terminus types" if self.class.abstract_terminus?
+  end
+
+  def model
+    self.class.model
+  end
+
+  def name
+    self.class.name
+  end
+
+  def terminus_type
+    self.class.terminus_type
+  end
 end

data/lib/puppet/indirector/yaml.rb

@@ -3,68 +3,66 @@ require 'puppet/util/file_locking'
 
 # The base class for YAML indirection termini.
 class Puppet::Indirector::Yaml < Puppet::Indirector::Terminus
-    include Puppet::Util::FileLocking
+  include Puppet::Util::FileLocking
 
-    # Read a given name's file in and convert it from YAML.
-    def find(request)
-        file = path(request.key)
-        return nil unless FileTest.exist?(file)
+  # Read a given name's file in and convert it from YAML.
+  def find(request)
+    file = path(request.key)
+    return nil unless FileTest.exist?(file)
 
-        yaml = nil
-        begin
-            readlock(file) { |fh| yaml = fh.read }
-        rescue => detail
-            raise Puppet::Error, "Could not read YAML data for %s %s: %s" % [indirection.name, request.key, detail]
-        end
-        begin
-            return from_yaml(yaml)
-        rescue => detail
-            raise Puppet::Error, "Could not parse YAML data for %s %s: %s" % [indirection.name, request.key, detail]
-        end
+    yaml = nil
+    begin
+      readlock(file) { |fh| yaml = fh.read }
+    rescue => detail
+      raise Puppet::Error, "Could not read YAML data for #{indirection.name} #{request.key}: #{detail}"
     end
+    begin
+      return from_yaml(yaml)
+    rescue => detail
+      raise Puppet::Error, "Could not parse YAML data for #{indirection.name} #{request.key}: #{detail}"
+    end
+  end
 
-    # Convert our object to YAML and store it to the disk.
-    def save(request)
-        raise ArgumentError.new("You can only save objects that respond to :name") unless request.instance.respond_to?(:name)
+  # Convert our object to YAML and store it to the disk.
+  def save(request)
+    raise ArgumentError.new("You can only save objects that respond to :name") unless request.instance.respond_to?(:name)
 
-        file = path(request.key)
+    file = path(request.key)
 
-        basedir = File.dirname(file)
+    basedir = File.dirname(file)
 
-        # This is quite likely a bad idea, since we're not managing ownership or modes.
-        unless FileTest.exist?(basedir)
-            Dir.mkdir(basedir)
-        end
+    # This is quite likely a bad idea, since we're not managing ownership or modes.
+    Dir.mkdir(basedir) unless FileTest.exist?(basedir)
 
-        begin
-            writelock(file, 0660) { |f| f.print to_yaml(request.instance) }
-        rescue TypeError => detail
-            Puppet.err "Could not save %s %s: %s" % [self.name, request.key, detail]
-        end
+    begin
+      writelock(file, 0660) { |f| f.print to_yaml(request.instance) }
+    rescue TypeError => detail
+      Puppet.err "Could not save #{self.name} #{request.key}: #{detail}"
     end
+  end
 
-    # Get the yaml directory
-    def base
-        (Puppet[:name] == "puppetmasterd") ? Puppet[:yamldir] : Puppet[:clientyamldir]
-    end
+  # Get the yaml directory
+  def base
+    Puppet.run_mode.master? ? Puppet[:yamldir] : Puppet[:clientyamldir]
+  end
 
-    # Return the path to a given node's file.
-    def path(name)
-        File.join(base, self.class.indirection_name.to_s, name.to_s + ".yaml")
-    end
+  # Return the path to a given node's file.
+  def path(name)
+    File.join(base, self.class.indirection_name.to_s, name.to_s + ".yaml")
+  end
 
-    # Do a glob on the yaml directory, loading each file found
-    def search(request)
-      Dir.glob(File.join(base, self.class.indirection_name.to_s, request.key)).collect { |f| YAML.load_file(f) }
-    end
+  # Do a glob on the yaml directory, loading each file found
+  def search(request)
+    Dir.glob(File.join(base, self.class.indirection_name.to_s, request.key)).collect { |f| YAML.load_file(f) }
+  end
 
-    private
+  private
 
-    def from_yaml(text)
-        YAML.load(text)
-    end
+  def from_yaml(text)
+    YAML.load(text)
+  end
 
-    def to_yaml(object)
-        YAML.dump(object)
-    end
+  def to_yaml(object)
+    YAML.dump(object)
+  end
 end

data/lib/puppet/metatype/manager.rb

@@ -5,137 +5,143 @@ require 'puppet/util/classgen'
 # Puppet::Type class, it's just split out here for clarity.
 module Puppet::MetaType
 module Manager
-    include Puppet::Util::ClassGen
-
-    # remove all type instances; this is mostly only useful for testing
-    def allclear
-        @types.each { |name, type|
-            type.clear
-        }
+  include Puppet::Util::ClassGen
+
+  # remove all type instances; this is mostly only useful for testing
+  def allclear
+    @types.each { |name, type|
+      type.clear
+    }
+  end
+
+  # iterate across all of the subclasses of Type
+  def eachtype
+    @types.each do |name, type|
+      # Only consider types that have names
+      #if ! type.parameters.empty? or ! type.validproperties.empty?
+        yield type
+      #end
+    end
+  end
+
+  # Load all types.  Only currently used for documentation.
+  def loadall
+    typeloader.loadall
+  end
+
+  # Define a new type.
+  def newtype(name, options = {}, &block)
+    # Handle backward compatibility
+    unless options.is_a?(Hash)
+      Puppet.warning "Puppet::Type.newtype(#{name}) now expects a hash as the second argument, not #{options.inspect}"
+      options = {:parent => options}
     end
 
-    # iterate across all of the subclasses of Type
-    def eachtype
-        @types.each do |name, type|
-            # Only consider types that have names
-            #if ! type.parameters.empty? or ! type.validproperties.empty?
-                yield type
-            #end
-        end
+    # First make sure we don't have a method sitting around
+    name = symbolize(name)
+    newmethod = "new#{name.to_s}"
+
+    # Used for method manipulation.
+    selfobj = singleton_class
+
+    @types ||= {}
+
+    if @types.include?(name)
+      if self.respond_to?(newmethod)
+        # Remove the old newmethod
+        selfobj.send(:remove_method,newmethod)
+      end
     end
 
-    # Load all types.  Only currently used for documentation.
-    def loadall
-        typeloader.loadall
+    options = symbolize_options(options)
+
+    if parent = options[:parent]
+      options.delete(:parent)
     end
 
-    # Define a new type.
-    def newtype(name, options = {}, &block)
-        # Handle backward compatibility
-        unless options.is_a?(Hash)
-            Puppet.warning "Puppet::Type.newtype(%s) now expects a hash as the second argument, not %s" % [name, options.inspect]
-            options = {:parent => options}
-        end
-
-        # First make sure we don't have a method sitting around
-        name = symbolize(name)
-        newmethod = "new#{name.to_s}"
-
-        # Used for method manipulation.
-        selfobj = metaclass()
-
-        @types ||= {}
-
-        if @types.include?(name)
-            if self.respond_to?(newmethod)
-                # Remove the old newmethod
-                selfobj.send(:remove_method,newmethod)
-            end
-        end
-
-        options = symbolize_options(options)
-
-        if parent = options[:parent]
-            options.delete(:parent)
-        end
-
-        # Then create the class.
-        klass = genclass(name,
-            :parent => (parent || Puppet::Type),
-            :overwrite => true,
-            :hash => @types,
-            :attributes => options,
-            &block
-        )
-
-        # Now define a "new<type>" method for convenience.
-        if self.respond_to? newmethod
-            # Refuse to overwrite existing methods like 'newparam' or 'newtype'.
-            Puppet.warning "'new#{name.to_s}' method already exists; skipping"
-        else
-            selfobj.send(:define_method, newmethod) do |*args|
-                klass.create(*args)
-            end
-        end
-
-        # If they've got all the necessary methods defined and they haven't
-        # already added the property, then do so now.
-        if klass.ensurable? and ! klass.validproperty?(:ensure)
-            klass.ensurable
-        end
-
-        # Now set up autoload any providers that might exist for this type.
-        klass.providerloader = Puppet::Util::Autoload.new(klass,
-            "puppet/provider/#{klass.name.to_s}"
-        )
-
-        # We have to load everything so that we can figure out the default type.
-        klass.providerloader.loadall()
-
-        klass
+    # Then create the class.
+
+          klass = genclass(
+        name,
+      :parent => (parent || Puppet::Type),
+        
+      :overwrite => true,
+      :hash => @types,
+      :attributes => options,
+      &block
+    )
+
+    # Now define a "new<type>" method for convenience.
+    if self.respond_to? newmethod
+      # Refuse to overwrite existing methods like 'newparam' or 'newtype'.
+      Puppet.warning "'new#{name.to_s}' method already exists; skipping"
+    else
+      selfobj.send(:define_method, newmethod) do |*args|
+        klass.new(*args)
+      end
     end
 
-    # Remove an existing defined type.  Largely used for testing.
-    def rmtype(name)
-        # Then create the class.
-        klass = rmclass(name,
-            :hash => @types
-        )
+    # If they've got all the necessary methods defined and they haven't
+    # already added the property, then do so now.
+    klass.ensurable if klass.ensurable? and ! klass.validproperty?(:ensure)
 
-        if respond_to?("new" + name.to_s)
-            metaclass.send(:remove_method, "new" + name.to_s)
-        end
-    end
+    # Now set up autoload any providers that might exist for this type.
 
-    # Return a Type instance by name.
-    def type(name)
-        @types ||= {}
+          klass.providerloader = Puppet::Util::Autoload.new(
+        klass,
+        
+      "puppet/provider/#{klass.name.to_s}"
+    )
 
-        name = name.to_s.downcase.to_sym
+    # We have to load everything so that we can figure out the default type.
+    klass.providerloader.loadall
 
-        if t = @types[name]
-            return t
-        else
-            if typeloader.load(name)
-                unless @types.include? name
-                    Puppet.warning "Loaded puppet/type/#{name} but no class was created"
-                end
-            end
+    klass
+  end
 
-            return @types[name]
-        end
+  # Remove an existing defined type.  Largely used for testing.
+  def rmtype(name)
+    # Then create the class.
+
+          klass = rmclass(
+        name,
+        
+      :hash => @types
+    )
+
+    singleton_class.send(:remove_method, "new#{name}") if respond_to?("new#{name}")
+  end
+
+  # Return a Type instance by name.
+  def type(name)
+    @types ||= {}
+
+    name = name.to_s.downcase.to_sym
+
+    if t = @types[name]
+      return t
+    else
+      if typeloader.load(name)
+        Puppet.warning "Loaded puppet/type/#{name} but no class was created" unless @types.include? name
+      end
+
+      return @types[name]
     end
+  end
 
-    # Create a loader for Puppet types.
-    def typeloader
-        unless defined? @typeloader
-            @typeloader = Puppet::Util::Autoload.new(self,
-                "puppet/type", :wrap => false
-            )
-        end
+  # Create a loader for Puppet types.
+  def typeloader
+    unless defined?(@typeloader)
 
-        @typeloader
+            @typeloader = Puppet::Util::Autoload.new(
+        self,
+        
+        "puppet/type", :wrap => false
+      )
     end
+
+    @typeloader
+  end
 end
 end