puppet 0.24.9 → 0.25.0

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

@@ -0,0 +1,7 @@
+require 'puppet/agent'
+require 'puppet/agent/runner'
+require 'puppet/indirector/rest'
+
+class Puppet::Agent::Runner::Rest < Puppet::Indirector::REST
+    desc "Trigger Agent runs via REST."
+end

data/lib/puppet/indirector/ssl_file.rb

@@ -0,0 +1,174 @@
+require 'puppet/ssl'
+
+class Puppet::Indirector::SslFile < Puppet::Indirector::Terminus
+    # Specify the directory in which multiple files are stored.
+    def self.store_in(setting)
+        @directory_setting = setting
+    end
+
+    # Specify a single file location for storing just one file.
+    # This is used for things like the CRL.
+    def self.store_at(setting)
+        @file_setting = setting
+    end
+
+    # Specify where a specific ca file should be stored.
+    def self.store_ca_at(setting)
+        @ca_setting = setting
+    end
+
+    class << self
+        attr_reader :directory_setting, :file_setting, :ca_setting
+    end
+
+    # The full path to where we should store our files.
+    def self.collection_directory
+        return nil unless directory_setting
+        Puppet.settings[directory_setting]
+    end
+
+    # The full path to an individual file we would be managing.
+    def self.file_location
+        return nil unless file_setting
+        Puppet.settings[file_setting]
+    end
+
+    # The full path to a ca file we would be managing.
+    def self.ca_location
+        return nil unless ca_setting
+        Puppet.settings[ca_setting]
+    end
+
+    # We assume that all files named 'ca' are pointing to individual ca files,
+    # rather than normal host files.  It's a bit hackish, but all the other
+    # solutions seemed even more hackish.
+    def ca?(name)
+        name == Puppet::SSL::Host.ca_name
+    end
+
+    def initialize
+        Puppet.settings.use(:main, :ssl)
+
+        (collection_directory || file_location) or raise Puppet::DevError, "No file or directory setting provided; terminus %s cannot function" % self.class.name
+    end
+
+    # Use a setting to determine our path.
+    def path(name)
+        if ca?(name) and ca_location
+            ca_location
+        elsif collection_directory
+            File.join(collection_directory, name.to_s + ".pem")
+        else
+            file_location
+        end
+    end
+
+    # Remove our file.
+    def destroy(request)
+        path = path(request.key)
+        return false unless FileTest.exist?(path)
+
+        Puppet.notice "Removing file %s %s at '%s'" % [model, request.key, path]
+        begin
+            File.unlink(path)
+        rescue => detail
+            raise Puppet::Error, "Could not remove %s: %s" % [request.key, detail]
+        end
+    end
+
+    # Find the file on disk, returning an instance of the model.
+    def find(request)
+        path = path(request.key)
+
+        return nil unless FileTest.exist?(path) or rename_files_with_uppercase(path)
+
+        result = model.new(request.key)
+        result.read(path)
+        result
+    end
+
+    # Save our file to disk.
+    def save(request)
+        path = path(request.key)
+        dir = File.dirname(path)
+
+        raise Puppet::Error.new("Cannot save %s; parent directory %s does not exist" % [request.key, dir]) unless FileTest.directory?(dir)
+        raise Puppet::Error.new("Cannot save %s; parent directory %s is not writable" % [request.key, dir]) unless FileTest.writable?(dir)
+
+        write(request.key, path) { |f| f.print request.instance.to_s }
+    end
+
+    # Search for more than one file.  At this point, it just returns
+    # an instance for every file in the directory.
+    def search(request)
+        dir = collection_directory
+        Dir.entries(dir).reject { |file| file !~ /\.pem$/ }.collect do |file|
+            name = file.sub(/\.pem$/, '')
+            result = model.new(name)
+            result.read(File.join(dir, file))
+            result
+        end
+    end
+
+    private
+
+    # Demeterish pointers to class info.
+    def collection_directory
+        self.class.collection_directory
+    end
+
+    def file_location
+        self.class.file_location
+    end
+
+    def ca_location
+        self.class.ca_location
+    end
+
+    # A hack method to deal with files that exist with a different case.
+    # Just renames it; doesn't read it in or anything.
+    # LAK:NOTE This is a copy of the method in sslcertificates/support.rb,
+    # which we'll be EOL'ing at some point.  This method was added at 20080702
+    # and should be removed at some point.
+    def rename_files_with_uppercase(file)
+        dir, short = File.split(file)
+        return nil unless FileTest.exist?(dir)
+
+        raise ArgumentError, "Tried to fix SSL files to a file containing uppercase" unless short.downcase == short
+        real_file = Dir.entries(dir).reject { |f| f =~ /^\./ }.find do |other|
+            other.downcase == short
+        end
+
+        return nil unless real_file
+
+        full_file = File.join(dir, real_file)
+
+        Puppet.notice "Fixing case in %s; renaming to %s" % [full_file, file]
+        File.rename(full_file, file)
+
+        return true
+    end
+
+    # Yield a filehandle set up appropriately, either with our settings doing
+    # the work or opening a filehandle manually.
+    def write(name, path)
+        if ca?(name) and ca_location
+            Puppet.settings.write(self.class.ca_setting) { |f| yield f }
+        elsif file_location
+            Puppet.settings.write(self.class.file_setting) { |f| yield f }
+        elsif setting = self.class.directory_setting
+            begin
+                Puppet.settings.writesub(setting, path) { |f| yield f }
+            rescue => detail
+                raise Puppet::Error, "Could not write %s to %s: %s" % [path, setting, detail]
+            end
+        else
+            raise Puppet::DevError, "You must provide a setting to determine where the files are stored"
+        end
+    end
+end
+
+# LAK:NOTE This has to be at the end, because classes like SSL::Key use this
+# class, and this require statement loads those, which results in a load loop
+# and lots of failures.
+require 'puppet/ssl/host'

data/lib/puppet/indirector/terminus.rb

@@ -111,7 +111,7 @@ class Puppet::Indirector::Terminus
         # 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
 
@@ -137,15 +137,15 @@ class Puppet::Indirector::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

data/lib/puppet/indirector/yaml.rb

@@ -52,7 +52,7 @@ class Puppet::Indirector::Yaml < Puppet::Indirector::Terminus
     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) }

data/lib/puppet/metatype/manager.rb

@@ -19,7 +19,7 @@ module Manager
         @types.each do |name, type|
             # Only consider types that have names
             #if ! type.parameters.empty? or ! type.validproperties.empty?
-                yield type 
+                yield type
             #end
         end
     end
@@ -94,14 +94,14 @@ module Manager
 
         klass
     end
-    
+
     # Remove an existing defined type.  Largely used for testing.
     def rmtype(name)
         # Then create the class.
         klass = rmclass(name,
             :hash => @types
         )
-        
+
         if respond_to?("new" + name.to_s)
             metaclass.send(:remove_method, "new" + name.to_s)
         end

data/lib/puppet/module.rb

@@ -1,171 +1,146 @@
+require 'puppet/util/logging'
+
 # Support for modules
 class Puppet::Module
+    include Puppet::Util::Logging
+
+    class InvalidName < ArgumentError
+        def message
+            "Invalid module name; module names must be alphanumeric (plus '-')"
+        end
+    end
 
     TEMPLATES = "templates"
     FILES = "files"
     MANIFESTS = "manifests"
-    
+    PLUGINS = "plugins"
+
+    FILETYPES = [MANIFESTS, FILES, TEMPLATES, PLUGINS]
+
     # Return an array of paths by splitting the +modulepath+ config
     # parameter. Only consider paths that are absolute and existing
     # directories
     def self.modulepath(environment = nil)
-        dirs = Puppet.settings.value(:modulepath, environment).split(":")
-        if ENV["PUPPETLIB"]
-            dirs = ENV["PUPPETLIB"].split(":") + dirs
-        else
-        end
-        dirs.select do |p|
-            p =~ /^#{File::SEPARATOR}/ && File::directory?(p)
-        end
-    end
-
-    # Return an array of paths by splitting the +templatedir+ config
-    # parameter.
-    def self.templatepath(environment = nil)
-        dirs = Puppet.settings.value(:templatedir, environment).split(":")
-        dirs.select do |p|
-            File::directory?(p)
-        end
+        Puppet::Node::Environment.new(environment).modulepath
     end
 
     # Find and return the +module+ that +path+ belongs to. If +path+ is
     # absolute, or if there is no module whose name is the first component
     # of +path+, return +nil+
     def self.find(modname, environment = nil)
-        if modname =~ %r/^#{File::SEPARATOR}/
-            return nil
-        end
+        return nil unless modname
+        Puppet::Node::Environment.new(environment).module(modname)
+    end
 
-        modpath = modulepath(environment).collect { |path|
-            File::join(path, modname)
-        }.find { |f| File::directory?(f) }
-        return nil unless modpath
+    attr_reader :name, :environment
+    attr_writer :environment
 
-        return self.new(modname, modpath)
-    end
+    def initialize(name, environment = nil)
+        @name = name
 
-    # Return an array of the full path of every subdirectory in each
-    # directory in the modulepath.
-    def self.all(environment = nil)
-        modulepath(environment).map do |mp|
-            Dir.new(mp).map do |modfile|
-                modpath = File.join(mp, modfile)
-                unless modfile == '.' or modfile == '..' or !File.directory?(modpath)
-                    modpath
-                else
-                    nil
-                end
-            end
-        end.flatten.compact
-    end
+        assert_validity()
 
-    # Instance methods
-
-    # Find the concrete file denoted by +file+. If +file+ is absolute,
-    # return it directly. Otherwise try to find it as a template in a
-    # module. If that fails, return it relative to the +templatedir+ config
-    # param.
-    # In all cases, an absolute path is returned, which does not
-    # necessarily refer to an existing file
-    def self.find_template(template, environment = nil)
-        if template =~ /^#{File::SEPARATOR}/
-            return template
+        if environment.is_a?(Puppet::Node::Environment)
+            @environment = environment
+        else
+            @environment = Puppet::Node::Environment.new(environment)
         end
+    end
 
-        template_paths = templatepath(environment)
-        if template_paths
-            # If we can find the template in :templatedir, we return that.
-            td_file = template_paths.collect { |path|
-                File::join(path, template)
-            }.find { |f| File.exists?(f) }
-
-            return td_file unless td_file == nil
+    FILETYPES.each do |type|
+        # A boolean method to let external callers determine if
+        # we have files of a given type.
+        define_method(type +'?') do
+            return false unless path
+            return false unless FileTest.exist?(subpath(type))
+            return true
         end
 
-        td_file = find_template_for_module(template, environment)
+        # A method for returning a given file of a given type.
+        # e.g., file = mod.manifest("my/manifest.pp")
+        #
+        # If the file name is nil, then the base directory for the
+        # file type is passed; this is used for fileserving.
+        define_method(type.to_s.sub(/s$/, '')) do |file|
+            return nil unless path
+
+            # If 'file' is nil then they're asking for the base path.
+            # This is used for things like fileserving.
+            if file
+                full_path = File.join(subpath(type), file)
+            else
+                full_path = subpath(type)
+            end
 
-        # check in the default template dir, if there is one
-        if td_file.nil?
-            raise Puppet::Error, "No valid template directory found, please check templatedir settings" if template_paths.nil?
-            td_file = File::join(template_paths.first, template)
+            return nil unless FileTest.exist?(full_path)
+            return full_path
         end
-        td_file
     end
 
-    def self.find_template_for_module(template, environment = nil)
-        path, file = split_path(template)
+    def exist?
+        ! path.nil?
+    end
 
-        # Because templates don't have an assumed template name, like manifests do,
-        # we treat templates with no name as being templates in the main template
-        # directory.
-        if not file.nil?
-            mod = find(path, environment)
-            if mod
-                return mod.template(file)
-            end
-        end
-        nil
+    # Find the first 'files' directory.  This is used by the XMLRPC fileserver.
+    def file_directory
+        subpath("files")
     end
 
-    # Return a list of manifests (as absolute filenames) that match +pat+
-    # with the current directory set to +cwd+. If the first component of
-    # +pat+ does not contain any wildcards and is an existing module, return
-    # a list of manifests in that module matching the rest of +pat+
-    # Otherwise, try to find manifests matching +pat+ relative to +cwd+
-    def self.find_manifests(start, options = {})
-        cwd = options[:cwd] || Dir.getwd
-        module_name, pattern = split_path(start)
-        if module_name and mod = find(module_name, options[:environment])
-            return mod.manifests(pattern)
-        else
-            abspat = File::expand_path(start, cwd)
-            files = Dir.glob(abspat).reject { |f| FileTest.directory?(f) }
-            if files.size == 0
-                files = Dir.glob(abspat + ".pp").reject { |f| FileTest.directory?(f) }
-            end
-            return files
+    # Return the list of manifests matching the given glob pattern,
+    # defaulting to 'init.pp' for empty modules.
+    def match_manifests(rest)
+        return find_init_manifest unless rest # Use init.pp
+
+        rest ||= "init.pp"
+        p = File::join(path, MANIFESTS, rest)
+        result = Dir.glob(p).reject { |f| FileTest.directory?(f) }
+        if result.size == 0 and rest !~ /\.pp$/
+            result = Dir.glob(p + ".pp")
         end
+        result.flatten.compact
     end
 
-    # Split the path into the module and the rest of the path.
-    # This method can and often does return nil, so anyone calling
-    # it needs to handle that.
-    def self.split_path(path)
-        if path =~ %r/^#{File::SEPARATOR}/
-            return nil
-        end
+    # Find this module in the modulepath.
+    def path
+        environment.modulepath.collect { |path| File.join(path, name) }.find { |d| FileTest.exist?(d) }
+    end
 
-        modname, rest = path.split(File::SEPARATOR, 2)
-        return nil if modname.nil? || modname.empty?
-        return modname, rest
+    # Find all plugin directories.  This is used by the Plugins fileserving mount.
+    def plugin_directory
+        subpath("plugins")
     end
 
-    attr_reader :name, :path
-    def initialize(name, path)
-        @name = name
-        @path = path
+    def to_s
+        result = "Module %s" % name
+        if path
+            result += "(%s)" % path
+        end
+        result
     end
 
-    def template(file)
-        return File::join(path, TEMPLATES, file)
+    private
+
+    def find_init_manifest
+        return [] unless file = manifest("init.pp")
+        return [file]
     end
 
-    def files
-        return File::join(path, FILES)
+    def subpath(type)
+        return File.join(path, type) unless type.to_s == "plugins"
+
+        return backward_compatible_plugins_dir
     end
 
-    # Return the list of manifests matching the given glob pattern,
-    # defaulting to 'init.pp' for empty modules.
-    def manifests(rest)
-        rest ||= "init.pp"
-        p = File::join(path, MANIFESTS, rest)
-        files = Dir.glob(p).reject { |f| FileTest.directory?(f) }
-        if files.size == 0
-            files = Dir.glob(p + ".pp")
+    def backward_compatible_plugins_dir
+        if dir = File.join(path, "plugins") and FileTest.exist?(dir)
+            warning "using the deprecated 'plugins' directory for ruby extensions; please move to 'lib'"
+            return dir
+        else
+            return File.join(path, "lib")
         end
-        return files
     end
 
-    private :initialize
-    private_class_method :find_template_for_module
+    def assert_validity
+        raise InvalidName unless name =~ /^[-\w]+$/
+    end
 end