openvox 7.37.1

data/lib/puppet/file_serving/metadata.rb

@@ -0,0 +1,171 @@
+require_relative '../../puppet'
+require_relative '../../puppet/indirector'
+require_relative '../../puppet/file_serving'
+require_relative '../../puppet/file_serving/base'
+require_relative '../../puppet/util/checksums'
+require 'uri'
+
+# 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, :source_permissions, :content_uri
+
+  PARAM_ORDER = [:mode, :ftype, :owner, :group]
+
+  def checksum_type=(type)
+    raise(ArgumentError, _("Unsupported checksum type %{type}") % { type: type }) unless Puppet::Util::Checksums.respond_to?("#{type}_file")
+
+    @checksum_type = type
+  end
+
+  def source_permissions=(source_permissions)
+    raise(ArgumentError, _("Unsupported source_permission %{source_permissions}") % { source_permissions: source_permissions }) unless [:use, :use_when_creating, :ignore].include?(source_permissions.intern)
+
+    @source_permissions = source_permissions.intern
+  end
+
+  def content_uri=(path)
+    begin
+      uri = URI.parse(Puppet::Util.uri_encode(path))
+    rescue URI::InvalidURIError => detail
+      raise(ArgumentError, _("Could not understand URI %{path}: %{detail}") % { path: path, detail: detail })
+    end
+    raise(ArgumentError, _("Cannot use opaque URLs '%{path}'") % { path: path }) unless uri.hierarchical?
+    raise(ArgumentError, _("Must use URLs of type puppet as content URI")) if uri.scheme != "puppet"
+
+    @content_uri = path.encode(Encoding::UTF_8)
+  end
+
+  class MetaStat
+    extend Forwardable
+
+    def initialize(stat, source_permissions)
+      @stat = stat
+      @source_permissions_ignore = (!source_permissions || source_permissions == :ignore)
+    end
+
+    def owner
+      @source_permissions_ignore ? Process.euid : @stat.uid
+    end
+
+    def group
+      @source_permissions_ignore ? Process.egid : @stat.gid
+    end
+
+    def mode
+      @source_permissions_ignore ? 0644 : @stat.mode
+    end
+
+    def_delegators :@stat, :ftype
+  end
+
+  class WindowsStat < MetaStat
+    if Puppet::Util::Platform.windows?
+      require_relative '../../puppet/util/windows/security'
+    end
+
+    def initialize(stat, path, source_permissions)
+      super(stat, source_permissions)
+      @path = path
+      raise(ArgumentError, _("Unsupported Windows source permissions option %{source_permissions}") % { source_permissions: source_permissions }) unless @source_permissions_ignore
+    end
+
+    { :owner => 'S-1-5-32-544',
+      :group => 'S-1-0-0',
+      :mode => 0644
+    }.each do |method, default_value|
+      define_method method do
+        return default_value
+      end
+    end
+  end
+
+  def collect_stat(path)
+    stat = stat()
+
+    if Puppet::Util::Platform.windows?
+      WindowsStat.new(stat, path, @source_permissions)
+    else
+      MetaStat.new(stat, @source_permissions)
+    end
+  end
+
+  # Retrieve the attributes for this file, relative to a base directory.
+  # Note that Puppet::FileSystem.stat(path) raises Errno::ENOENT
+  # if the file is absent and this method does not catch that exception.
+  def collect(source_permissions = nil)
+    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 = Puppet::FileSystem.readlink(real_path)
+      @checksum = ("{#{@checksum_type}}") + send("#{@checksum_type}_file", real_path).to_s rescue nil
+    when "fifo", "socket"
+      @checksum_type = "none"
+      @checksum = ("{#{@checksum_type}}") + send("#{@checksum_type}_file", real_path).to_s
+    else
+      raise ArgumentError, _("Cannot manage files of type %{file_type}") % { file_type: stat.ftype }
+    end
+  end
+
+  def initialize(path,data={})
+    @owner       = data.delete('owner')
+    @group       = data.delete('group')
+    @mode        = data.delete('mode')
+    checksum = data.delete('checksum')
+    if checksum
+      @checksum_type = checksum['type']
+      @checksum      = checksum['value']
+    end
+    @checksum_type ||= Puppet[:digest_algorithm]
+    @ftype       = data.delete('type')
+    @destination = data.delete('destination')
+    @source      = data.delete('source')
+    @content_uri = data.delete('content_uri')
+
+    links = data.fetch('links', nil) || data.fetch(:links, nil)
+    relative_path = data.fetch('relative_path', nil) || data.fetch(:relative_path, nil)
+    source = @source || data.fetch(:source, nil)
+    super(path, links: links, relative_path: relative_path, source: source)
+  end
+
+  def to_data_hash
+    super.update(
+      {
+        'owner'        => owner,
+        'group'        => group,
+        'mode'         => mode,
+        'checksum'     => {
+          'type'   => checksum_type,
+          'value'  => checksum
+        },
+        'type'         => ftype,
+        'destination'  => destination,
+      }.merge(content_uri ? {'content_uri' => content_uri} : {})
+       .merge(source ? {'source' => source} : {})
+    )
+  end
+
+  def self.from_data_hash(data)
+    new(data.delete('path'), data)
+  end
+
+end

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

@@ -0,0 +1,122 @@
+require_relative '../../../puppet/file_serving/mount'
+
+class Puppet::FileServing::Mount::File < Puppet::FileServing::Mount
+  def self.localmap
+    @localmap ||= {
+      "h" => Puppet.runtime[:facter].value("hostname"),
+      "H" => [
+               Puppet.runtime[:facter].value("hostname"),
+               Puppet.runtime[:facter].value("domain")
+             ].join("."),
+      "d" => Puppet.runtime[: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 !(Puppet::FileSystem.exist?(file) or Puppet::FileSystem.symlink?(file))
+      Puppet.info(_("File does not exist or is not accessible: %{file}") % { file: 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") % { path: path } unless FileTest.directory?(path)
+      raise ArgumentError, _("%{path} is not readable") % { path: path } unless FileTest.readable?(path)
+      @expandable = false
+    end
+    @path = path
+  end
+
+  def search(path, request)
+    path = complete_path(path, request.node)
+    return nil unless path
+    [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") % { path: 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
+    self.class.localmap
+  end
+end

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

@@ -0,0 +1,35 @@
+require_relative '../../../puppet/file_serving/mount'
+
+# Find files in the modules' locales directories.
+# This is a very strange mount because it merges
+# many directories into one.
+class Puppet::FileServing::Mount::Locales < Puppet::FileServing::Mount
+  # Return an instance of the appropriate class.
+  def find(relative_path, request)
+    mod = request.environment.modules.find { |m|  m.locale(relative_path) }
+    return nil unless mod
+
+    path = mod.locale(relative_path)
+
+    path
+  end
+
+  def search(relative_path, request)
+    # We currently only support one kind of search on locales - return
+    # them all.
+    paths = request.environment.modules.find_all { |mod| mod.locales? }.collect { |mod| mod.locale_directory }
+    if paths.empty?
+      # If the modulepath is valid then we still need to return a valid root
+      # directory for the search, but make sure nothing inside it is
+      # returned.
+      request.options[:recurse] = false
+      request.environment.modulepath.empty? ? [Puppet[:codedir]] : request.environment.modulepath
+    else
+      paths
+    end
+  end
+
+  def valid?
+    true
+  end
+end

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

@@ -0,0 +1,26 @@
+require_relative '../../../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)
+    mod = request.environment.module(module_name)
+    return nil unless mod
+
+    mod.file(relative_path)
+  end
+
+  def search(path, request)
+    result = find(path, request)
+    if result
+      [result]
+    end
+  end
+
+  def valid?
+    true
+  end
+end

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

@@ -0,0 +1,35 @@
+require_relative '../../../puppet/file_serving/mount'
+
+# Find files in the modules' pluginfacts directories.
+# This is a very strange mount because it merges
+# many directories into one.
+class Puppet::FileServing::Mount::PluginFacts < Puppet::FileServing::Mount
+  # Return an instance of the appropriate class.
+  def find(relative_path, request)
+    mod = request.environment.modules.find { |m|  m.pluginfact(relative_path) }
+    return nil unless mod
+
+    path = mod.pluginfact(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.pluginfacts? }.collect { |mod| mod.plugin_fact_directory }
+    if paths.empty?
+      # If the modulepath is valid then we still need to return a valid root
+      # directory for the search, but make sure nothing inside it is
+      # returned.
+      request.options[:recurse] = false
+      request.environment.modulepath.empty? ? [Puppet[:codedir]] : request.environment.modulepath
+    else
+      paths
+    end
+  end
+
+  def valid?
+    true
+  end
+end

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

@@ -0,0 +1,35 @@
+require_relative '../../../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)
+    mod = request.environment.modules.find { |m|  m.plugin(relative_path) }
+    return nil unless mod
+
+    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 }
+    if paths.empty?
+      # If the modulepath is valid then we still need to return a valid root
+      # directory for the search, but make sure nothing inside it is
+      # returned.
+      request.options[:recurse] = false
+      request.environment.modulepath.empty? ? [Puppet[:codedir]] : request.environment.modulepath
+    else
+      paths
+    end
+  end
+
+  def valid?
+    true
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'puppet/file_serving/mount'
+
+class Puppet::FileServing::Mount::Scripts < 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)
+    mod = request.environment.module(module_name)
+    return nil unless mod
+
+    mod.script(relative_path)
+  end
+
+  def search(path, request)
+    result = find(path, request)
+    if result
+      [result]
+    end
+  end
+
+  def valid?
+    true
+  end
+end

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

@@ -0,0 +1,23 @@
+require_relative '../../../puppet/file_serving/mount'
+
+class Puppet::FileServing::Mount::Tasks < Puppet::FileServing::Mount
+  def find(path, request)
+    raise _("No task specified") if path.to_s.empty?
+    module_name, task_path = path.split("/", 2)
+    mod = request.environment.module(module_name)
+    return nil unless mod
+
+    mod.task_file(task_path)
+  end
+
+  def search(path, request)
+    result = find(path, request)
+    if result
+      [result]
+    end
+  end
+
+  def valid?
+    true
+  end
+end

data/lib/puppet/file_serving/mount.rb

@@ -0,0 +1,38 @@
+require_relative '../../puppet/util/logging'
+require_relative '../../puppet/file_serving'
+require_relative '../../puppet/file_serving/metadata'
+require_relative '../../puppet/file_serving/content'
+
+# Broker access to the filesystem, converting local URIs into metadata
+# or content objects.
+class Puppet::FileServing::Mount
+  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}'") % { name: 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

data/lib/puppet/file_serving/terminus_helper.rb

@@ -0,0 +1,31 @@
+require_relative '../../puppet/file_serving'
+require_relative '../../puppet/file_serving/fileset'
+
+# Define some common methods for FileServing termini.
+
+module Puppet::FileServing::TerminusHelper
+  # Create model instance for a file in a file server.
+  def path2instance(request, path, options = {})
+    result = model.new(path, :relative_path => options[:relative_path])
+    result.links = request.options[:links] if request.options[:links]
+
+    result.checksum_type = request.options[:checksum_type] if request.options[:checksum_type]
+    result.source_permissions = request.options[:source_permissions] if request.options[:source_permissions]
+
+    result.collect
+
+    result
+  end
+
+  # Create model instances for all files in a fileset.
+  def path2instances(request, *paths)
+    filesets = paths.collect do |path|
+      # Filesets support indirector requests as an options collection
+      Puppet::FileServing::Fileset.new(path, request)
+    end
+
+    Puppet::FileServing::Fileset.merge(*filesets).collect do |file, base_path|
+      path2instance(request, base_path, :relative_path => file)
+    end
+  end
+end

data/lib/puppet/file_serving/terminus_selector.rb

@@ -0,0 +1,31 @@
+require_relative '../../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::TerminusSelector
+  def select(request)
+    # We rely on the request's parsing of the URI.
+
+    case request.protocol
+    when "file"
+      :file
+    when "puppet"
+      if request.server
+        :rest
+      else
+        Puppet[:default_file_terminus]
+      end
+    when "http","https"
+      :http
+    when nil
+      if Puppet::Util.absolute_path?(request.key)
+        :file
+      else
+        :file_server
+      end
+    else
+      raise ArgumentError, _("URI protocol '%{protocol}' is not currently supported for file serving") % { protocol: request.protocol }
+    end
+  end
+end

data/lib/puppet/file_serving.rb

@@ -0,0 +1,3 @@
+# Just a stub class.
+class Puppet::FileServing # :nodoc:
+end