puppet 0.25.5 → 2.6.0

data/lib/puppet/file_serving/configuration/parser.rb

@@ -2,120 +2,121 @@ require 'puppet/file_serving/configuration'
 require 'puppet/util/loadedfile'
 
 class Puppet::FileServing::Configuration::Parser < Puppet::Util::LoadedFile
-    Mount = Puppet::FileServing::Mount
-    MODULES = 'modules'
+  Mount = Puppet::FileServing::Mount
+  MODULES = 'modules'
 
-    # Parse our configuration file.
-    def parse
-        raise("File server configuration %s does not exist" % self.file) unless FileTest.exists?(self.file)
-        raise("Cannot read file server configuration %s" % self.file) unless FileTest.readable?(self.file)
+  # Parse our configuration file.
+  def parse
+    raise("File server configuration #{self.file} does not exist") unless FileTest.exists?(self.file)
+    raise("Cannot read file server configuration #{self.file}") unless FileTest.readable?(self.file)
 
-        @mounts = {}
-        @count = 0
+    @mounts = {}
+    @count = 0
 
-        File.open(self.file) { |f|
-            mount = nil
-            f.each { |line|
-                # Have the count increment at the top, in case we throw exceptions.
-                @count += 1
+    File.open(self.file) { |f|
+      mount = nil
+      f.each { |line|
+        # Have the count increment at the top, in case we throw exceptions.
+        @count += 1
 
-                case line
-                when /^\s*#/; next # skip comments
-                when /^\s*$/; next # skip blank lines
-                when /\[([-\w]+)\]/
-                    mount = newmount($1)
-                when /^\s*(\w+)\s+(.+)$/
-                    var = $1
-                    value = $2
-                    raise(ArgumentError, "Fileserver configuration file does not use '=' as a separator") if value =~ /^=/
-                    case var
-                    when "path"
-                        path(mount, value)
-                    when "allow"
-                        allow(mount, value)
-                    when "deny"
-                        deny(mount, value)
-                    else
-                        raise ArgumentError.new("Invalid argument '%s'" % var,
-                            @count, file)
-                    end
-                else
-                    raise ArgumentError.new("Invalid line '%s'" % line.chomp,
-                        @count, file)
-                end
-            }
-        }
+        case line
+        when /^\s*#/; next # skip comments
+        when /^\s*$/; next # skip blank lines
+        when /\[([-\w]+)\]/
+          mount = newmount($1)
+        when /^\s*(\w+)\s+(.+)$/
+          var = $1
+          value = $2
+          raise(ArgumentError, "Fileserver configuration file does not use '=' as a separator") if value =~ /^=/
+          case var
+          when "path"
+            path(mount, value)
+          when "allow"
+            allow(mount, value)
+          when "deny"
+            deny(mount, value)
+          else
+            raise ArgumentError.new("Invalid argument '#{var}'", @count, file)
+          end
+        else
+          raise ArgumentError.new("Invalid line '#{line.chomp}'", @count, file)
+        end
+      }
+    }
 
-        validate()
+    validate
 
-        return @mounts
-    end
+    @mounts
+  end
 
-    private
+  private
 
-    # Allow a given pattern access to a mount.
-    def allow(mount, value)
-        # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
-        x = value.split(/\s*,\s*/).each { |val|
-            begin
-                mount.info "allowing %s access" % val
-                mount.allow(val)
-            rescue AuthStoreError => detail
-                raise ArgumentError.new(detail.to_s,
-                    @count, file)
-            end
-        }
-    end
+  # Allow a given pattern access to a mount.
+  def allow(mount, value)
+    # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
+    x = value.split(/\s*,\s*/).each { |val|
+      begin
+        mount.info "allowing #{val} access"
+        mount.allow(val)
+      rescue AuthStoreError => detail
 
-    # Deny a given pattern access to a mount.
-    def deny(mount, value)
-        # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
-        x = value.split(/\s*,\s*/).each { |val|
-            begin
-                mount.info "denying %s access" % val
-                mount.deny(val)
-            rescue AuthStoreError => detail
-                raise ArgumentError.new(detail.to_s,
-                    @count, file)
-            end
-        }
-    end
+              raise ArgumentError.new(
+        detail.to_s,
+        
+          @count, file)
+      end
+    }
+  end
 
-    # Create a new mount.
-    def newmount(name)
-        if @mounts.include?(name)
-            raise ArgumentError, "%s is already mounted at %s" %
-                [@mounts[name], name], @count, file
-        end
-        case name
-        when "modules"
-            mount = Mount::Modules.new(name)
-        when "plugins"
-            mount = Mount::Plugins.new(name)
-        else
-            mount = Mount::File.new(name)
-        end
-        @mounts[name] = mount
-        return mount
-    end
+  # Deny a given pattern access to a mount.
+  def deny(mount, value)
+    # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
+    x = value.split(/\s*,\s*/).each { |val|
+      begin
+        mount.info "denying #{val} access"
+        mount.deny(val)
+      rescue AuthStoreError => detail
 
-    # Set the path for a mount.
-    def path(mount, value)
-        if mount.respond_to?(:path=)
-            begin
-                mount.path = value
-            rescue ArgumentError => detail
-                Puppet.err "Removing mount %s: %s" % [mount.name, detail]
-                @mounts.delete(mount.name)
-            end
-        else
-            Puppet.warning "The '#{mount.name}' module can not have a path. Ignoring attempt to set it"
-        end
+              raise ArgumentError.new(
+        detail.to_s,
+        
+          @count, file)
+      end
+    }
+  end
+
+  # Create a new mount.
+  def newmount(name)
+    raise ArgumentError, "#{@mounts[name]} is already mounted at #{name}", @count, file if @mounts.include?(name)
+    case name
+    when "modules"
+      mount = Mount::Modules.new(name)
+    when "plugins"
+      mount = Mount::Plugins.new(name)
+    else
+      mount = Mount::File.new(name)
     end
+    @mounts[name] = mount
+    mount
+  end
 
-    # Make sure all of our mounts are valid.  We have to do this after the fact
-    # because details are added over time as the file is parsed.
-    def validate
-        @mounts.each { |name, mount| mount.validate }
+  # Set the path for a mount.
+  def path(mount, value)
+    if mount.respond_to?(:path=)
+      begin
+        mount.path = value
+      rescue ArgumentError => detail
+        Puppet.err "Removing mount #{mount.name}: #{detail}"
+        @mounts.delete(mount.name)
+      end
+    else
+      Puppet.warning "The '#{mount.name}' module can not have a path. Ignoring attempt to set it"
     end
+  end
+
+  # Make sure all of our mounts are valid.  We have to do this after the fact
+  # because details are added over time as the file is parsed.
+  def validate
+    @mounts.each { |name, mount| mount.validate }
+  end
 end

data/lib/puppet/file_serving/content.rb

@@ -11,39 +11,40 @@ require 'puppet/file_serving/indirection_hooks'
 # It only reads the file when its content is specifically
 # asked for.
 class Puppet::FileServing::Content < Puppet::FileServing::Base
-    extend Puppet::Indirector
-    indirects :file_content, :extend => Puppet::FileServing::IndirectionHooks
-
-    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
+  extend Puppet::Indirector
+  indirects :file_content, :extend => Puppet::FileServing::IndirectionHooks
+
+  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
+
+  # BF: we used to fetch the file content here, but this is counter-productive
+  # for puppetmaster streaming of file content. So collect just returns itself
+  def collect
+    return if stat.ftype == "directory"
+    self
+  end
+
+  # Read the content of our file in.
+  def content
+    unless @content
+      # This stat can raise an exception, too.
+      raise(ArgumentError, "Cannot read the contents of links unless following links") if stat.ftype == "symlink"
+
+      @content = ::File.read(full_path)
     end
+    @content
+  end
 
-    # Read the content of our file in.
-    def content
-        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"
-
-            @content = ::File.read(full_path())
-        end
-        @content
-    end
-
-    def to_raw
-        content
-    end
+  def to_raw
+    File.new(full_path, "r")
+  end
 end

data/lib/puppet/file_serving/fileset.rb

@@ -8,166 +8,164 @@ 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, :recurselimit, :checksum_type
-
-    # 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
+  attr_reader :path, :ignore, :links
+  attr_accessor :recurse, :recurselimit, :checksum_type
+
+  # 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
 
-    # 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
+    result
+  end
 
-        # 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{^#{Regexp.escape(@path)}/*}, '') }
+  # 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
 
-        # And add the path itself.
-        result.unshift(".")
+    # 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{^#{Regexp.escape(@path)}/*}, '') }
 
-        result
-    end
-
-    # Should we ignore this path?
-    def ignore?(path)
-        return false if @ignore == [nil]
+    # And add the path itself.
+    result.unshift(".")
 
-        # '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
+    result
+  end
 
-    def initialize(path, options = {})
-        raise ArgumentError.new("Fileset paths must be fully qualified") unless path =~ /^#{::File::SEPARATOR}/
+  # Should we ignore this path?
+  def ignore?(path)
+    return false if @ignore == [nil]
 
-        @path = path
+    # 'detect' normally returns the found result, whereas we just want true/false.
+    ! @ignore.detect { |pattern| File.fnmatch?(pattern, path) }.nil?
+  end
 
-        # Set our defaults.
-        @ignore = []
-        @links = :manage
-        @recurse = false
-        @recurselimit = :infinite
+  def ignore=(values)
+    values = [values] unless values.is_a?(Array)
+    @ignore = values
+  end
 
-        if options.is_a?(Puppet::Indirector::Request)
-            initialize_from_request(options)
-        else
-            initialize_from_hash(options)
-        end
+  def initialize(path, options = {})
+    raise ArgumentError.new("Fileset paths must be fully qualified") unless File.expand_path(path) == path
 
-        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
+    @path = path
 
-    def links=(links)
-        links = links.to_sym
-        raise(ArgumentError, "Invalid :links value '%s'" % links) unless [:manage, :follow].include?(links)
-        @links = links
-        @stat_method = links == :manage ? :lstat : :stat
-    end
+    # Set our defaults.
+    @ignore = []
+    @links = :manage
+    @recurse = false
+    @recurselimit = :infinite
 
-    # Should we recurse further?  This is basically a single
-    # place for all of the logic around recursion.
-    def recurse?(depth)
-        # recurse if told to, and infinite recursion or current depth not at the limit
-        self.recurse and (self.recurselimit == :infinite or depth <= self.recurselimit)
+    if options.is_a?(Puppet::Indirector::Request)
+      initialize_from_request(options)
+    else
+      initialize_from_hash(options)
     end
 
-    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
+    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.to_sym
+    raise(ArgumentError, "Invalid :links value '#{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)
+    # 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
+
+  def initialize_from_hash(options)
+    options.each do |option, value|
+      method = option.to_s + "="
+      begin
+        send(method, value)
+      rescue NoMethodError
+        raise ArgumentError, "Invalid option '#{option}'"
+      end
     end
-
-    def initialize_from_request(request)
-        [:links, :ignore, :recurse, :recurselimit, :checksum_type].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
+
+  def initialize_from_request(request)
+    [:links, :ignore, :recurse, :recurselimit, :checksum_type].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
+  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]
+  # 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 = []
+    next_dirs = []
 
-        depth = 1
+    depth = 1
 
-        result = []
-        return result unless recurse?(depth)
+    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?
+    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)
+      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)
+        # 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)
+        # 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
+        # And to our list of files/directories to iterate over.
+        next_dirs << File.join(dir_path, file_path)
+      end
     end
-    public
-    # 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
+
+    result
+  end
+  public
+  # Stat a given file, using the links-appropriate method.
+  def stat(path)
+    @stat_method ||= self.links == :manage ? :lstat : :stat
+
+    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