puppet 3.4.3 → 3.5.0.rc1

data/lib/puppet/file_system/file.rb

@@ -1,271 +0,0 @@
-# An abstraction over the ruby file system operations for a single file.
-#
-# For the time being this is being kept private so that we can evolve it for a
-# while.
-#
-# @api private
-class Puppet::FileSystem::File
-  attr_reader :path
-
-  IMPL = if RUBY_VERSION =~ /^1\.8/
-           require 'puppet/file_system/file18'
-           Puppet::FileSystem::File18
-         elsif Puppet::Util::Platform.windows?
-           require 'puppet/file_system/file19windows'
-           Puppet::FileSystem::File19Windows
-         else
-           require 'puppet/file_system/file19'
-           Puppet::FileSystem::File19
-         end
-
-  @remembered = {}
-
-  def self.new(path)
-    if @remembered.include?(path.to_s)
-      @remembered[path.to_s]
-    else
-      file = IMPL.allocate
-      file.send(:initialize, path)
-      file
-    end
-  end
-
-  # Run a block of code with a file accessible in the filesystem.
-  # @note This API should only be used for testing
-  #
-  # @param file [Object] an object that conforms to the Puppet::FileSystem::File interface
-  # @api private
-  def self.overlay(file, &block)
-    remember(file)
-    yield
-  ensure
-    forget(file)
-  end
-
-  # Create a binding between a filename and a particular instance of a file object.
-  # @note This API should only be used for testing
-  #
-  # @param file [Object] an object that conforms to the Puppet::FileSystem::File interface
-  # @api private
-  def self.remember(file)
-    @remembered[file.path.to_s] = file
-  end
-
-  # Forget a remembered file
-  # @note This API should only be used for testing
-  #
-  # @param file [Object] an object that conforms to the Puppet::FileSystem::File interface
-  # @api private
-  def self.forget(file)
-    @remembered.delete(file.path.to_s)
-  end
-
-  def initialize(path)
-    if path.is_a?(Pathname)
-      @path = path
-    else
-      @path = Pathname.new(path)
-    end
-  end
-
-  def open(mode, options, &block)
-    ::File.open(@path, options, mode, &block)
-  end
-
-  # @return [Puppet::FileSystem::File] The directory of this file
-  # @api public
-  def dir
-    Puppet::FileSystem::File.new(@path.dirname)
-  end
-
-  # @return [String] the name of the file
-  # @api public
-  def basename
-    @path.basename.to_s
-  end
-
-  # @return [Num] The size of this file
-  # @api public
-  def size
-    @path.size
-  end
-
-  # Allows exclusive updates to a file to be made by excluding concurrent
-  # access using flock. This means that if the file is on a filesystem that
-  # does not support flock, this method will provide no protection.
-  #
-  # While polling to aquire the lock the process will wait ever increasing
-  # amounts of time in order to prevent multiple processes from wasting
-  # resources.
-  #
-  # @param mode [Integer] The mode to apply to the file if it is created
-  # @param options [Integer] Extra file operation mode information to use
-  # (defaults to read-only mode)
-  # @param timeout [Integer] Number of seconds to wait for the lock (defaults to 300)
-  # @yield The file handle, in read-write mode
-  # @return [Void]
-  # @raise [Timeout::Error] If the timeout is exceeded while waiting to aquire the lock
-  # @api public
-  def exclusive_open(mode, options = 'r', timeout = 300, &block)
-    wait = 0.001 + (Kernel.rand / 1000)
-    written = false
-    while !written
-      ::File.open(@path, options, mode) do |rf|
-        if rf.flock(::File::LOCK_EX|::File::LOCK_NB)
-          yield rf
-          written = true
-        else
-          sleep wait
-          timeout -= wait
-          wait *= 2
-          if timeout < 0
-            raise Timeout::Error, "Timeout waiting for exclusive lock on #{@path}"
-          end
-        end
-      end
-    end
-  end
-
-  def each_line(&block)
-    ::File.open(@path) do |f|
-      f.each_line do |line|
-        yield line
-      end
-    end
-  end
-
-  # @return [String] The contents of the file
-  def read
-    @path.read
-  end
-
-  # @return [String] The binary contents of the file
-  def binread
-    raise NotImplementedError
-  end
-
-  # Determine if a file exists by verifying that the file can be stat'd.
-  # Will follow symlinks and verify that the actual target path exists.
-  #
-  # @return [Boolean] true if the named file exists.
-  def self.exist?(path)
-    return IMPL.exist?(path) if IMPL.method(:exist?) != self.method(:exist?)
-    File.exist?(path)
-  end
-
-  # Determine if a file exists by verifying that the file can be stat'd.
-  # Will follow symlinks and verify that the actual target path exists.
-  #
-  # @return [Boolean] true if the path of this file is present
-  def exist?
-    self.class.exist?(@path)
-  end
-
-  # Determine if a file is executable.
-  #
-  # @todo Should this take into account extensions on the windows platform?
-  #
-  # @return [Boolean] true if this file can be executed
-  def executable?
-    ::File.executable?(@path)
-  end
-
-  # @return [Boolean] Whether the file is writable by the current
-  # process
-  def writable?
-    @path.writable?
-  end
-
-  # Touches the file. On most systems this updates the mtime of the file.
-  def touch
-    ::FileUtils.touch(@path)
-  end
-
-  # Create the entire path as directories
-  def mkpath
-    @path.mkpath
-  end
-
-  # Creates a symbolic link dest which points to the current file.
-  # If dest already exists:
-  #
-  # * and is a file, will raise Errno::EEXIST
-  # * and is a directory, will return 0 but perform no action
-  # * and is a symlink referencing a file, will raise Errno::EEXIST
-  # * and is a symlink referencing a directory, will return 0 but perform no action
-  #
-  # With the :force option set to true, when dest already exists:
-  #
-  # * and is a file, will replace the existing file with a symlink (DANGEROUS)
-  # * and is a directory, will return 0 but perform no action
-  # * and is a symlink referencing a file, will modify the existing symlink
-  # * and is a symlink referencing a directory, will return 0 but perform no action
-  #
-  # @param dest [String] The path to create the new symlink at
-  # @param [Hash] options the options to create the symlink with
-  # @option options [Boolean] :force overwrite dest
-  # @option options [Boolean] :noop do not perform the operation
-  # @option options [Boolean] :verbose verbose output
-  #
-  # @raise [Errno::EEXIST] dest already exists as a file and, :force is not set
-  #
-  # @return [Integer] 0
-  def symlink(dest, options = {})
-    FileUtils.symlink(@path, dest, options)
-  end
-
-  # @return [Boolean] true if the file is a symbolic link.
-  def symlink?
-    File.symlink?(@path)
-  end
-
-  # @return [String] the name of the file referenced by the given link.
-  def readlink
-    File.readlink(@path)
-  end
-
-  # Deletes the named files, returning the number of names passed as arguments.
-  # See also Dir::rmdir.
-  #
-  # @raise an exception on any error.
-  #
-  # @return [Integer] the number of names passed as arguments
-  def self.unlink(*file_names)
-    return IMPL.unlink(*file_names) if IMPL.method(:unlink) != self.method(:unlink)
-    File.unlink(*file_names)
-  end
-
-  # Deletes the file.
-  # See also Dir::rmdir.
-  #
-  # @raise an exception on any error.
-  #
-  # @return [Integer] the number of names passed as arguments, in this case 1
-  def unlink
-    self.class.unlink(@path)
-  end
-
-  # @return [File::Stat] object for the named file.
-  def stat
-    File.stat(@path)
-  end
-
-  # @return [File::Stat] Same as stat, but does not follow the last symbolic
-  # link. Instead, reports on the link itself.
-  def lstat
-    File.lstat(@path)
-  end
-
-  # Compare the contents of this file against the contents of a stream.
-  # @param stream [IO] The stream to compare the contents against
-  # @return [Boolean] Whether the contents were the same
-  def compare_stream(stream)
-    open(0, 'rb') do |this|
-      FileUtils.compare_stream(this, stream)
-    end
-  end
-
-  def to_s
-    @path.to_s
-  end
-end

data/lib/puppet/network/http/rack/httphandler.rb

@@ -1,13 +0,0 @@
-require 'openssl'
-require 'puppet/ssl/certificate'
-
-class Puppet::Network::HTTP::RackHttpHandler
-
-  # do something useful with request (a Rack::Request) and use
-  # response to fill your Rack::Response
-  def process(request, response)
-    raise NotImplementedError, "Your RackHttpHandler subclass is supposed to override service(request)"
-  end
-
-end
-

data/lib/puppet/pops/binder/hiera2.rb

@@ -1,10 +0,0 @@
-# The Hiera2 Module contains the classes needed to configure a bindings producer
-# to read module specific data. The configuration is expected to be found in
-# a hiera.yaml file in the root of each module
-module Puppet::Pops::Binder::Hiera2
-  require 'puppet/pops/binder/hiera2/config_checker'
-  require 'puppet/pops/binder/hiera2/config'
-  require 'puppet/pops/binder/hiera2/diagnostic_producer'
-  require 'puppet/pops/binder/hiera2/bindings_provider'
-  require 'puppet/pops/binder/hiera2/issues'
-end

data/lib/puppet/pops/binder/hiera2/bindings_provider.rb

@@ -1,148 +0,0 @@
-module Puppet::Pops::Binder::Hiera2
-  Model = Puppet::Pops::Model
-
-  # A BindingsProvider instance is used for creating a bindings model from a module directory
-  # @api public
-  #
-  class BindingsProvider
-    # The resulting name of loaded bindings (given when initializing)
-    attr_reader :name
-
-    # Creates a new BindingsProvider by reading the hiera_conf.yaml configuration file. Problems
-    # with the configuration are reported propagated to the acceptor
-    #
-    # @param name [String] the name to assign to the result (and in error messages if there is no result)
-    # @param hiera_config_dir [String] Path to the directory containing a hiera_config
-    # @param acceptor [Puppet::Pops::Validation::Acceptor] Acceptor that will receive diagnostics
-    def initialize(name, hiera_config_dir, acceptor)
-      @name = name
-      @parser = Puppet::Pops::Parser::EvaluatingParser.new()
-      @diagnostics = DiagnosticProducer.new(acceptor)
-      @type_calculator = Puppet::Pops::Types::TypeCalculator.new()
-      @config = Config.new(hiera_config_dir, @diagnostics)
-    end
-
-    # Loads a bindings model using the hierarchy and backends configured for this instance.
-    #
-    # @param scope [Puppet::Parser::Scope] The hash used when expanding
-    # @return [Puppet::Pops::Binder::Bindings::ContributedBindings] A bindings model with effective categories
-    def load_bindings(scope)
-      backends = BackendHelper.new(scope)
-      factory = Puppet::Pops::Binder::BindingsFactory
-      result = factory.named_bindings(name)
-
-      hierarchy = {}
-      precedence = []
-
-      @config.hierarchy.each do |key, value, path|
-        source_file = File.join(@config.module_dir, 'hiera.yaml')
-        category_value = @parser.evaluate_string(scope, @parser.quote(value), source_file)
-
-        hierarchy[key] = {
-          :bindings    => result.when_in_category(key, category_value),
-          :path        => @parser.evaluate_string(scope, @parser.quote(path)),
-          :unique_keys =>Set.new()}
-
-        precedence << [key, category_value]
-      end
-
-      @config.backends.each do |backend_key|
-        backend = backends[backend_key]
-
-        hierarchy.each_pair do |hier_key, hier_val|
-          bindings = hier_val[:bindings]
-          unique_keys = hier_val[:unique_keys]
-
-          hiera_data_file_path = hier_val[:path]
-          backend.read_data(@config.module_dir, hiera_data_file_path).each_pair do |key, value|
-            if unique_keys.add?(key)
-              b = bindings.bind().name(key)
-              # Transform value into a Model::Expression
-              expr = build_expr(value, hiera_data_file_path)
-              if is_constant?(expr)
-                # The value is constant so toss the expression
-                b.type(@type_calculator.infer(value)).to(value)
-              else
-                # Use an evaluating producer for the binding
-                b.to(expr)
-              end
-            end
-          end
-        end
-      end
-
-      factory.contributed_bindings(name, result.model, factory.categories(precedence))
-    end
-
-    private
-
-    # @return true unless the expression is a Model::ConcatenatedString or
-    # somehow contains one
-    def is_constant?(expr)
-      if expr.is_a?(Model::ConcatenatedString)
-        false
-      else
-        !expr.eAllContents.any? { |v| v.is_a?(Model::ConcatenatedString) }
-      end
-    end
-
-    # Transform the value into a Model::Expression. Strings are parsed using
-    # the Pops::Parser::Parser to produce either Model::LiteralString or Model::ConcatenatedString
-    #
-    # @param value [Object] May be an String, Number, TrueClass, FalseClass, or NilClass nested to any depth using Hash or Array.
-    # @param hiera_data_file_path [String] The source_file used when reporting errors
-    # @return [Model::Expression] The expression that corresponds to the value
-    def build_expr(value, hiera_data_file_path)
-      case value
-      when Symbol
-        value.to_s
-      when String
-        @parser.parse_string(@parser.quote(value)).current
-      when Hash
-        value.inject(Model::LiteralHash.new)  do |h,(k,v)|
-          e = Model::KeyedEntry.new
-          e.key = build_expr(k, hiera_data_file_path)
-          e.value = build_expr(v, hiera_data_file_path)
-          h.addEntries(e)
-          h
-        end
-      when Enumerable
-        value.inject(Model::LiteralList.new) {|a,v| a.addValues(build_expr(v, hiera_data_file_path)); a }
-      when Numeric
-        expr = Model::LiteralNumber.new
-        expr.value = value;
-        expr
-      when TrueClass, FalseClass
-        expr = Model::LiteralBoolean.new
-        expr.value = value;
-        expr
-      when NilClass
-        Model::Nop.new
-      else
-        @diagnostics.accept(Issues::UNABLE_TO_PARSE_INSTANCE, value.class.name)
-        nil
-      end
-    end
-  end
-
-  # @api private
-  class BackendHelper
-    T = Puppet::Pops::Types::TypeFactory
-    HASH_OF_BACKENDS = T.hash_of(T.type_of('Puppetx::Puppet::Hiera2Backend'))
-    def initialize(scope)
-      @scope = scope
-      @cache = nil
-    end
-
-    def [] (backend_key)
-      load_backends unless @cache
-      @cache[backend_key]
-    end
-
-    def load_backends
-      @cache = @scope.compiler.boot_injector.lookup(@scope, HASH_OF_BACKENDS, Puppetx::HIERA2_BACKENDS) || {}
-    end
-  end
-
-end
-

data/lib/puppet/pops/binder/hiera2/config.rb

@@ -1,69 +0,0 @@
-module Puppet::Pops::Binder::Hiera2
-
-  # Class holding the Hiera2 Configuration
-  # The configuration is obtained from the file 'hiera.yaml'
-  # that must reside in the root directory of the module
-  # @api public
-  #
-  class Puppet::Pops::Binder::Hiera2::Config
-    DEFAULT_HIERARCHY = [ ['osfamily', '${osfamily}', 'data/osfamily/${osfamily}'], ['common', 'true', 'data/common']]
-    DEFAULT_BACKENDS = ['yaml', 'json']
-
-    if defined?(::Psych::SyntaxError)
-      YamlLoadExceptions = [::StandardError, ::ArgumentError, ::Psych::SyntaxError]
-    else
-      YamlLoadExceptions = [::StandardError, ::ArgumentError]
-    end
-
-    # Returns a list of configured backends.
-    #
-    # @return [Array<String>] backend names
-    attr_reader :backends
-
-    # Root directory of the module holding the configuration
-    #
-    # @return [String] An absolute path
-    attr_reader :module_dir
-
-    # The bindings hierarchy is an array of categorizations where the
-    # array for each category has exactly three elements - the categorization name,
-    # category value, and the path that is later used by the backend to read
-    # the bindings for that category
-    #
-    # @return [Array<Array(String, String, String)>]
-    # @api public
-    attr_reader :hierarchy
-
-    # Creates a new Config. The configuration is loaded from the file 'hiera.yaml' which
-    # is expected to be found in the given module_dir.
-    #
-    # @param module_dir [String] The module directory
-    # @param diagnostics [DiagnosticProducer] collector of diagnostics
-    # @api public
-    #
-    def initialize(module_dir, diagnostics)
-      @module_dir = module_dir
-      config_file = File.join(module_dir, 'hiera.yaml')
-      validator = ConfigChecker.new(diagnostics)
-      begin
-        data = YAML.load_file(config_file)
-        validator.validate(data, config_file)
-        unless diagnostics.errors?
-          # if these are missing the result is nil, and they get default values later
-          @hierarchy = data['hierarchy']
-          @backends = data['backends']
-        end
-      rescue Errno::ENOENT
-        diagnostics.accept(Issues::CONFIG_FILE_NOT_FOUND, config_file)
-      rescue Errno::ENOTDIR
-        diagnostics.accept(Issues::CONFIG_FILE_NOT_FOUND, config_file)
-      rescue ::SyntaxError => e
-        diagnostics.accept(Issues::CONFIG_FILE_SYNTAX_ERROR, e)
-      rescue *YamlLoadExceptions => e
-        diagnostics.accept(Issues::CONFIG_FILE_SYNTAX_ERROR, e)
-      end
-      @hierarchy ||= DEFAULT_HIERARCHY
-      @backends ||= DEFAULT_BACKENDS
-    end
-  end
-end