puppet 0.23.2 → 0.24.0

data/lib/puppet/indirector/rest.rb

@@ -0,0 +1,8 @@
+require 'puppet/indirector/rest'
+
+# Access objects via REST
+class Puppet::Indirector::REST < Puppet::Indirector::Terminus
+    def find(name, options = {})
+        indirection.model.new(name)
+    end
+end

data/lib/puppet/indirector/ssl_rsa.rb

@@ -0,0 +1,5 @@
+# This is a stub class
+
+class Puppet::Indirector::SslRsa #:nodoc:
+end
+

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

@@ -0,0 +1,33 @@
+require 'puppet/indirector/file'
+require 'puppet/indirector/ssl_rsa'
+
+class Puppet::Indirector::SslRsa::File < Puppet::Indirector::File
+    desc "Store SSL keys on disk."
+
+    def initialize
+        Puppet.settings.use(:ssl)
+    end
+
+    def path(name)
+        if name == :ca
+            File.join Puppet.settings[:cadir], "ca_key.pem"
+        else
+            File.join Puppet.settings[:publickeydir], name.to_s + ".pem"
+        end
+    end
+
+    def save(key)
+        File.open(path(key.name), "w") { |f| f.print key.to_pem }
+    end
+
+    def find(name)
+        return nil unless FileTest.exists?(path(name))
+        OpenSSL::PKey::RSA.new(File.read(path(name)))
+    end
+
+    def destroy(name)
+        return nil unless FileTest.exists?(path(name))
+        File.unlink(path(name)) and true
+    end
+
+end

data/lib/puppet/indirector/terminus.rb

@@ -0,0 +1,178 @@
+require 'puppet/indirector'
+require 'puppet/indirector/indirection'
+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.
+            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
+    end
+
+    # Do we have an update for this object?  This compares the provided version
+    # to our version, and returns true if our version is at least as high
+    # as the asked-about version.
+    def has_most_recent?(key, vers)
+        raise Puppet::DevError.new("Cannot check update status when no 'version' method is defined") unless respond_to?(:version)
+
+        if existing_version = version(key)
+            #puts "%s fresh: %s (%s vs %s)" % [self.name, (existing_version.to_f >= vers.to_f).inspect, existing_version.to_f, vers.to_f]
+            existing_version.to_f >= vers.to_f
+        else
+            false
+        end
+    end
+
+    def indirection
+        self.class.indirection
+    end
+
+    def initialize
+        if self.class.abstract_terminus?
+            raise Puppet::DevError, "Cannot create instances of abstract terminus types"
+        end
+    end
+    
+    def model
+        self.class.model
+    end
+    
+    def name
+        self.class.name
+    end
+    
+    def terminus_type
+        self.class.terminus_type
+    end
+
+    # Provide a default method for retrieving an instance's version.
+    # By default, just find the resource and get its version.  Individual
+    # terminus types can override this method to provide custom definitions of
+    # 'versions'.
+    def version(name)
+        raise Puppet::DevError.new("Cannot retrieve an instance's version without a :find method") unless respond_to?(:find)
+        if instance = find(name)
+            instance.version
+        else
+            nil
+        end
+    end
+end

data/lib/puppet/indirector/yaml.rb

@@ -0,0 +1,57 @@
+require 'puppet/indirector/terminus'
+
+# The base class for YAML indirection termini.
+class Puppet::Indirector::Yaml < Puppet::Indirector::Terminus
+    def initialize
+        # Make sure our base directory exists.
+        Puppet.settings.use(:yaml)
+    end
+
+    # Read a given name's file in and convert it from YAML.
+    def find(name)
+        raise ArgumentError.new("You must specify the name of the object to retrieve") unless name
+        file = path(name)
+        return nil unless FileTest.exist?(file)
+
+        begin
+            return from_yaml(File.read(file))
+        rescue => detail
+            raise Puppet::Error, "Could not read YAML data for %s %s: %s" % [indirection.name, name, detail]
+        end
+    end
+
+    # Convert our object to YAML and store it to the disk.
+    def save(object)
+        raise ArgumentError.new("You can only save objects that respond to :name") unless object.respond_to?(:name)
+
+        file = path(object.name)
+
+        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
+
+        begin
+            File.open(file, "w", 0660) { |f| f.print to_yaml(object) }
+        rescue TypeError => detail
+            Puppet.err "Could not save %s %s: %s" % [self.name, object.name, detail]
+        end
+    end
+
+    private
+
+    def from_yaml(text)
+        YAML.load(text)
+    end
+
+    def to_yaml(object)
+        YAML.dump(object)
+    end
+
+    # Return the path to a given node's file.
+    def path(name)
+        File.join(Puppet[:yamldir], self.class.indirection_name.to_s, name.to_s + ".yaml")
+    end
+end

data/lib/puppet/metatype/attributes.rb

@@ -252,6 +252,8 @@ class Puppet::Type
             param.required_features = options[:required_features]
         end
 
+        param.isnamevar if options[:namevar]
+
         # These might be enabled later.
 #        define_method(name) do
 #            @parameters[name].value
@@ -426,8 +428,7 @@ class Puppet::Type
             if defined? @title and @title
                 hash[namevar] = @title
             else
-                raise Puppet::Error,
-                    "Was not passed a namevar or title"
+                raise Puppet::Error, "Was not passed a namevar or title"
             end
         end
 
@@ -686,4 +687,3 @@ class Puppet::Type
     end
 end
 
-# $Id: attributes.rb 2676 2007-07-10 23:24:34Z luke $

data/lib/puppet/metatype/closure.rb

@@ -1,19 +1,6 @@
 class Puppet::Type
     attr_writer :implicit
 
-    def self.implicitcreate(hash)
-        unless hash.include?(:implicit)
-            hash[:implicit] = true
-        end
-        if obj = self.create(hash)
-            obj.implicit = true
-
-            return obj
-        else
-            return nil
-        end
-    end
-
     # Is this type's name isomorphic with the object?  That is, if the
     # name conflicts, does it necessarily mean that the objects conflict?
     # Defaults to true.
@@ -55,57 +42,4 @@ class Puppet::Type
             return @managed
         end
     end
-
-    # Merge new information with an existing object, checking for conflicts
-    # and such.  This allows for two specifications of the same object and
-    # the same values, but it's pretty limited right now.  The result of merging
-    # properties is very different from the result of merging parameters or
-    # metaparams.  This is currently unused.
-    def merge(hash)
-        hash.each { |param, value|
-            if param.is_a?(String)
-                param = param.intern
-            end
-            
-            # Of course names are the same, duh.
-            next if param == :name or param == self.class.namevar
-
-            unless value.is_a?(Array)
-                value = [value]
-            end
-
-            if @parameters.include?(param) and oldvals = @parameters[param].shouldorig
-                unless oldvals.is_a?(Array)
-                    oldvals = [oldvals]
-                end
-                # If the values are exactly the same, order and everything,
-                # then it's okay.
-                if oldvals == value
-                    return true
-                end
-                # take the intersection
-                newvals = oldvals & value
-                if newvals.empty?
-                    self.fail "No common values for %s on %s(%s)" %
-                        [param, self.class.name, self.title]
-                elsif newvals.length > 1
-                    self.fail "Too many values for %s on %s(%s)" %
-                        [param, self.class.name, self.title]
-                else
-                    self.debug "Reduced old values %s and new values %s to %s" %
-                        [oldvals.inspect, value.inspect, newvals.inspect]
-                    @parameters[param].should = newvals
-                    #self.should = newvals
-                    return true
-                end
-            else
-                self[param] = value
-            end
-        }
-
-        # Set the defaults again, just in case.
-        self.setdefaults
-    end
 end
-
-# $Id: closure.rb 2169 2007-02-07 06:47:10Z luke $

data/lib/puppet/metatype/container.rb

@@ -14,14 +14,6 @@ class Puppet::Type
         self.class.depthfirst?
     end
 
-    def parent=(parent)
-        if self.parentof?(parent)
-            devfail "%s[%s] is already the parent of %s[%s]" %
-                [self.class.name, self.title, parent.class.name, parent.title]
-        end
-        @parent = parent
-    end
-
     # Add a hook for testing for recursion.
     def parentof?(child)
         if (self == child)
@@ -56,4 +48,3 @@ class Puppet::Type
     end
 end
 
-# $Id: container.rb 2499 2007-05-09 21:30:44Z luke $

data/lib/puppet/metatype/evaluation.rb

@@ -29,7 +29,16 @@ class Puppet::Type
             self.debug "%s change(s)" %
                 [changes.length]
         end
-        self.cache(:checked, Time.now)
+
+        # If we're in noop mode, we don't want to store the checked time,
+        # because it will result in the resource not getting scheduled if
+        # someone were to apply the catalog in non-noop mode.
+        # We're going to go ahead and record that we checked if there were
+        # no changes, since it's unlikely it will affect the scheduling.
+        noop = noop?
+        if ! noop or (noop && changes.length == 0)
+            self.cache(:checked, Time.now)
+        end
         return changes.flatten
     end
 
@@ -153,4 +162,3 @@ class Puppet::Type
     end
 end
 
-# $Id: evaluation.rb 2678 2007-07-11 19:30:42Z luke $

data/lib/puppet/metatype/instances.rb

@@ -79,8 +79,7 @@ class Puppet::Type
     end
 
     # Force users to call this, so that we can merge objects if
-    # necessary.  FIXME This method should be responsible for most of the
-    # error handling.
+    # necessary.
     def self.create(args)
         # Don't modify the original hash; instead, create a duplicate and modify it.
         # We have to dup and use the ! so that it stays a TransObject if it is
@@ -100,6 +99,8 @@ class Puppet::Type
                 end
             end
 
+            # If they've specified a type and called on the base, then
+            # delegate to the subclass.
             if type
                 if typeklass = self.type(type)
                     return typeklass.create(hash)
@@ -125,8 +126,6 @@ class Puppet::Type
         # XXX This will have to change when transobjects change to using titles
         title = hash.name
 
-        #Puppet.debug "Creating %s[%s]" % [self.name, title]
-
         # if the object already exists
         if self.isomorphic? and retobj = self[title]
             # if only one of our objects is implicit, then it's easy to see
@@ -138,23 +137,10 @@ class Puppet::Type
 
                 # now pass through and create the new object
             elsif implicit
-                Puppet.notice "Ignoring implicit %s" % title
-
-                return retobj
+                Puppet.debug "Ignoring implicit %s[%s]" % [self.name, title]
+                return nil
             else
-                # If only one of the objects is being managed, then merge them
-                if retobj.managed?
-                    raise Puppet::Error, "%s '%s' is already being managed" %
-                        [self.name, title]
-                else
-                    retobj.merge(hash)
-                    return retobj
-                end
-                # We will probably want to support merging of some kind in
-                # the future, but for now, just throw an error.
-                #retobj.merge(hash)
-
-                #return retobj
+                raise Puppet::Error, "%s is already being managed" % retobj.ref
             end
         end
 
@@ -235,19 +221,22 @@ class Puppet::Type
             hash.delete :name
         end
 
-        unless title
-            raise Puppet::Error,
-                "You must specify a title for objects of type %s" % self.to_s
+        if catalog = hash[:catalog]
+            hash.delete(:catalog)
         end
 
+        raise(Puppet::Error, "You must specify a title for objects of type %s" % self.to_s) unless title
+
         if hash.include? :type
             unless self.validattr? :type
                 hash.delete :type
             end
         end
+
         # okay, now make a transobject out of hash
         begin
             trans = Puppet::TransObject.new(title, self.name.to_s)
+            trans.catalog = catalog if catalog
             hash.each { |param, value|
                 trans[param] = value
             }
@@ -270,10 +259,8 @@ class Puppet::Type
         providers_by_source.collect do |provider|
             provider.instances.collect do |instance|
                 # First try to get the resource if it already exists
-                if resource = self[instance.name] and resource.provider.class != instance.class
-                    # Skip instances that map to a managed resource with a different provider
-                    next
-                end
+                # Skip instances that map to a managed resource with a different provider
+                next if resource = self[instance.name] and resource.provider.class != instance.class
 
                 # We always want to use the "first" provider instance we find, unless the resource
                 # is already managed and has a different provider set
@@ -308,12 +295,11 @@ class Puppet::Type
 
     # Create the path for logging and such.
     def pathbuilder
-        if defined? @parent and @parent
-            [@parent.pathbuilder, self.ref].flatten
+        if p = parent
+            [p.pathbuilder, self.ref].flatten
         else
             [self.ref]
         end
     end
 end
 
-# $Id: instances.rb 2718 2007-07-19 22:12:51Z luke $