puppet 0.24.9 → 0.25.0

data/lib/puppet/file_serving/content.rb

@@ -4,31 +4,46 @@
 
 require 'puppet/indirector'
 require 'puppet/file_serving'
-require 'puppet/file_serving/file_base'
+require 'puppet/file_serving/base'
 require 'puppet/file_serving/indirection_hooks'
 
 # A class that handles retrieving file contents.
 # It only reads the file when its content is specifically
 # asked for.
-class Puppet::FileServing::Content < Puppet::FileServing::FileBase
+class Puppet::FileServing::Content < Puppet::FileServing::Base
     extend Puppet::Indirector
     indirects :file_content, :extend => Puppet::FileServing::IndirectionHooks
 
-    attr_reader :path
+    attr_writer :content
+
+    def self.supported_formats
+        [:raw]
+    end
+
+    def self.from_raw(content)
+        instance = new("/this/is/a/fake/path")
+        instance.content = content
+        instance
+    end
+
+    # Collect our data.
+    def collect
+        return if stat.ftype == "directory"
+        content
+    end
 
     # Read the content of our file in.
     def content
-        # This stat can raise an exception, too.
-        raise(ArgumentError, "Cannot read the contents of links unless following links") if stat().ftype == "symlink" 
+        unless defined?(@content) and @content
+            # This stat can raise an exception, too.
+            raise(ArgumentError, "Cannot read the contents of links unless following links") if stat().ftype == "symlink"
 
-        ::File.read(full_path())
+            @content = ::File.read(full_path())
+        end
+        @content
     end
 
-    # Just return the file contents as the yaml.  This allows us to
-    # avoid escaping or any such thing.  LAK:NOTE Not really sure how
-    # this will behave if the file contains yaml...  I think the far
-    # side needs to understand that it's a plain string.
-    def to_yaml
+    def to_raw
         content
     end
 end

data/lib/puppet/file_serving/fileset.rb

@@ -9,7 +9,24 @@ require 'puppet/file_serving/metadata'
 # Operate recursively on a path, returning a set of file paths.
 class Puppet::FileServing::Fileset
     attr_reader :path, :ignore, :links
-    attr_accessor :recurse
+    attr_accessor :recurse, :recurselimit
+
+    # Produce a hash of files, with merged so that earlier files
+    # with the same postfix win.  E.g., /dir1/subfile beats /dir2/subfile.
+    # It's a hash because we need to know the relative path of each file,
+    # and the base directory.
+    #   This will probably only ever be used for searching for plugins.
+    def self.merge(*filesets)
+        result = {}
+
+        filesets.each do |fileset|
+            fileset.files.each do |file|
+                result[file] ||= fileset.path
+            end
+        end
+
+        result
+    end
 
     # Return a list of all files in our fileset.  This is different from the
     # normal definition of find in that we support specific levels
@@ -30,6 +47,8 @@ class Puppet::FileServing::Fileset
 
     # Should we ignore this path?
     def ignore?(path)
+        return false if @ignore == [nil]
+
         # 'detect' normally returns the found result, whereas we just want true/false.
         ! @ignore.detect { |pattern| File.fnmatch?(pattern, path) }.nil?
     end
@@ -48,21 +67,20 @@ class Puppet::FileServing::Fileset
         @ignore = []
         @links = :manage
         @recurse = false
+        @recurselimit = :infinite
 
-        options.each do |option, value|
-            method = option.to_s + "="
-            begin
-                send(method, value)
-            rescue NoMethodError
-                raise ArgumentError, "Invalid option '%s'" % option
-            end
+        if options.is_a?(Puppet::Indirector::Request)
+            initialize_from_request(options)
+        else
+            initialize_from_hash(options)
         end
 
         raise ArgumentError.new("Fileset paths must exist") unless stat = stat(path)
+        raise ArgumentError.new("Fileset recurse parameter must not be a number anymore, please use recurselimit") if @recurse.is_a?(Integer)
     end
 
     def links=(links)
-        links = links.intern if links.is_a?(String)
+        links = links.to_sym
         raise(ArgumentError, "Invalid :links value '%s'" % links) unless [:manage, :follow].include?(links)
         @links = links
         @stat_method = links == :manage ? :lstat : :stat
@@ -71,19 +89,36 @@ class Puppet::FileServing::Fileset
     # Should we recurse further?  This is basically a single
     # place for all of the logic around recursion.
     def recurse?(depth)
-        # If recurse is true, just return true
-        return true if self.recurse == true
-
-        # Return false if the value is false or zero.
-        return false if [false, 0].include?(self.recurse)
+        # recurse if told to, and infinite recursion or current depth not at the limit
+        self.recurse and (self.recurselimit == :infinite or depth <= self.recurselimit)
+    end
 
-        # Return true if our current depth is less than the allowed recursion depth.
-        return true if self.recurse.is_a?(Fixnum) and depth <= self.recurse
+    def initialize_from_hash(options)
+        options.each do |option, value|
+            method = option.to_s + "="
+            begin
+                send(method, value)
+            rescue NoMethodError
+                raise ArgumentError, "Invalid option '%s'" % option
+            end
+        end
+    end
 
-        # Else, return false.
-        return false
+    def initialize_from_request(request)
+        [:links, :ignore, :recurse, :recurselimit].each do |param|
+            if request.options.include?(param) # use 'include?' so the values can be false
+                value = request.options[param]
+            elsif request.options.include?(param.to_s)
+                value = request.options[param.to_s]
+            end
+            next if value.nil?
+            value = true if value == "true"
+            value = false if value == "false"
+            value = Integer(value) if value.is_a?(String) and value =~ /^\d+$/
+            send(param.to_s + "=", value)
+        end
     end
-    
+
     private
 
     # Pull the recursion logic into one place.  It's moderately hairy, and this

data/lib/puppet/file_serving/indirection_hooks.rb

@@ -9,38 +9,26 @@ require 'puppet/file_serving'
 # in file-serving indirections.  This is necessary because
 # the terminus varies based on the URI asked for.
 module Puppet::FileServing::IndirectionHooks
-    PROTOCOL_MAP = {"puppet" => :rest, "file" => :file, "puppetmounts" => :file_server}
+    PROTOCOL_MAP = {"puppet" => :rest, "file" => :file}
 
     # Pick an appropriate terminus based on the protocol.
     def select_terminus(request)
-        full_uri = request.key
-        # Short-circuit to :file if it's a fully-qualified path.
-        return PROTOCOL_MAP["file"] if full_uri =~ /^#{::File::SEPARATOR}/
-        begin
-            uri = URI.parse(URI.escape(full_uri))
-        rescue => detail
-            raise ArgumentError, "Could not understand URI %s: %s" % [full_uri, detail.to_s]
-        end
+        # We rely on the request's parsing of the URI.
 
-        terminus = PROTOCOL_MAP[uri.scheme] || raise(ArgumentError, "URI protocol '%s' is not supported for file serving" % uri.scheme)
+        # Short-circuit to :file if it's a fully-qualified path or specifies a 'file' protocol.
+        return PROTOCOL_MAP["file"] if request.key =~ /^#{::File::SEPARATOR}/
+        return PROTOCOL_MAP["file"] if request.protocol == "file"
 
-        # This provides a convenient mechanism for people to write configurations work
-        # well in both a networked and local setting.
-        if uri.host.nil? and uri.scheme == "puppet" and Puppet.settings[:name] == "puppet"
-            terminus = :file_server
+        # We're heading over the wire the protocol is 'puppet' and we've got a server name or we're not named 'puppet'
+        if request.protocol == "puppet" and (request.server or Puppet.settings[:name] != "puppet")
+            return PROTOCOL_MAP["puppet"]
         end
 
-        # This is the backward-compatible module terminus.
-        if terminus == :file_server and uri.path =~ %r{^/([^/]+)\b}
-            modname = $1
-            if modname == "modules"
-                terminus = :modules
-            elsif terminus(:modules).find_module(modname, request.options[:node])
-                Puppet.warning "DEPRECATION NOTICE: Found file '%s' in module without using the 'modules' mount; please prefix path with '/modules'" % uri.path
-                terminus = :modules
-            end
+        if request.protocol and PROTOCOL_MAP[request.protocol].nil?
+            raise(ArgumentError, "URI protocol '%s' is not currently supported for file serving" % request.protocol)
         end
 
-        return terminus
+        # If we're still here, we're using the file_server or modules.
+        return :file_server
     end
 end

data/lib/puppet/file_serving/metadata.rb

@@ -5,12 +5,12 @@
 require 'puppet'
 require 'puppet/indirector'
 require 'puppet/file_serving'
-require 'puppet/file_serving/file_base'
+require 'puppet/file_serving/base'
 require 'puppet/util/checksums'
 require 'puppet/file_serving/indirection_hooks'
 
 # A class that handles retrieving file metadata.
-class Puppet::FileServing::Metadata < Puppet::FileServing::FileBase
+class Puppet::FileServing::Metadata < Puppet::FileServing::Base
 
     include Puppet::Util::Checksums
 
@@ -29,8 +29,8 @@ class Puppet::FileServing::Metadata < Puppet::FileServing::FileBase
         }
 
         case ftype
-        when "file", "directory": desc << checksum
-        when "link": desc << @destination
+        when "file", "directory"; desc << checksum
+        when "link"; desc << @destination
         else
             raise ArgumentError, "Cannot manage files of type %s" % ftype
         end
@@ -47,7 +47,7 @@ class Puppet::FileServing::Metadata < Puppet::FileServing::FileBase
     # Retrieve the attributes for this file, relative to a base directory.
     # Note that File.stat raises Errno::ENOENT if the file is absent and this
     # method does not catch that exception.
-    def collect_attributes
+    def collect
         real_path = full_path()
         stat = stat()
         @owner = stat.uid
@@ -59,12 +59,12 @@ class Puppet::FileServing::Metadata < Puppet::FileServing::FileBase
         @mode = stat.mode & 007777
 
         case stat.ftype
-        when "file":
+        when "file"
             @checksum = ("{%s}" % @checksum_type) + send("%s_file" % @checksum_type, real_path).to_s
-        when "directory": # Always just timestamp the directory.
+        when "directory" # Always just timestamp the directory.
             @checksum_type = "ctime"
             @checksum = ("{%s}" % @checksum_type) + send("%s_file" % @checksum_type, path).to_s
-        when "link":
+        when "link"
             @destination = File.readlink(real_path)
         else
             raise ArgumentError, "Cannot manage files of type %s" % stat.ftype

data/lib/puppet/file_serving/mount.rb

@@ -4,6 +4,7 @@
 
 require 'puppet/network/authstore'
 require 'puppet/util/logging'
+require 'puppet/util/cacher'
 require 'puppet/file_serving'
 require 'puppet/file_serving/metadata'
 require 'puppet/file_serving/content'
@@ -13,174 +14,31 @@ require 'puppet/file_serving/content'
 class Puppet::FileServing::Mount < Puppet::Network::AuthStore
     include Puppet::Util::Logging
 
-    @@localmap = nil
-
-    # Clear the cache.  This is only ever used for testing.
-    def self.clear_cache
-        @@localmap = nil
-    end
-
     attr_reader :name
 
-    # Return a new mount with the same properties as +self+, except
-    # with a different name and path.
-    def copy(name, path)
-        result = self.clone
-        result.path = path
-        result.instance_variable_set(:@name, name)
-        return result
-    end
-
-    # Return an instance of the appropriate class.
-    def file(short_file, options = {})
-        file = file_path(short_file, options[:node])
-
-        return nil unless FileTest.exists?(file)
-
-        return file
+    def find(path, options)
+        raise NotImplementedError
     end
 
-    # Return a fully qualified path, given a short path and
-    # possibly a client name.
-    def file_path(relative_path, node = nil)
-        full_path = path(node)
-        raise ArgumentError.new("Mounts without paths are not usable") unless full_path
-
-        # If there's no relative path name, then we're serving the mount itself.
-        return full_path unless relative_path
-
-        return File.join(full_path, relative_path)
-    end
-
-    # Create out object.  It must have a name.
-    def initialize(name, path = nil)
+    # Create our object.  It must have a name.
+    def initialize(name)
         unless name =~ %r{^[-\w]+$}
             raise ArgumentError, "Invalid mount name format '%s'" % name
         end
         @name = name
 
-        if path
-            self.path = path
-        else
-            @path = nil
-        end
-
         super()
     end
 
-    # Return the path as appropriate, expanding as necessary.
-    def path(node = nil)
-        if expandable?
-            return expand(@path, node)
-        else
-            return @path
-        end
-    end
-
-    # Set the path.
-    def path=(path)
-        # FIXME: For now, just don't validate paths with replacement
-        # patterns in them.
-        if path =~ /%./
-            # Mark that we're expandable.
-            @expandable = true
-        else
-            unless FileTest.directory?(path)
-                raise ArgumentError, "%s does not exist or is not a directory" % path
-            end
-            unless FileTest.readable?(path)
-                raise ArgumentError, "%s is not readable" % path
-            end
-            @expandable = false
-        end
-        @path = path
-    end
-
-    def sync(path)
-        @@syncs[path] ||= Sync.new
-        @@syncs[path]
+    def search(path, options)
+        raise NotImplementedError
     end
 
     def to_s
         "mount[%s]" % @name
     end
 
-    # Verify our configuration is valid.  This should really check to
-    # make sure at least someone will be allowed, but, eh.
-    def valid?
-        return ! @path.nil?
-    end
-
-    private
-
-    # LAK:FIXME Move this method to the REST terminus hook.
-    def authcheck(file, client, clientip)
-        raise "This method should be replaced by a REST/terminus hook"
-        # If we're local, don't bother passing in information.
-        if local?
-            client = nil
-            clientip = nil
-        end
-        unless mount.allowed?(client, clientip)
-            mount.warning "%s cannot access %s" %
-                [client, file]
-            raise Puppet::AuthorizationError, "Cannot access %s" % mount
-        end
-    end
-
-    # Create a map for a specific node.
-    def clientmap(node)
-        {
-            "h" => node.sub(/\..*$/, ""), 
-            "H" => node,
-            "d" => node.sub(/[^.]+\./, "") # domain name
-        }
-    end
-
-    # Replace % patterns as appropriate.
-    def expand(path, node = nil)
-        # This map should probably be moved into a method.
-        map = nil
-
-        if node
-            map = clientmap(node)
-        else
-            Puppet.notice "No client; expanding '%s' with local host" %
-                path
-            # Else, use the local information
-            map = localmap()
-        end
-
-        path.gsub(/%(.)/) do |v|
-            key = $1
-            if key == "%" 
-                "%"
-            else
-                map[key] || v
-            end
-        end
-    end
-
-    # Do we have any patterns in our path, yo?
-    def expandable?
-        if defined? @expandable
-            @expandable
-        else
-            false
-        end
-    end
-
-    # Cache this manufactured map, since if it's used it's likely
-    # to get used a lot.
-    def localmap
-        unless @@localmap
-            @@localmap = {
-                "h" =>  Facter.value("hostname"),
-                "H" => [Facter.value("hostname"),
-                        Facter.value("domain")].join("."),
-                "d" =>  Facter.value("domain")
-            }
-        end
-        @@localmap
+    # A noop.
+    def validate
     end
 end