bolt 0.0.1 → 0.5.0

data/vendored/puppet/lib/puppet/loaders.rb

@@ -0,0 +1,26 @@
+module Puppet
+  module Pops
+    require 'puppet/pops/loaders'
+
+    module Loader
+      require 'puppet/pops/loader/typed_name'
+      require 'puppet/pops/loader/loader'
+      require 'puppet/pops/loader/base_loader'
+      require 'puppet/pops/loader/gem_support'
+      require 'puppet/pops/loader/module_loaders'
+      require 'puppet/pops/loader/dependency_loader'
+      require 'puppet/pops/loader/null_loader'
+      require 'puppet/pops/loader/static_loader'
+      require 'puppet/pops/loader/runtime3_type_loader'
+      require 'puppet/pops/loader/ruby_function_instantiator'
+      require 'puppet/pops/loader/puppet_function_instantiator'
+      require 'puppet/pops/loader/type_definition_instantiator'
+      require 'puppet/pops/loader/puppet_resource_type_impl_instantiator'
+      require 'puppet/pops/loader/loader_paths'
+      require 'puppet/pops/loader/simple_environment_loader'
+      require 'puppet/pops/loader/predefined_loader'
+      require 'puppet/pops/loader/puppet_plan_instantiator'
+    end
+  end
+
+end

data/vendored/puppet/lib/puppet/metatype/manager.rb

@@ -0,0 +1,195 @@
+require 'puppet'
+require 'puppet/util/classgen'
+require 'puppet/node/environment'
+
+# This module defines methods dealing with Type management.
+# This module gets included into the Puppet::Type class, it's just split out here for clarity.
+# @api public
+#
+module Puppet::MetaType
+module Manager
+  include Puppet::Util::ClassGen
+
+  # An implementation specific method that removes all type instances during testing.
+  # @note Only use this method for testing purposes.
+  # @api private
+  #
+  def allclear
+    @types.each { |name, type|
+      type.clear
+    }
+  end
+
+  # Clears any types that were used but absent when types were last loaded.
+  # @note Used after each catalog compile when always_retry_plugins is false
+  # @api private
+  #
+  def clear_misses
+    unless @types.nil?
+      @types.delete_if {|_, v| v.nil? }
+    end
+  end
+
+  # Iterates over all already loaded Type subclasses.
+  # @yield [t] a block receiving each type
+  # @yieldparam t [Puppet::Type] each defined type
+  # @yieldreturn [Object] the last returned object is also returned from this method
+  # @return [Object] the last returned value from the block.
+  def eachtype
+    @types.each do |name, type|
+      # Only consider types that have names
+      #if ! type.parameters.empty? or ! type.validproperties.empty?
+        yield type
+      #end
+    end
+  end
+
+  # Loads all types.
+  # @note Should only be used for purposes such as generating documentation as this is potentially a very
+  #  expensive operation.
+  # @return [void]
+  #
+  def loadall
+    typeloader.loadall
+  end
+
+  # Defines a new type or redefines an existing type with the given name.
+  # A convenience method on the form `new<name>` where name is the name of the type is also created.
+  # (If this generated method happens to clash with an existing method, a warning is issued and the original
+  # method is kept).
+  #
+  # @param name [String] the name of the type to create or redefine.
+  # @param options [Hash] options passed on to {Puppet::Util::ClassGen#genclass} as the option `:attributes`.
+  # @option options [Puppet::Type]
+  #   Puppet::Type. This option is not passed on as an attribute to genclass.
+  # @yield [ ] a block evaluated in the context of the created class, thus allowing further detailing of
+  #   that class.
+  # @return [Class<inherits Puppet::Type>] the created subclass
+  # @see Puppet::Util::ClassGen.genclass
+  #
+  # @dsl type
+  # @api public
+  def newtype(name, options = {}, &block)
+    # Handle backward compatibility
+    unless options.is_a?(Hash)
+      Puppet.warning "Puppet::Type.newtype(#{name}) now expects a hash as the second argument, not #{options.inspect}"
+    end
+
+    # First make sure we don't have a method sitting around
+    name = name.intern
+    newmethod = "new#{name}"
+
+    # Used for method manipulation.
+    selfobj = singleton_class
+
+    @types ||= {}
+
+    if @types.include?(name)
+      if self.respond_to?(newmethod)
+        # Remove the old newmethod
+        selfobj.send(:remove_method,newmethod)
+      end
+    end
+
+    options = symbolize_options(options)
+
+    # Then create the class.
+
+    klass = genclass(
+      name,
+      :parent => Puppet::Type,
+      :overwrite => true,
+      :hash => @types,
+      :attributes => options,
+      &block
+    )
+
+    # Now define a "new<type>" method for convenience.
+    if self.respond_to? newmethod
+      # Refuse to overwrite existing methods like 'newparam' or 'newtype'.
+      Puppet.warning "'new#{name.to_s}' method already exists; skipping"
+    else
+      selfobj.send(:define_method, newmethod) do |*args|
+        klass.new(*args)
+      end
+    end
+
+    # If they've got all the necessary methods defined and they haven't
+    # already added the property, then do so now.
+    klass.ensurable if klass.ensurable? and ! klass.validproperty?(:ensure)
+
+    # Now set up autoload any providers that might exist for this type.
+
+    klass.providerloader = Puppet::Util::Autoload.new(klass, "puppet/provider/#{klass.name.to_s}")
+
+    # We have to load everything so that we can figure out the default provider.
+    klass.providerloader.loadall Puppet.lookup(:current_environment)
+    klass.providify unless klass.providers.empty?
+
+    loc = block_given? ? block.source_location : nil
+    uri = loc.nil? ? nil : URI("#{Puppet::Util.path_to_uri(loc[0])}?line=#{loc[1]}")
+    Puppet::Pops::Loaders.register_runtime3_type(name, uri)
+
+    klass
+  end
+
+  # Removes an existing type.
+  # @note Only use this for testing.
+  # @api private
+  def rmtype(name)
+    # Then create the class.
+
+    rmclass(name, :hash => @types)
+
+    singleton_class.send(:remove_method, "new#{name}") if respond_to?("new#{name}")
+  end
+
+  # Returns a Type instance by name.
+  # This will load the type if not already defined.
+  # @param [String, Symbol] name of the wanted Type
+  # @return [Puppet::Type, nil] the type or nil if the type was not defined and could not be loaded
+  #
+  def type(name)
+    # Avoid loading if name obviously is not a type name
+    if name.to_s.include?(':')
+      return nil
+    end
+
+    @types ||= {}
+
+    # We are overwhelmingly symbols here, which usually match, so it is worth
+    # having this special-case to return quickly.  Like, 25K symbols vs. 300
+    # strings in this method. --daniel 2012-07-17
+    return @types[name] if @types.include? name
+
+    # Try mangling the name, if it is a string.
+    if name.is_a? String
+      name = name.downcase.intern
+      return @types[name] if @types.include? name
+    end
+    # Try loading the type.
+    if typeloader.load(name, Puppet.lookup(:current_environment))
+      Puppet.warning "Loaded puppet/type/#{name} but no class was created" unless @types.include? name
+    elsif !Puppet[:always_retry_plugins]
+      # PUP-5482 - Only look for a type once if plugin retry is disabled
+      @types[name] = nil
+    end
+
+    # ...and I guess that is that, eh.
+    return @types[name]
+  end
+
+  # Creates a loader for Puppet types.
+  # Defaults to an instance of {Puppet::Util::Autoload} if no other auto loader has been set.
+  # @return [Puppet::Util::Autoload] the loader to use.
+  # @api private
+def typeloader
+  unless defined?(@typeloader)
+    @typeloader = Puppet::Util::Autoload.new(self, "puppet/type")
+  end
+
+  @typeloader
+end
+end
+end
+

data/vendored/puppet/lib/puppet/module.rb

@@ -0,0 +1,473 @@
+require 'puppet/util/logging'
+require 'puppet/module/task'
+require 'json'
+require 'semantic_puppet/gem_version'
+
+# Support for modules
+class Puppet::Module
+  class Error < Puppet::Error; end
+  class MissingModule < Error; end
+  class IncompatibleModule < Error; end
+  class UnsupportedPlatform < Error; end
+  class IncompatiblePlatform < Error; end
+  class MissingMetadata < Error; end
+  class FaultyMetadata < Error; end
+  class InvalidName < Error; end
+  class InvalidFilePattern < Error; end
+
+  include Puppet::Util::Logging
+
+  FILETYPES = {
+    "manifests" => "manifests",
+    "files" => "files",
+    "templates" => "templates",
+    "plugins" => "lib",
+    "pluginfacts" => "facts.d",
+  }
+
+  # Find and return the +module+ that +path+ belongs to. If +path+ is
+  # absolute, or if there is no module whose name is the first component
+  # of +path+, return +nil+
+  def self.find(modname, environment = nil)
+    return nil unless modname
+    # Unless a specific environment is given, use the current environment
+    env = environment ? Puppet.lookup(:environments).get!(environment) : Puppet.lookup(:current_environment)
+    env.module(modname)
+  end
+
+  def self.is_module_directory?(name, path)
+    # it must be a directory
+    fullpath = File.join(path, name)
+    return false unless Puppet::FileSystem.directory?(fullpath)
+    return is_module_directory_name?(name)
+  end
+
+  def self.is_module_directory_name?(name)
+    # it must match an installed module name according to forge validator
+    return true if name =~ /^[a-z][a-z0-9_]*$/
+    return false
+  end
+
+  def self.is_module_namespaced_name?(name)
+    # it must match the full module name according to forge validator
+    return true if name =~ /^[a-zA-Z0-9]+[-][a-z][a-z0-9_]*$/
+    return false
+  end
+
+  # @api private
+  def self.parse_range(range, strict)
+    @parse_range_method ||= SemanticPuppet::VersionRange.method(:parse)
+    if @parse_range_method.arity == 1
+      @semver_gem_version ||= SemanticPuppet::Version.parse(SemanticPuppet::VERSION)
+
+      # Give user a heads-up if the desired strict setting cannot be honored
+      if strict
+        if @semver_gem_version.major < 1
+          Puppet.warn_once('strict_version_ranges', 'version_range_cannot_be_strict',
+            _('VersionRanges will never be strict when using non-vendored SemanticPuppet gem, version %{version}') % { version: @semver_gem_version},
+            :default, :default, :notice)
+        end
+      else
+        if @semver_gem_version.major >= 1
+          Puppet.warn_once('strict_version_ranges', 'version_range_always_strict',
+            _('VersionRanges will always be strict when using non-vendored SemanticPuppet gem, version %{version}') % { version: @semver_gem_version},
+            :default, :default, :notice)
+        end
+      end
+      @parse_range_method.call(range)
+    else
+      @parse_range_method.call(range, strict)
+    end
+  end
+
+  attr_reader :name, :environment, :path, :metadata, :tasks
+  attr_writer :environment
+
+  attr_accessor :dependencies, :forge_name
+  attr_accessor :source, :author, :version, :license, :summary, :description, :project_page
+
+  def initialize(name, path, environment, strict_semver = true)
+    @name = name
+    @path = path
+    @strict_semver = strict_semver
+    @environment = environment
+
+    assert_validity
+    load_metadata
+
+    @absolute_path_to_manifests = Puppet::FileSystem::PathPattern.absolute(manifests)
+
+    # i18n initialization for modules
+    initialize_i18n
+  end
+
+  # @deprecated The puppetversion module metadata field is no longer used.
+  def puppetversion
+    nil
+  end
+
+  # @deprecated The puppetversion module metadata field is no longer used.
+  def puppetversion=(something)
+  end
+
+  # @deprecated The puppetversion module metadata field is no longer used.
+  def validate_puppet_version
+    return
+  end
+
+  def has_metadata?
+    begin
+      load_metadata
+      @metadata.is_a?(Hash) && !@metadata.empty?
+    rescue Puppet::Module::MissingMetadata
+      false
+    end
+  end
+
+  FILETYPES.each do |type, location|
+    # A boolean method to let external callers determine if
+    # we have files of a given type.
+    define_method(type + '?') do
+      type_subpath = subpath(location)
+      unless Puppet::FileSystem.exist?(type_subpath)
+        Puppet.debug("No #{type} found in subpath '#{type_subpath}' " +
+                         "(file / directory does not exist)")
+        return false
+      end
+
+      return true
+    end
+
+    # A method for returning a given file of a given type.
+    # e.g., file = mod.manifest("my/manifest.pp")
+    #
+    # If the file name is nil, then the base directory for the
+    # file type is passed; this is used for fileserving.
+    define_method(type.sub(/s$/, '')) do |file|
+      # If 'file' is nil then they're asking for the base path.
+      # This is used for things like fileserving.
+      if file
+        full_path = File.join(subpath(location), file)
+      else
+        full_path = subpath(location)
+      end
+
+      return nil unless Puppet::FileSystem.exist?(full_path)
+      return full_path
+    end
+
+    # Return the base directory for the given type
+    define_method(type) do
+      subpath(location)
+    end
+  end
+
+  def tasks_directory
+    subpath("tasks")
+  end
+
+  def tasks
+    return @tasks if instance_variable_defined?(:@tasks)
+
+    if Puppet::FileSystem.exist?(tasks_directory)
+      @tasks = Puppet::Module::Task.tasks_in_module(self)
+    else
+      @tasks = []
+    end
+  end
+
+  # This is a re-implementation of the Filetypes singular type method (e.g.
+  # `manifest('my/manifest.pp')`. We don't implement the full filetype "API" for
+  # tasks since tasks don't map 1:1 onto files.
+  def task_file(name)
+    # If 'file' is nil then they're asking for the base path.
+    # This is used for things like fileserving.
+    if name
+      full_path = File.join(tasks_directory, name)
+    else
+      full_path = tasks_directory
+    end
+
+    if Puppet::FileSystem.exist?(full_path)
+      return full_path
+    else
+      return nil
+    end
+  end
+
+  def license_file
+    return @license_file if defined?(@license_file)
+
+    return @license_file = nil unless path
+    @license_file = File.join(path, "License")
+  end
+
+  def read_metadata
+    md_file = metadata_file
+    md_file.nil? ? {} : JSON.parse(File.read(md_file, :encoding => 'utf-8'))
+  rescue Errno::ENOENT
+    {}
+  rescue JSON::JSONError => e
+    msg = "#{name} has an invalid and unparsable metadata.json file. The parse error: #{e.message}"
+    case Puppet[:strict]
+    when :off
+      Puppet.debug(msg)
+    when :warning
+      Puppet.warning(msg)
+    when :error
+      raise FaultyMetadata, msg
+    end
+    {}
+  end
+
+  def load_metadata
+    return if instance_variable_defined?(:@metadata)
+
+    @metadata = data = read_metadata
+    return if data.empty?
+
+    @forge_name = data['name'].gsub('-', '/') if data['name']
+
+    [:source, :author, :version, :license, :dependencies].each do |attr|
+      value = data[attr.to_s]
+      raise MissingMetadata, "No #{attr} module metadata provided for #{self.name}" if value.nil?
+
+      if attr == :dependencies
+        unless value.is_a?(Array)
+          raise MissingMetadata, "The value for the key dependencies in the file metadata.json of the module #{self.name} must be an array, not: '#{value}'"
+        end
+        value.each do |dep|
+          name = dep['name']
+          dep['name'] = name.tr('-', '/') unless name.nil?
+          dep['version_requirement'] ||= '>= 0.0.0'
+        end
+      end
+
+      send(attr.to_s + "=", value)
+    end
+  end
+
+  # Return the list of manifests matching the given glob pattern,
+  # defaulting to 'init.pp' for empty modules.
+  def match_manifests(rest)
+    if rest
+      wanted_manifests = wanted_manifests_from(rest)
+      searched_manifests = wanted_manifests.glob.reject { |f| FileTest.directory?(f) }
+    else
+      searched_manifests = []
+    end
+
+    # (#4220) Always ensure init.pp in case class is defined there.
+    init_manifest = manifest("init.pp")
+    if !init_manifest.nil? && !searched_manifests.include?(init_manifest)
+      searched_manifests.unshift(init_manifest)
+    end
+    searched_manifests
+  end
+
+  def all_manifests
+    return [] unless Puppet::FileSystem.exist?(manifests)
+
+    Dir.glob(File.join(manifests, '**', '*.pp'))
+  end
+
+  def metadata_file
+    return @metadata_file if defined?(@metadata_file)
+
+    return @metadata_file = nil unless path
+    @metadata_file = File.join(path, "metadata.json")
+  end
+
+  def hiera_conf_file
+    unless defined?(@hiera_conf_file)
+       @hiera_conf_file = path.nil? ? nil : File.join(path, Puppet::Pops::Lookup::HieraConfig::CONFIG_FILE_NAME)
+    end
+    @hiera_conf_file
+  end
+
+  def has_hiera_conf?
+    hiera_conf_file.nil? ? false : Puppet::FileSystem.exist?(hiera_conf_file)
+  end
+
+  def modulepath
+    File.dirname(path) if path
+  end
+
+  # Find all plugin directories.  This is used by the Plugins fileserving mount.
+  def plugin_directory
+    subpath("lib")
+  end
+
+  def plugin_fact_directory
+    subpath("facts.d")
+  end
+
+  def has_external_facts?
+    File.directory?(plugin_fact_directory)
+  end
+
+  def supports(name, version = nil)
+    @supports ||= []
+    @supports << [name, version]
+  end
+
+  def to_s
+    result = "Module #{name}"
+    result += "(#{path})" if path
+    result
+  end
+
+  def dependencies_as_modules
+    dependent_modules = []
+    dependencies and dependencies.each do |dep|
+      author, dep_name = dep["name"].split('/')
+      found_module = environment.module(dep_name)
+      dependent_modules << found_module if found_module
+    end
+
+    dependent_modules
+  end
+
+  def required_by
+    environment.module_requirements[self.forge_name] || {}
+  end
+
+  # Identify and mark unmet dependencies.  A dependency will be marked unmet
+  # for the following reasons:
+  #
+  #   * not installed and is thus considered missing
+  #   * installed and does not meet the version requirements for this module
+  #   * installed and doesn't use semantic versioning
+  #
+  # Returns a list of hashes representing the details of an unmet dependency.
+  #
+  # Example:
+  #
+  #   [
+  #     {
+  #       :reason => :missing,
+  #       :name   => 'puppetlabs-mysql',
+  #       :version_constraint => 'v0.0.1',
+  #       :mod_details => {
+  #         :installed_version => '0.0.1'
+  #       }
+  #       :parent => {
+  #         :name    => 'puppetlabs-bacula',
+  #         :version => 'v1.0.0'
+  #       }
+  #     }
+  #   ]
+  #
+  def unmet_dependencies
+    unmet_dependencies = []
+    return unmet_dependencies unless dependencies
+
+    dependencies.each do |dependency|
+      name = dependency['name']
+      version_string = dependency['version_requirement'] || '>= 0.0.0'
+
+      dep_mod = begin
+        environment.module_by_forge_name(name)
+      rescue
+        nil
+      end
+
+      error_details = {
+        :name => name,
+        :version_constraint => version_string.gsub(/^(?=\d)/, "v"),
+        :parent => {
+          :name => self.forge_name,
+          :version => self.version.gsub(/^(?=\d)/, "v")
+        },
+        :mod_details => {
+          :installed_version => dep_mod.nil? ? nil : dep_mod.version
+        }
+      }
+
+      unless dep_mod
+        error_details[:reason] = :missing
+        unmet_dependencies << error_details
+        next
+      end
+
+      if version_string
+        begin
+          required_version_semver_range = self.class.parse_range(version_string, @strict_semver)
+          actual_version_semver = SemanticPuppet::Version.parse(dep_mod.version)
+        rescue ArgumentError
+          error_details[:reason] = :non_semantic_version
+          unmet_dependencies << error_details
+          next
+        end
+
+        unless required_version_semver_range.include? actual_version_semver
+          error_details[:reason] = :version_mismatch
+          unmet_dependencies << error_details
+          next
+        end
+      end
+    end
+
+    unmet_dependencies
+  end
+
+  def ==(other)
+    self.name == other.name &&
+    self.version == other.version &&
+    self.path == other.path &&
+    self.environment == other.environment
+  end
+
+  def strict_semver?
+    @strict_semver
+  end
+
+  def initialize_i18n
+    module_name = @forge_name.gsub("/","-") if @forge_name
+    return if module_name.nil? || i18n_initialized?(module_name)
+
+    locales_path = File.absolute_path('locales', path)
+
+    begin
+      Puppet::GettextConfig.initialize(locales_path, :po)
+      Puppet.debug "#{module_name} initialized for i18n: #{GettextSetup.translation_repositories[module_name]}"
+    rescue
+      config_path = File.absolute_path('config.yaml', locales_path)
+      Puppet.debug "Could not find locales configuration file for #{module_name} at #{config_path}. Skipping i18n initialization."
+    end
+  end
+
+  private
+
+  def i18n_initialized?(module_name)
+    begin
+      GettextSetup.translation_repositories.has_key? module_name
+    rescue NameError
+      # GettextSetup not yet initialized
+      false
+    end
+  end
+
+  def wanted_manifests_from(pattern)
+    begin
+      extended = File.extname(pattern).empty? ? "#{pattern}.pp" : pattern
+      relative_pattern = Puppet::FileSystem::PathPattern.relative(extended)
+    rescue Puppet::FileSystem::PathPattern::InvalidPattern => error
+      raise Puppet::Module::InvalidFilePattern.new(
+        "The pattern \"#{pattern}\" to find manifests in the module \"#{name}\" " +
+        "is invalid and potentially unsafe.", error)
+    end
+
+    relative_pattern.prefix_with(@absolute_path_to_manifests)
+  end
+
+  def subpath(type)
+    File.join(path, type)
+  end
+
+  def assert_validity
+    if !Puppet::Module.is_module_directory_name?(@name) && !Puppet::Module.is_module_namespaced_name?(@name)
+      raise InvalidName, "Invalid module name #{@name}; module names must be alphanumeric (plus '-'), not '#{@name}'"
+    end
+  end
+end