puppet-parse 0.0.1 → 0.0.2

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

@@ -0,0 +1,122 @@
+require 'monitor'
+require 'puppet'
+require 'puppet/file_serving'
+require 'puppet/file_serving/mount'
+require 'puppet/file_serving/mount/file'
+require 'puppet/file_serving/mount/modules'
+require 'puppet/file_serving/mount/plugins'
+
+class Puppet::FileServing::Configuration
+  require 'puppet/file_serving/configuration/parser'
+
+  extend MonitorMixin
+
+  def self.configuration
+    synchronize do
+      @configuration ||= new
+    end
+  end
+
+  Mount = Puppet::FileServing::Mount
+
+  private_class_method  :new
+
+  attr_reader :mounts
+  #private :mounts
+
+  # Find the right mount.  Does some shenanigans to support old-style module
+  # mounts.
+  def find_mount(mount_name, environment)
+    # Reparse the configuration if necessary.
+    readconfig
+
+    if mount = mounts[mount_name]
+      return mount
+    end
+
+    if environment.module(mount_name)
+      Puppet::Util::Warnings.notice_once "DEPRECATION NOTICE: Files found in modules without specifying 'modules' in file path will be deprecated in the next major release.  Please fix module '#{mount_name}' when no 0.24.x clients are present"
+      return mounts["modules"]
+    end
+
+    # This can be nil.
+    mounts[mount_name]
+  end
+
+  def initialize
+    @mounts = {}
+    @config_file = nil
+
+    # We don't check to see if the file is modified the first time,
+    # because we always want to parse at first.
+    readconfig(false)
+  end
+
+  # Is a given mount available?
+  def mounted?(name)
+    @mounts.include?(name)
+  end
+
+  # Split the path into the separate mount point and path.
+  def split_path(request)
+    # Reparse the configuration if necessary.
+    readconfig
+
+    mount_name, path = request.key.split(File::Separator, 2)
+
+    raise(ArgumentError, "Cannot find file: Invalid mount '#{mount_name}'") unless mount_name =~ %r{^[-\w]+$}
+    raise(ArgumentError, "Cannot find file: Invalid relative path '#{path}'") if path and path.split('/').include?('..')
+
+    return nil unless mount = find_mount(mount_name, request.environment)
+    if mount.name == "modules" and mount_name != "modules"
+      # yay backward-compatibility
+      path = "#{mount_name}/#{path}"
+    end
+
+    if path == ""
+      path = nil
+    elsif path
+      # Remove any double slashes that might have occurred
+      path = path.gsub(/\/+/, "/")
+    end
+
+    return mount, path
+  end
+
+  def umount(name)
+    @mounts.delete(name) if @mounts.include? name
+  end
+
+  private
+
+  def mk_default_mounts
+    @mounts["modules"] ||= Mount::Modules.new("modules")
+    @mounts["modules"].allow('*') if @mounts["modules"].empty?
+    @mounts["plugins"] ||= Mount::Plugins.new("plugins")
+    @mounts["plugins"].allow('*') if @mounts["plugins"].empty?
+  end
+
+  # Read the configuration file.
+  def readconfig(check = true)
+    config = Puppet[:fileserverconfig]
+
+    return unless FileTest.exists?(config)
+
+    @parser ||= Puppet::FileServing::Configuration::Parser.new(config)
+
+    return if check and ! @parser.changed?
+
+    # Don't assign the mounts hash until we're sure the parsing succeeded.
+    begin
+      newmounts = @parser.parse
+      @mounts = newmounts
+    rescue => detail
+      puts detail.backtrace if Puppet[:trace]
+      Puppet.err "Error parsing fileserver configuration: #{detail}; using old configuration"
+    end
+
+  ensure
+    # Make sure we've got our plugins and modules.
+    mk_default_mounts
+  end
+end

data/lib/vendor/puppet/file_serving/content.rb

@@ -0,0 +1,45 @@
+require 'puppet/indirector'
+require 'puppet/file_serving'
+require 'puppet/file_serving/base'
+
+# 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::Base
+  extend Puppet::Indirector
+  indirects :file_content, :terminus_class => :selector
+
+  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 = IO.binread(full_path)
+    end
+    @content
+  end
+
+  def to_raw
+    File.new(full_path, "rb")
+  end
+end

data/lib/vendor/puppet/file_serving/fileset.rb

@@ -0,0 +1,173 @@
+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, :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
+  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
+
+    # 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)}/*}, '') }
+
+    # And add the path itself.
+    result.unshift(".")
+
+    result
+  end
+
+  # 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
+
+  def ignore=(values)
+    values = [values] unless values.is_a?(Array)
+    @ignore = values
+  end
+
+  def initialize(path, options = {})
+    if Puppet.features.microsoft_windows?
+      # REMIND: UNC path
+      path = path.chomp(File::SEPARATOR) unless path =~ /^[A-Za-z]:\/$/
+    else
+      path = path.chomp(File::SEPARATOR) unless path == File::SEPARATOR
+    end
+    raise ArgumentError.new("Fileset paths must be fully qualified: #{path}") unless Puppet::Util.absolute_path?(path)
+
+    @path = path
+
+    # Set our defaults.
+    @ignore = []
+    @links = :manage
+    @recurse = false
+    @recurselimit = :infinite
+
+    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.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
+  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
+
+  # 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
+
+    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

data/lib/vendor/puppet/file_serving/metadata.rb

@@ -0,0 +1,155 @@
+require 'puppet'
+require 'puppet/indirector'
+require 'puppet/file_serving'
+require 'puppet/file_serving/base'
+require 'puppet/util/checksums'
+
+# A class that handles retrieving file metadata.
+class Puppet::FileServing::Metadata < Puppet::FileServing::Base
+
+  include Puppet::Util::Checksums
+
+  extend Puppet::Indirector
+  indirects :file_metadata, :terminus_class => :selector
+
+  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
+
+  class MetaStat
+    extend Forwardable
+
+    def initialize(stat)
+      @stat = stat
+    end
+
+    def_delegator :@stat, :uid, :owner
+    def_delegator :@stat, :gid, :group
+    def_delegators :@stat, :mode, :ftype
+  end
+
+  class WindowsStat < MetaStat
+    if Puppet.features.microsoft_windows?
+      require 'puppet/util/windows/security'
+    end
+
+    def initialize(stat, path)
+      super(stat)
+      @path = path
+    end
+
+    { :owner => 'S-1-5-32-544',
+      :group => 'S-1-0-0',
+      :mode => 0644
+    }.each do |method, default_value|
+      define_method method do
+        Puppet::Util::Windows::Security.send("get_#{method}", @path) || default_value
+      end
+    end
+  end
+
+  def collect_stat(path)
+    stat = stat()
+
+    if Puppet.features.microsoft_windows?
+      WindowsStat.new(stat, path)
+    else
+      MetaStat.new(stat)
+    end
+  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 = collect_stat(real_path)
+    @owner = stat.owner
+    @group = stat.group
+    @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
+  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 self.from_pson(data)
+    new(data.delete('path'), data)
+  end
+
+end

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

@@ -0,0 +1,121 @@
+require 'puppet/file_serving/mount'
+
+class Puppet::FileServing::Mount::File < Puppet::FileServing::Mount
+  def self.localmap
+    @localmap ||= {
+      "h" => Facter.value("hostname"),
+      "H" => [
+               Facter.value("hostname"),
+               Facter.value("domain")
+             ].join("."),
+      "d" => Facter.value("domain")
+    }
+  end
+
+  def complete_path(relative_path, node)
+    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
+
+    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
+
+    file
+  end
+
+  # Return an instance of the appropriate class.
+  def find(short_file, request)
+    complete_path(short_file, request.node)
+  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
+      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
+    @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
+
+    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
+    self.class.localmap
+  end
+end

data/lib/vendor/puppet/file_serving/mount/modules.rb

@@ -0,0 +1,24 @@
+require 'puppet/file_serving/mount'
+
+# This is the modules-specific mount: it knows how to search through
+# modules for files.  Yay.
+class Puppet::FileServing::Mount::Modules < Puppet::FileServing::Mount
+  # Return an instance of the appropriate class.
+  def find(path, request)
+    raise "No module specified" if path.to_s.empty?
+    module_name, relative_path = path.split("/", 2)
+    return nil unless mod = request.environment.module(module_name)
+
+    mod.file(relative_path)
+  end
+
+  def search(path, request)
+    if result = find(path, request)
+      [result]
+    end
+  end
+
+  def valid?
+    true
+  end
+end

data/lib/vendor/puppet/file_serving/mount/plugins.rb

@@ -0,0 +1,26 @@
+require 'puppet/file_serving/mount'
+
+# Find files in the modules' plugins directories.
+# This is a very strange mount because it merges
+# many directories into one.
+class Puppet::FileServing::Mount::Plugins < Puppet::FileServing::Mount
+  # Return an instance of the appropriate class.
+  def find(relative_path, request)
+    return nil unless mod = request.environment.modules.find { |mod|  mod.plugin(relative_path) }
+
+    path = mod.plugin(relative_path)
+
+    path
+  end
+
+  def search(relative_path, request)
+    # We currently only support one kind of search on plugins - return
+    # them all.
+    paths = request.environment.modules.find_all { |mod| mod.plugins? }.collect { |mod| mod.plugin_directory }
+    return(paths.empty? ? nil : paths)
+  end
+
+  def valid?
+    true
+  end
+end

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

@@ -0,0 +1,39 @@
+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
+
+  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 '#{name}'"
+    end
+    @name = name
+
+    super()
+  end
+
+  def search(path, options)
+    raise NotImplementedError
+  end
+
+  def to_s
+    "mount[#{@name}]"
+  end
+
+  # A noop.
+  def validate
+  end
+end