puppet 0.25.5 → 2.6.0

data/lib/puppet/file_serving/indirection_hooks.rb

@@ -9,26 +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}
+  PROTOCOL_MAP = {"puppet" => :rest, "file" => :file}
 
-    # Pick an appropriate terminus based on the protocol.
-    def select_terminus(request)
-        # We rely on the request's parsing of the URI.
+  # Pick an appropriate terminus based on the protocol.
+  def select_terminus(request)
+    # We rely on the request's parsing of the URI.
 
-        # 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"
+    # 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"
 
-        # 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
-
-        if request.protocol and PROTOCOL_MAP[request.protocol].nil?
-            raise(ArgumentError, "URI protocol '%s' is not currently supported for file serving" % request.protocol)
-        end
+    # 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
 
-        # If we're still here, we're using the file_server or modules.
-        return :file_server
+    if request.protocol and PROTOCOL_MAP[request.protocol].nil?
+      raise(ArgumentError, "URI protocol '#{request.protocol}' is not currently supported for file serving")
     end
+
+    # If we're still here, we're using the file_server or modules.
+    :file_server
+  end
 end

data/lib/puppet/file_serving/metadata.rb

@@ -12,104 +12,107 @@ require 'puppet/file_serving/indirection_hooks'
 # A class that handles retrieving file metadata.
 class Puppet::FileServing::Metadata < Puppet::FileServing::Base
 
-    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
-
-    PARAM_ORDER = [:mode, :ftype, :owner, :group]
-
-    def attributes_with_tabs
-        raise(ArgumentError, "Cannot manage files of type #{ftype}") unless ['file','directory','link'].include? ftype
-        desc = []
-        PARAM_ORDER.each { |check|
-            check = :ftype if check == :type
-            desc << send(check)
-        }
-
-        desc << checksum
-        desc << @destination rescue nil if ftype == 'link'
-
-        return desc.join("\t")
-    end
-
-    def checksum_type=(type)
-        raise(ArgumentError, "Unsupported checksum type %s" % type) unless respond_to?("%s_file" % type)
-
-        @checksum_type = type
+  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
+
+  PARAM_ORDER = [:mode, :ftype, :owner, :group]
+
+  def attributes_with_tabs
+    raise(ArgumentError, "Cannot manage files of type #{ftype}") unless ['file','directory','link'].include? ftype
+    desc = []
+    PARAM_ORDER.each { |check|
+      check = :ftype if check == :type
+      desc << send(check)
+    }
+
+    desc << checksum
+    desc << @destination rescue nil if ftype == 'link'
+
+    desc.join("\t")
+  end
+
+  def checksum_type=(type)
+    raise(ArgumentError, "Unsupported checksum type #{type}") unless respond_to?("#{type}_file")
+
+    @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
+    real_path = full_path
+    stat = stat()
+    @owner = stat.uid
+    @group = stat.gid
+    @ftype = stat.ftype
+
+
+    # We have to mask the mode, yay.
+    @mode = stat.mode & 007777
+
+    case stat.ftype
+    when "file"
+      @checksum = ("{#{@checksum_type}}") + send("#{@checksum_type}_file", real_path).to_s
+    when "directory" # Always just timestamp the directory.
+      @checksum_type = "ctime"
+      @checksum = ("{#{@checksum_type}}") + send("#{@checksum_type}_file", path).to_s
+    when "link"
+      @destination = File.readlink(real_path)
+      @checksum = ("{#{@checksum_type}}") + send("#{@checksum_type}_file", real_path).to_s rescue nil
+    else
+      raise ArgumentError, "Cannot manage files of type #{stat.ftype}"
     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
-        real_path = full_path()
-        stat = stat()
-        @owner = stat.uid
-        @group = stat.gid
-        @ftype = stat.ftype
-
-
-        # We have to mask the mode, yay.
-        @mode = stat.mode & 007777
-
-        case stat.ftype
-        when "file"
-            @checksum = ("{%s}" % @checksum_type) + send("%s_file" % @checksum_type, real_path).to_s
-        when "directory" # Always just timestamp the directory.
-            @checksum_type = "ctime"
-            @checksum = ("{%s}" % @checksum_type) + send("%s_file" % @checksum_type, path).to_s
-        when "link"
-            @destination = File.readlink(real_path)
-            @checksum = ("{%s}" % @checksum_type) + send("%s_file" % @checksum_type, real_path).to_s rescue nil
-        else
-            raise ArgumentError, "Cannot manage files of type %s" % stat.ftype
-        end
-    end
-
-    def initialize(path,data={})
-        @owner       = data.delete('owner')
-        @group       = data.delete('group')
-        @mode        = data.delete('mode')
-        if checksum = data.delete('checksum')
-            @checksum_type = checksum['type']
-            @checksum      = checksum['value']
-        end
-        @checksum_type ||= "md5"
-        @ftype       = data.delete('type')
-        @destination = data.delete('destination')
-        super(path,data)
-    end
-
-    PSON.register_document_type('FileMetadata',self)
-    def to_pson_data_hash
-        {
-            'document_type' => 'FileMetadata',
-            'data'       => super['data'].update({
-                'owner'        => owner,
-                'group'        => group,
-                'mode'         => mode,
-                'checksum'     => {
-                    'type'   => checksum_type,
-                    'value'  => checksum
-                },
-                'type'         => ftype,
-                'destination'  => destination,
-                }),
-            'metadata' => {
-                'api_version' => 1
-                }
-       }
+  end
+
+  def initialize(path,data={})
+    @owner       = data.delete('owner')
+    @group       = data.delete('group')
+    @mode        = data.delete('mode')
+    if checksum = data.delete('checksum')
+      @checksum_type = checksum['type']
+      @checksum      = checksum['value']
     end
+    @checksum_type ||= "md5"
+    @ftype       = data.delete('type')
+    @destination = data.delete('destination')
+    super(path,data)
+  end
+
+  PSON.register_document_type('FileMetadata',self)
+  def to_pson_data_hash
+    {
+      'document_type' => 'FileMetadata',
+
+        'data'       => super['data'].update(
+          {
+          'owner'        => owner,
+          'group'        => group,
+          'mode'         => mode,
+          'checksum'     => {
+            'type'   => checksum_type,
+            'value'  => checksum
+        },
+        'type'         => ftype,
+        'destination'  => destination,
+
+        }),
+      'metadata' => {
+        'api_version' => 1
+        }
+    }
+  end
 
-    def to_pson(*args)
-       to_pson_data_hash.to_pson(*args)
-    end
+  def to_pson(*args)
+    to_pson_data_hash.to_pson(*args)
+  end
 
-    def self.from_pson(data)
-       new(data.delete('path'), data)
-    end
+  def self.from_pson(data)
+    new(data.delete('path'), data)
+  end
 
 end

data/lib/puppet/file_serving/mount.rb

@@ -12,33 +12,33 @@ 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
+  include Puppet::Util::Logging
 
-    attr_reader :name
+  attr_reader :name
 
-    def find(path, options)
-        raise NotImplementedError
-    end
-
-    # 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
+  def find(path, options)
+    raise NotImplementedError
+  end
 
-        super()
+  # Create our object.  It must have a name.
+  def initialize(name)
+    unless name =~ %r{^[-\w]+$}
+      raise ArgumentError, "Invalid mount name format '#{name}'"
     end
+    @name = name
 
-    def search(path, options)
-        raise NotImplementedError
-    end
+    super()
+  end
 
-    def to_s
-        "mount[%s]" % @name
-    end
+  def search(path, options)
+    raise NotImplementedError
+  end
 
-    # A noop.
-    def validate
-    end
+  def to_s
+    "mount[#{@name}]"
+  end
+
+  # A noop.
+  def validate
+  end
 end

data/lib/puppet/file_serving/mount/file.rb

@@ -3,127 +3,122 @@ require 'puppet/util/cacher'
 require 'puppet/file_serving/mount'
 
 class Puppet::FileServing::Mount::File < Puppet::FileServing::Mount
-    class << self
-        include Puppet::Util::Cacher
-
-        cached_attr(:localmap) do
-            {   "h" =>  Facter.value("hostname"),
-                "H" => [Facter.value("hostname"),
-                        Facter.value("domain")].join("."),
-                "d" =>  Facter.value("domain")
-            }
-        end
+  class << self
+    include Puppet::Util::Cacher
+
+    cached_attr(:localmap) do
+      {   "h" =>  Facter.value("hostname"),
+        "H" => [Facter.value("hostname"),
+            Facter.value("domain")].join("."),
+        "d" =>  Facter.value("domain")
+      }
     end
+  end
 
-    def complete_path(relative_path, node)
-        full_path = path(node)
+  def complete_path(relative_path, node)
+    full_path = path(node)
 
-        raise ArgumentError.new("Mounts without paths are not usable") unless full_path
+    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
+    # If there's no relative path name, then we're serving the mount itself.
+    return full_path unless relative_path
 
-        file = ::File.join(full_path, relative_path)
+    file = ::File.join(full_path, relative_path)
 
-        if !(FileTest.exist?(file) or FileTest.symlink?(file))
-            Puppet.info("File does not exist or is not accessible: #{file}")
-            return nil
-        end
-
-        return file
+    if !(FileTest.exist?(file) or FileTest.symlink?(file))
+      Puppet.info("File does not exist or is not accessible: #{file}")
+      return nil
     end
 
-    # Return an instance of the appropriate class.
-    def find(short_file, request)
-        complete_path(short_file, request.node)
-    end
+    file
+  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
+  # Return an instance of the appropriate class.
+  def find(short_file, request)
+    complete_path(short_file, request.node)
+  end
 
-    def search(path, request)
-        return nil unless path = complete_path(path, request.node)
-        return [path]
+  # Return the path as appropriate, expanding as necessary.
+  def path(node = nil)
+    if expandable?
+      return expand(@path, node)
+    else
+      return @path
     end
-
-    # Verify our configuration is valid.  This should really check to
-    # make sure at least someone will be allowed, but, eh.
-    def validate
-        raise ArgumentError.new("Mounts without paths are not usable") if @path.nil?
+  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
+      raise ArgumentError, "#{path} does not exist or is not a directory" unless FileTest.directory?(path)
+      raise ArgumentError, "#{path} is not readable" unless FileTest.readable?(path)
+      @expandable = false
     end
-
-    private
-
-    # Create a map for a specific node.
-    def clientmap(node)
-        {
-            "h" => node.sub(/\..*$/, ""),
-            "H" => node,
-            "d" => node.sub(/[^.]+\./, "") # domain name
-        }
+    @path = path
+  end
+
+  def search(path, request)
+    return nil unless path = complete_path(path, request.node)
+    [path]
+  end
+
+  # Verify our configuration is valid.  This should really check to
+  # make sure at least someone will be allowed, but, eh.
+  def validate
+    raise ArgumentError.new("Mounts without paths are not usable") if @path.nil?
+  end
+
+  private
+
+  # 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 '#{path}' with local host"
+      # Else, use the local information
+      map = localmap
     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
+    path.gsub(/%(.)/) do |v|
+      key = $1
+      if key == "%"
+        "%"
+      else
+        map[key] || v
+      end
     end
-
-    # Do we have any patterns in our path, yo?
-    def expandable?
-        if defined? @expandable
-            @expandable
-        else
-            false
-        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
-        self.class.localmap
-    end
+  # Cache this manufactured map, since if it's used it's likely
+  # to get used a lot.
+  def localmap
+    self.class.localmap
+  end
 end