puppet 0.23.2 → 0.24.0

data/lib/puppet/file_serving/content.rb

@@ -0,0 +1,34 @@
+#
+#  Created by Luke Kanies on 2007-10-16.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'puppet/indirector'
+require 'puppet/file_serving'
+require 'puppet/file_serving/file_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
+    extend Puppet::Indirector
+    indirects :file_content, :extend => Puppet::FileServing::IndirectionHooks
+
+    attr_reader :path
+
+    # 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" 
+
+        ::File.read(full_path())
+    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
+        content
+    end
+end

data/lib/puppet/file_serving/file_base.rb

@@ -0,0 +1,63 @@
+#
+#  Created by Luke Kanies on 2007-10-22.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'puppet/file_serving'
+
+# The base class for Content and Metadata; provides common
+# functionality like the behaviour around links.
+class Puppet::FileServing::FileBase
+    attr_accessor :key
+
+    # Return the full path to our file.  Fails if there's no path set.
+    def full_path
+        raise(ArgumentError, "You must set a path to get a file's path") unless self.path
+
+        relative_path ? File.join(path, relative_path) : path
+    end
+
+    def initialize(key, options = {})
+        raise ArgumentError.new("Files must not be fully qualified") if path =~ /^#{::File::SEPARATOR}/
+
+        @key = key
+        @links = :manage
+
+        options.each do |param, value|
+            begin
+                send param.to_s + "=", value
+            rescue NoMethodError
+                raise ArgumentError, "Invalid option %s for %s" % [param, self.class]
+            end
+        end
+    end
+
+    # Determine how we deal with links.
+    attr_reader :links
+    def links=(value)
+        raise(ArgumentError, ":links can only be set to :manage or :follow") unless [:manage, :follow].include?(value) 
+        @links = value
+    end
+
+    # Set our base path.
+    attr_reader :path
+    def path=(path)
+        raise ArgumentError.new("Paths must be fully qualified") unless path =~ /^#{::File::SEPARATOR}/
+        @path = path
+    end
+
+    # Set a relative path; this is used for recursion, and sets
+    # the file's path relative to the initial recursion point.
+    attr_reader :relative_path
+    def relative_path=(path)
+        raise ArgumentError.new("Relative paths must not be fully qualified") if path =~ /^#{::File::SEPARATOR}/
+        @relative_path = path
+    end
+
+    # Stat our file, using the appropriate link-sensitive method.
+    def stat
+        unless defined?(@stat_method)
+            @stat_method = self.links == :manage ? :lstat : :stat
+        end
+        File.send(@stat_method, full_path())
+    end
+end

data/lib/puppet/file_serving/fileset.rb

@@ -0,0 +1,138 @@
+#
+#  Created by Luke Kanies on 2007-10-22.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'find'
+require 'puppet/file_serving'
+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
+
+    # Return a list of all files in our fileset.  This is different from the
+    # normal definition of find in that we support specific levels
+    # of recursion, which means we need to know when we're going another
+    # level deep, which Find doesn't do.
+    def files
+        files = perform_recursion
+
+        # Now strip off the leading path, so each file becomes relative, and remove
+        # any slashes that might end up at the beginning of the path.
+        result = files.collect { |file| file.sub(%r{^#{@path}/*}, '') }
+
+        # And add the path itself.
+        result.unshift(".")
+
+        result
+    end
+
+    # Should we ignore this path?
+    def ignore?(path)
+        # 'detect' normally returns the found result, whereas we just want true/false.
+        ! @ignore.detect { |pattern| File.fnmatch?(pattern, path) }.nil?
+    end
+
+    def ignore=(values)
+        values = [values] unless values.is_a?(Array)
+        @ignore = values
+    end
+
+    def initialize(path, options = {})
+        raise ArgumentError.new("Fileset paths must be fully qualified") unless path =~ /^#{::File::SEPARATOR}/
+
+        @path = path
+
+        # Set our defaults.
+        @ignore = []
+        @links = :manage
+        @recurse = false
+
+        options.each do |option, value|
+            method = option.to_s + "="
+            begin
+                send(method, value)
+            rescue NoMethodError
+                raise ArgumentError, "Invalid option '%s'" % option
+            end
+        end
+
+        raise ArgumentError.new("Fileset paths must exist") unless stat = stat(path)
+    end
+
+    def links=(links)
+        links = links.intern if links.is_a?(String)
+        raise(ArgumentError, "Invalid :links value '%s'" % links) unless [:manage, :follow].include?(links)
+        @links = links
+        @stat_method = links == :manage ? :lstat : :stat
+    end
+
+    # 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)
+
+        # 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
+
+        # Else, return false.
+        return false
+    end
+    
+    private
+
+    # Pull the recursion logic into one place.  It's moderately hairy, and this
+    # allows us to keep the hairiness apart from what we do with the files.
+    def perform_recursion
+        # Start out with just our base directory.
+        current_dirs = [@path]
+
+        next_dirs = []
+
+        depth = 1
+
+        result = []
+        return result unless recurse?(depth)
+
+        while dir_path = current_dirs.shift or ((depth += 1) and recurse?(depth) and current_dirs = next_dirs and next_dirs = [] and dir_path = current_dirs.shift)
+            next unless stat = stat(dir_path)
+            next unless stat.directory?
+
+            Dir.entries(dir_path).each do |file_path|
+                next if [".", ".."].include?(file_path)
+
+                # Note that this also causes matching directories not
+                # to be recursed into.
+                next if ignore?(file_path)
+
+                # Add it to our list of files to return
+                result << File.join(dir_path, file_path)
+
+                # And to our list of files/directories to iterate over.
+                next_dirs << File.join(dir_path, file_path)
+            end
+        end
+
+        return result
+    end
+
+    # Stat a given file, using the links-appropriate method.
+    def stat(path)
+        unless defined?(@stat_method)
+            @stat_method = self.links == :manage ? :lstat : :stat
+        end
+
+        begin
+            return File.send(@stat_method, path)
+        rescue
+            # If this happens, it is almost surely because we're
+            # trying to manage a link to a file that does not exist.
+            return nil
+        end
+    end
+end

data/lib/puppet/file_serving/indirection_hooks.rb

@@ -0,0 +1,44 @@
+#
+#  Created by Luke Kanies on 2007-10-18.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'uri'
+require 'puppet/file_serving'
+
+# This module is used to pick the appropriate terminus
+# 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}
+
+    # Pick an appropriate terminus based on the protocol.
+    def select_terminus(full_uri, options = {})
+        # 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
+
+        terminus = PROTOCOL_MAP[uri.scheme] || raise(ArgumentError, "URI protocol '%s' is not supported for file serving" % uri.scheme)
+
+        # 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
+        end
+
+        if terminus == :file_server and uri.path =~ %r{^/([^/]+)\b}
+            modname = $1
+            if modname == "modules"
+                terminus = :modules
+            elsif terminus(:modules).find_module(modname, 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
+        end
+
+        return terminus
+    end
+end

data/lib/puppet/file_serving/metadata.rb

@@ -0,0 +1,69 @@
+#
+#  Created by Luke Kanies on 2007-10-16.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'puppet'
+require 'puppet/indirector'
+require 'puppet/file_serving'
+require 'puppet/file_serving/file_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
+    module MetadataHelper
+        include Puppet::FileServing::IndirectionHooks
+
+        def post_find(instance)
+        end
+
+        def post_search(key, options = {})
+        end
+    end
+
+    include Puppet::Util::Checksums
+
+    extend Puppet::Indirector
+    indirects :file_metadata, :extend => Puppet::FileServing::IndirectionHooks
+
+    attr_reader :path, :owner, :group, :mode, :checksum_type, :checksum, :ftype, :destination
+
+    def checksum_type=(type)
+        raise(ArgumentError, "Unsupported checksum type %s" % type) unless respond_to?("%s_file" % type)
+
+        @checksum_type = type
+    end
+
+    # 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
+        real_path = full_path()
+        stat = stat()
+        @owner = stat.uid
+        @group = stat.gid
+        @ftype = stat.ftype
+
+
+        # Set the octal mode, but as a string.
+        @mode = "%o" % (stat.mode & 007777)
+
+        if stat.ftype == "symlink"
+            @destination = File.readlink(real_path)
+        else
+            @checksum = get_checksum(real_path)
+        end
+    end
+
+    def initialize(*args)
+        @checksum_type = "md5"
+        super
+    end
+
+    private
+
+    # Retrieve our checksum.
+    def get_checksum(path)
+        ("{%s}" % @checksum_type) + send("%s_file" % @checksum_type, path)
+    end
+end

data/lib/puppet/file_serving/mount.rb

@@ -0,0 +1,186 @@
+#
+#  Created by Luke Kanies on 2007-10-16.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'puppet/network/authstore'
+require 'puppet/util/logging'
+require 'puppet/file_serving'
+require 'puppet/file_serving/metadata'
+require 'puppet/file_serving/content'
+
+# Broker access to the filesystem, converting local URIs into metadata
+# or content objects.
+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
+    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)
+        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]
+    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
+    end
+end