puppet-retrospec 1.5.0 → 1.6.0

data/vendor/pup410/lib/puppet/module_tool/local_tarball.rb

@@ -0,0 +1,90 @@
+require 'pathname'
+require 'tmpdir'
+
+require 'puppet/forge'
+require 'puppet/module_tool'
+
+module Puppet::ModuleTool
+  class LocalTarball < SemanticPuppet::Dependency::Source
+    attr_accessor :release
+
+    def initialize(filename)
+      unpack(filename, tmpdir)
+      Puppet.debug "Unpacked local tarball to #{tmpdir}"
+
+      mod = Puppet::Module.new('tarball', tmpdir, nil)
+      @release = ModuleRelease.new(self, mod)
+    end
+
+    def fetch(name)
+      if @release.name == name
+        [ @release ]
+      else
+        [ ]
+      end
+    end
+
+    def prepare(release)
+      release.mod.path
+    end
+
+    def install(release, dir)
+      staging_dir = release.prepare
+
+      module_dir = dir + release.name[/-(.*)/, 1]
+      module_dir.rmtree if module_dir.exist?
+
+      # Make sure unpacked module has the same ownership as the folder we are moving it into.
+      Puppet::ModuleTool::Applications::Unpacker.harmonize_ownership(dir, staging_dir)
+
+      FileUtils.mv(staging_dir, module_dir)
+    end
+
+    class ModuleRelease < SemanticPuppet::Dependency::ModuleRelease
+      attr_reader :mod, :install_dir, :metadata
+
+      def initialize(source, mod)
+        @mod = mod
+        @metadata = mod.metadata
+        name = mod.forge_name.tr('/', '-')
+        version = SemanticPuppet::Version.parse(mod.version)
+        release = "#{name}@#{version}"
+
+        if mod.dependencies
+          dependencies = mod.dependencies.map do |dep|
+            Puppet::ModuleTool.parse_module_dependency(release, dep)[0..1]
+          end
+          dependencies = Hash[dependencies]
+        end
+
+        super(source, name, version, dependencies || {})
+      end
+
+      def install(dir)
+        @source.install(self, dir)
+        @install_dir = dir
+      end
+
+      def prepare
+        @source.prepare(self)
+      end
+    end
+
+    private
+
+    # Obtain a suitable temporary path for unpacking tarballs
+    #
+    # @return [String] path to temporary unpacking location
+    def tmpdir
+      @dir ||= Dir.mktmpdir('local-tarball', Puppet::Forge::Cache.base_path)
+    end
+
+    def unpack(file, destination)
+      begin
+        Puppet::ModuleTool::Applications::Unpacker.unpack(file, destination)
+      rescue Puppet::ExecutionFailure => e
+        raise RuntimeError, "Could not extract contents of module archive: #{e.message}"
+      end
+    end
+  end
+end

data/vendor/pup410/lib/puppet/module_tool/metadata.rb

@@ -0,0 +1,221 @@
+require 'puppet/util/methodhelper'
+require 'puppet/module_tool'
+require 'puppet/network/format_support'
+require 'uri'
+require 'json'
+require 'set'
+
+module Puppet::ModuleTool
+
+  # This class provides a data structure representing a module's metadata.
+  # @api private
+  class Metadata
+    include Puppet::Network::FormatSupport
+
+    attr_accessor :module_name
+
+    DEFAULTS = {
+      'name'          => nil,
+      'version'       => nil,
+      'author'        => nil,
+      'summary'       => nil,
+      'license'       => 'Apache-2.0',
+      'source'        => '',
+      'project_page'  => nil,
+      'issues_url'    => nil,
+      'dependencies'  => Set.new.freeze,
+      'data_provider' => nil,
+    }
+
+    def initialize
+      @data = DEFAULTS.dup
+      @data['dependencies'] = @data['dependencies'].dup
+    end
+
+    # Returns a filesystem-friendly version of this module name.
+    def dashed_name
+      @data['name'].tr('/', '-') if @data['name']
+    end
+
+    # Returns a string that uniquely represents this version of this module.
+    def release_name
+      return nil unless @data['name'] && @data['version']
+      [ dashed_name, @data['version'] ].join('-')
+    end
+
+    alias :name :module_name
+    alias :full_module_name :dashed_name
+
+    # Merges the current set of metadata with another metadata hash.  This
+    # method also handles the validation of module names and versions, in an
+    # effort to be proactive about module publishing constraints.
+    def update(data)
+      process_name(data) if data['name']
+      process_version(data) if data['version']
+      process_source(data) if data['source']
+      process_data_provider(data) if data['data_provider']
+      merge_dependencies(data) if data['dependencies']
+
+      @data.merge!(data)
+      return self
+    end
+
+    # Validates the name and version_requirement for a dependency, then creates
+    # the Dependency and adds it.
+    # Returns the Dependency that was added.
+    def add_dependency(name, version_requirement=nil, repository=nil)
+      validate_name(name)
+      validate_version_range(version_requirement) if version_requirement
+
+      if dup = @data['dependencies'].find { |d| d.full_module_name == name && d.version_requirement != version_requirement }
+        raise ArgumentError, "Dependency conflict for #{full_module_name}: Dependency #{name} was given conflicting version requirements #{version_requirement} and #{dup.version_requirement}. Verify that there are no duplicates in the metadata.json."
+      end
+
+      dep = Dependency.new(name, version_requirement, repository)
+      @data['dependencies'].add(dep)
+
+      dep
+    end
+
+    # Provides an accessor for the now defunct 'description' property.  This
+    # addresses a regression in Puppet 3.6.x where previously valid templates
+    # referring to the 'description' property were broken.
+    # @deprecated
+    def description
+      @data['description']
+    end
+
+    def dependencies
+      @data['dependencies'].to_a
+    end
+
+    # Returns a hash of the module's metadata.  Used by Puppet's automated
+    # serialization routines.
+    #
+    # @see Puppet::Network::FormatSupport#to_data_hash
+    def to_hash
+      @data
+    end
+    alias :to_data_hash :to_hash
+
+    def to_json
+      data = @data.dup.merge('dependencies' => dependencies)
+
+      contents = data.keys.map do |k|
+        value = (JSON.pretty_generate(data[k]) rescue data[k].to_json)
+        "#{k.to_json}: #{value}"
+      end
+
+      "{\n" + contents.join(",\n").gsub(/^/, '  ') + "\n}\n"
+    end
+
+    # Expose any metadata keys as callable reader methods.
+    def method_missing(name, *args)
+      return @data[name.to_s] if @data.key? name.to_s
+      super
+    end
+
+    private
+
+    # Do basic validation and parsing of the name parameter.
+    def process_name(data)
+      validate_name(data['name'])
+      author, @module_name = data['name'].split(/[-\/]/, 2)
+
+      data['author'] ||= author if @data['author'] == DEFAULTS['author']
+    end
+
+    # Do basic validation on the version parameter.
+    def process_version(data)
+      validate_version(data['version'])
+    end
+
+    def process_data_provider(data)
+      validate_data_provider(data['data_provider'])
+    end
+
+    # Do basic parsing of the source parameter.  If the source is hosted on
+    # GitHub, we can predict sensible defaults for both project_page and
+    # issues_url.
+    def process_source(data)
+      if data['source'] =~ %r[://]
+        source_uri = URI.parse(data['source'])
+      else
+        source_uri = URI.parse("http://#{data['source']}")
+      end
+
+      if source_uri.host =~ /^(www\.)?github\.com$/
+        source_uri.scheme = 'https'
+        source_uri.path.sub!(/\.git$/, '')
+        data['project_page'] ||= @data['project_page'] || source_uri.to_s
+        data['issues_url'] ||= @data['issues_url'] || source_uri.to_s.sub(/\/*$/, '') + '/issues'
+      end
+
+    rescue URI::Error
+      return
+    end
+
+    # Validates and parses the dependencies.
+    def merge_dependencies(data)
+      data['dependencies'].each do |dep|
+        add_dependency(dep['name'], dep['version_requirement'], dep['repository'])
+      end
+
+      # Clear dependencies so @data dependencies are not overwritten
+      data.delete 'dependencies'
+    end
+
+    # Validates that the given module name is both namespaced and well-formed.
+    def validate_name(name)
+      return if name =~ /\A[a-z0-9]+[-\/][a-z][a-z0-9_]*\Z/i
+
+      namespace, modname = name.split(/[-\/]/, 2)
+      modname = :namespace_missing if namespace == ''
+
+      err = case modname
+      when nil, '', :namespace_missing
+        "the field must be a namespaced module name"
+      when /[^a-z0-9_]/i
+        "the module name contains non-alphanumeric (or underscore) characters"
+      when /^[^a-z]/i
+        "the module name must begin with a letter"
+      else
+        "the namespace contains non-alphanumeric characters"
+      end
+
+      raise ArgumentError, "Invalid 'name' field in metadata.json: #{err}"
+    end
+
+    # Validates that the version string can be parsed as per SemVer.
+    def validate_version(version)
+      return if SemVer.valid?(version)
+
+      err = "version string cannot be parsed as a valid Semantic Version"
+      raise ArgumentError, "Invalid 'version' field in metadata.json: #{err}"
+    end
+
+    # Validates that the given _value_ is a symbolic name that starts with a letter
+    # and then contains only letters, digits, or underscore. Will raise an ArgumentError
+    # if that's not the case.
+    #
+    # @param value [Object] The value to be tested
+    def validate_data_provider(value)
+      err = nil
+      if value.is_a?(String)
+        unless value =~ /^[a-zA-Z][a-zA-Z0-9_]*$/
+          err = value =~ /^[a-zA-Z]/ ? 'contains non-alphanumeric characters' : 'must begin with a letter'
+        end
+      else
+        err = 'must be a string'
+      end
+      raise ArgumentError, "field 'data_provider' #{err}" if err
+    end
+
+    # Validates that the version range can be parsed by Semantic.
+    def validate_version_range(version_range)
+      SemanticPuppet::VersionRange.parse(version_range)
+    rescue ArgumentError => e
+      raise ArgumentError, "Invalid 'version_range' field in metadata.json: #{e}"
+    end
+  end
+end

data/vendor/pup410/lib/puppet/module_tool/skeleton/templates/generator/examples/init.pp.erb

@@ -0,0 +1,12 @@
+# The baseline for module testing used by Puppet Inc. is that each manifest
+# should have a corresponding test manifest that declares that class or defined
+# type.
+#
+# Tests are then run by using puppet apply --noop (to check for compilation
+# errors and view a log of events) or by fully applying the test in a virtual
+# environment (to compare the resulting system state to the desired state).
+#
+# Learn more about module testing here:
+# https://docs.puppet.com/guides/tests_smoke.html
+#
+include ::<%= metadata.name %>

data/vendor/pup410/lib/puppet/module_tool/tar.rb

@@ -0,0 +1,17 @@
+require 'puppet/module_tool'
+require 'puppet/util'
+
+module Puppet::ModuleTool::Tar
+  require 'puppet/module_tool/tar/gnu'
+  require 'puppet/module_tool/tar/mini'
+
+  def self.instance
+    if Puppet.features.minitar? && Puppet.features.zlib?
+      Mini.new
+    elsif Puppet::Util.which('tar') && ! Puppet::Util::Platform.windows?
+      Gnu.new
+    else
+      raise RuntimeError, 'No suitable tar implementation found'
+    end
+  end
+end

data/vendor/pup410/lib/puppet/network/http/api/indirected_routes.rb

@@ -0,0 +1,239 @@
+require 'puppet/network/authorization'
+require 'puppet/network/http/api/indirection_type'
+
+class Puppet::Network::HTTP::API::IndirectedRoutes
+  include Puppet::Network::Authorization
+
+  # How we map http methods and the indirection name in the URI
+  # to an indirection method.
+  METHOD_MAP = {
+    "GET" => {
+      :plural => :search,
+      :singular => :find
+    },
+    "POST" => {
+      :singular => :find,
+    },
+    "PUT" => {
+      :singular => :save
+    },
+    "DELETE" => {
+      :singular => :destroy
+    },
+    "HEAD" => {
+      :singular => :head
+    }
+  }
+
+  IndirectionType = Puppet::Network::HTTP::API::IndirectionType
+
+  def self.routes
+    Puppet::Network::HTTP::Route.path(/.*/).any(new)
+  end
+
+  # handle an HTTP request
+  def call(request, response)
+    indirection, method, key, params = uri2indirection(request.method, request.path, request.params)
+    certificate = request.client_cert
+
+    if !indirection.allow_remote_requests?
+      # TODO: should we tell the user we found an indirection but it doesn't
+      # allow remote requests, or just pretend there's no handler at all? what
+      # are the security implications for the former?
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("No handler for #{indirection.name}", :NO_INDIRECTION_REMOTE_REQUESTS)
+    end
+
+    trusted = Puppet::Context::TrustedInformation.remote(params[:authenticated], params[:node], certificate)
+    Puppet.override(:trusted_information => trusted) do
+      send("do_#{method}", indirection, key, params, request, response)
+    end
+  end
+
+  def uri2indirection(http_method, uri, params)
+    # the first field is always nil because of the leading slash,
+    indirection_type, version, indirection_name, key = uri.split("/", 5)[1..-1]
+    url_prefix = "/#{indirection_type}/#{version}"
+    environment = params.delete(:environment)
+
+    if indirection_name !~ /^\w+$/
+      raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
+        "The indirection name must be purely alphanumeric, not '#{indirection_name}'")
+    end
+
+    # this also depluralizes the indirection_name if it is a search
+    method = indirection_method(http_method, indirection_name)
+
+    # check whether this indirection matches the prefix and version in the
+    # request
+    if url_prefix != IndirectionType.url_prefix_for(indirection_name)
+      raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
+        "Indirection '#{indirection_name}' does not match url prefix '#{url_prefix}'")
+    end
+
+    indirection = Puppet::Indirector::Indirection.instance(indirection_name.to_sym)
+    if !indirection
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(
+        "Could not find indirection '#{indirection_name}'",
+        Puppet::Network::HTTP::Issues::HANDLER_NOT_FOUND)
+    end
+
+    if !environment
+      raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
+        "An environment parameter must be specified")
+    end
+
+    if ! Puppet::Node::Environment.valid_name?(environment)
+      raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
+        "The environment must be purely alphanumeric, not '#{environment}'")
+    end
+
+    configured_environment = Puppet.lookup(:environments).get(environment)
+    unless configured_environment.nil?
+      configured_environment = configured_environment.override_from_commandline(Puppet.settings)
+      params[:environment] = configured_environment
+    end
+
+    begin
+      check_authorization(method, "#{url_prefix}/#{indirection_name}/#{key}", params)
+    rescue Puppet::Network::AuthorizationError => e
+      raise Puppet::Network::HTTP::Error::HTTPNotAuthorizedError.new(e.message)
+    end
+
+    if configured_environment.nil?
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(
+        "Could not find environment '#{environment}'")
+    end
+
+    params.delete(:bucket_path)
+
+    if key == "" or key.nil?
+      raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
+        "No request key specified in #{uri}")
+    end
+
+    [indirection, method, key, params]
+  end
+
+  private
+
+  # Execute our find.
+  def do_find(indirection, key, params, request, response)
+    unless result = indirection.find(key, params)
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("Could not find #{indirection.name} #{key}", Puppet::Network::HTTP::Issues::RESOURCE_NOT_FOUND)
+    end
+
+    format = accepted_response_formatter_for(indirection.model, request)
+
+    rendered_result = result
+    if result.respond_to?(:render)
+      Puppet::Util::Profiler.profile("Rendered result in #{format}", [:http, :v3_render, format]) do
+        rendered_result = result.render(format)
+      end
+    end
+
+    Puppet::Util::Profiler.profile("Sent response", [:http, :v3_response]) do
+      response.respond_with(200, format, rendered_result)
+    end
+  end
+
+  # Execute our head.
+  def do_head(indirection, key, params, request, response)
+    unless indirection.head(key, params)
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("Could not find #{indirection.name} #{key}", Puppet::Network::HTTP::Issues::RESOURCE_NOT_FOUND)
+    end
+
+    # No need to set a response because no response is expected from a
+    # HEAD request.  All we need to do is not die.
+  end
+
+  # Execute our search.
+  def do_search(indirection, key, params, request, response)
+    result = indirection.search(key, params)
+
+    if result.nil?
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("Could not find instances in #{indirection.name} with '#{key}'", Puppet::Network::HTTP::Issues::RESOURCE_NOT_FOUND)
+    end
+
+    format = accepted_response_formatter_for(indirection.model, request)
+
+    response.respond_with(200, format, indirection.model.render_multiple(format, result))
+  end
+
+  # Execute our destroy.
+  def do_destroy(indirection, key, params, request, response)
+    formatter = accepted_response_formatter_or_pson_for(indirection.model, request)
+
+    result = indirection.destroy(key, params)
+
+    response.respond_with(200, formatter, formatter.render(result))
+  end
+
+  # Execute our save.
+  def do_save(indirection, key, params, request, response)
+    formatter = accepted_response_formatter_or_pson_for(indirection.model, request)
+    sent_object = read_body_into_model(indirection.model, request)
+
+    result = indirection.save(sent_object, key)
+
+    response.respond_with(200, formatter, formatter.render(result))
+  end
+
+  def accepted_response_formatter_for(model_class, request)
+    accepted_formats = request.headers['accept'] or raise Puppet::Network::HTTP::Error::HTTPNotAcceptableError.new("Missing required Accept header", Puppet::Network::HTTP::Issues::MISSING_HEADER_FIELD)
+    request.response_formatter_for(model_class.supported_formats, accepted_formats)
+  end
+
+  def accepted_response_formatter_or_pson_for(model_class, request)
+    accepted_formats = request.headers['accept'] || "text/pson"
+    request.response_formatter_for(model_class.supported_formats, accepted_formats)
+  end
+
+  def read_body_into_model(model_class, request)
+    data = request.body.to_s
+
+    format = request.format
+    model_class.convert_from(format, data)
+  end
+
+  def indirection_method(http_method, indirection)
+    raise Puppet::Network::HTTP::Error::HTTPMethodNotAllowedError.new(
+      "No support for http method #{http_method}") unless METHOD_MAP[http_method]
+
+    unless method = METHOD_MAP[http_method][plurality(indirection)]
+      raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
+        "No support for plurality #{plurality(indirection)} for #{http_method} operations")
+    end
+
+    method
+  end
+
+  def self.request_to_uri(request)
+    uri, body = request_to_uri_and_body(request)
+    "#{uri}?#{body}"
+  end
+
+  def self.request_to_uri_and_body(request)
+    url_prefix = IndirectionType.url_prefix_for(request.indirection_name.to_s)
+    indirection = request.method == :search ? pluralize(request.indirection_name.to_s) : request.indirection_name.to_s
+    ["#{url_prefix}/#{indirection}/#{request.escaped_key}", "environment=#{request.environment.name}&#{request.query_string}"]
+  end
+
+  def self.pluralize(indirection)
+    return(indirection == "status" ? "statuses" : indirection + "s")
+  end
+
+  def plurality(indirection)
+    # NOTE These specific hooks for paths are ridiculous, but it's a *many*-line
+    # fix to not need this, and our goal is to move away from the complication
+    # that leads to the fix being too long.
+    return :singular if indirection == "status"
+    return :singular if indirection == "certificate_status"
+
+    result = (indirection =~ /s$|_search$/) ? :plural : :singular
+
+    indirection.sub!(/s$|_search$/, '')
+    indirection.sub!(/statuse$/, 'status')
+
+    result
+  end
+end