bolt 0.20.0 → 0.20.2

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

@@ -0,0 +1,90 @@
+require 'json'
+require 'puppet/util/logging'
+
+class Puppet::Module
+  class Task
+    class Error < Puppet::Error; end
+    class InvalidName < Error; end
+    class InvalidFile < Error; end
+    class TaskNotFound < Error; end
+
+    FORBIDDEN_EXTENSIONS = %w{.conf .md}
+
+    def self.is_task_name?(name)
+      return true if name =~ /^[a-z][a-z0-9_]*$/
+      return false
+    end
+
+    # Determine whether a file has a legal name for either a task's executable or metadata file.
+    def self.is_tasks_filename?(path)
+      name_less_extension = File.basename(path, '.*')
+      return false if not is_task_name?(name_less_extension)
+      FORBIDDEN_EXTENSIONS.each do |ext|
+        return false if path.end_with?(ext)
+      end
+      return true
+    end
+
+    def self.is_tasks_metadata_filename?(name)
+      is_tasks_filename?(name) && name.end_with?('.json')
+    end
+
+    def self.is_tasks_executable_filename?(name)
+      is_tasks_filename?(name) && !name.end_with?('.json')
+    end
+
+    def self.tasks_in_module(pup_module)
+      Dir.glob(File.join(pup_module.tasks_directory, '*'))
+        .keep_if { |f| is_tasks_filename?(f) }
+        .group_by { |f| task_name_from_path(f) }
+        .map { |task, files| new_with_files(pup_module, task, files) }
+    end
+
+    attr_reader :name, :module, :metadata_file, :files
+
+    def initialize(pup_module, task_name, files, metadata_file = nil)
+      if !Puppet::Module::Task.is_task_name?(task_name)
+        raise InvalidName, _("Task names must start with a lowercase letter and be composed of only lowercase letters, numbers, and underscores")
+      end
+
+      all_files = metadata_file.nil? ? files : files + [metadata_file]
+      all_files.each do |f|
+        if !f.start_with?(pup_module.tasks_directory)
+          msg = _("The file '%{path}' is not located in the %{module_name} module's tasks directory") %
+                       {path: f.to_s, module_name: pup_module.name}
+
+          # we can include some extra context for the log message:
+          Puppet.err(msg + " (#{pup_module.tasks_directory})")
+          raise InvalidFile, msg
+        end
+      end
+
+      name = task_name == "init" ? pup_module.name : "#{pup_module.name}::#{task_name}"
+
+      @module = pup_module
+      @name = name
+      @metadata_file = metadata_file if metadata_file
+      @files = files
+    end
+
+    def ==(other)
+      self.name == other.name &&
+      self.module == other.module
+    end
+
+    def self.new_with_files(pup_module, name, tasks_files)
+      files = tasks_files.map do |filename|
+        File.join(pup_module.tasks_directory, File.basename(filename))
+      end
+
+      metadata_files, exe_files = files.partition { |f| is_tasks_metadata_filename?(f) }
+      Puppet::Module::Task.new(pup_module, name, exe_files, metadata_files.first)
+    end
+    private_class_method :new_with_files
+
+    def self.task_name_from_path(path)
+      return File.basename(path, '.*')
+    end
+    private_class_method :task_name_from_path
+  end
+end

data/vendored/puppet/lib/puppet/module_tool.rb

@@ -0,0 +1,196 @@
+# encoding: UTF-8
+# Load standard libraries
+require 'pathname'
+require 'fileutils'
+require 'puppet/util/colors'
+
+module Puppet
+  module ModuleTool
+    require 'puppet/module_tool/tar'
+    extend Puppet::Util::Colors
+
+    # Directory and names that should not be checksummed.
+    ARTIFACTS = ['pkg', /^\./, /^~/, /^#/, 'coverage', 'checksums.json', 'REVISION']
+    FULL_MODULE_NAME_PATTERN = /\A([^-\/|.]+)[-|\/](.+)\z/
+    REPOSITORY_URL = Puppet.settings[:module_repository]
+
+    # Is this a directory that shouldn't be checksummed?
+    #
+    # TODO: Should this be part of Checksums?
+    # TODO: Rename this method to reflect its purpose?
+    # TODO: Shouldn't this be used when building packages too?
+    def self.artifact?(path)
+      case File.basename(path)
+      when *ARTIFACTS
+        true
+      else
+        false
+      end
+    end
+
+    # Return the +username+ and +modname+ for a given +full_module_name+, or raise an
+    # ArgumentError if the argument isn't parseable.
+    def self.username_and_modname_from(full_module_name)
+      if matcher = full_module_name.match(FULL_MODULE_NAME_PATTERN)
+        return matcher.captures
+      else
+        raise ArgumentError, _("Not a valid full name: %{full_module_name}") % { full_module_name: full_module_name }
+      end
+    end
+
+    # Find the module root when given a path by checking each directory up from
+    # its current location until it finds one that satisfies is_module_root?
+    #
+    # @param path [Pathname, String] path to start from
+    # @return [Pathname, nil] the root path of the module directory or nil if
+    #   we cannot find one
+    def self.find_module_root(path)
+      path = Pathname.new(path) if path.class == String
+
+      path.expand_path.ascend do |p|
+        return p if is_module_root?(p)
+      end
+
+      nil
+    end
+
+    # Analyse path to see if it is a module root directory by detecting a
+    # file named 'metadata.json'
+    #
+    # @param path [Pathname, String] path to analyse
+    # @return [Boolean] true if the path is a module root, false otherwise
+    def self.is_module_root?(path)
+      path = Pathname.new(path) if path.class == String
+
+      FileTest.file?(path + 'metadata.json')
+    end
+
+    # Builds a formatted tree from a list of node hashes containing +:text+
+    # and +:dependencies+ keys.
+    def self.format_tree(nodes, level = 0)
+      str = ''
+      nodes.each_with_index do |node, i|
+        last_node = nodes.length - 1 == i
+        deps = node[:dependencies] || []
+
+        str << (indent = "  " * level)
+        str << (last_node ? "└" : "├")
+        str << "─"
+        str << (deps.empty? ? "─" : "┬")
+        str << " #{node[:text]}\n"
+
+        branch = format_tree(deps, level + 1)
+        branch.gsub!(/^#{indent} /, indent + '│') unless last_node
+        str << branch
+      end
+
+      return str
+    end
+
+    def self.build_tree(mods, dir)
+      mods.each do |mod|
+        version_string = mod[:version].to_s.sub(/^(?!v)/, 'v')
+
+        if mod[:action] == :upgrade
+          previous_version = mod[:previous_version].to_s.sub(/^(?!v)/, 'v')
+          version_string = "#{previous_version} -> #{version_string}"
+        end
+
+        mod[:text] = "#{mod[:name]} (#{colorize(:cyan, version_string)})"
+        mod[:text] += " [#{mod[:path]}]" unless mod[:path].to_s == dir.to_s
+
+        deps = (mod[:dependencies] || [])
+        deps.sort! { |a, b| a[:name] <=> b[:name] }
+        build_tree(deps, dir)
+      end
+    end
+
+    # @param options [Hash<Symbol,String>] This hash will contain any
+    #   command-line arguments that are not Settings, as those will have already
+    #   been extracted by the underlying application code.
+    #
+    # @note Unfortunately the whole point of this method is the side effect of
+    # modifying the options parameter.  This same hash is referenced both
+    # when_invoked and when_rendering.  For this reason, we are not returning
+    # a duplicate.
+    # @todo Validate the above note...
+    #
+    # An :environment_instance and a :target_dir are added/updated in the
+    # options parameter.
+    #
+    # @api private
+    def self.set_option_defaults(options)
+      current_environment = environment_from_options(options)
+
+      modulepath = [options[:target_dir]] + current_environment.full_modulepath
+
+      face_environment = current_environment.override_with(:modulepath => modulepath.compact)
+
+      options[:environment_instance] = face_environment
+
+      # Note: environment will have expanded the path
+      options[:target_dir] = face_environment.full_modulepath.first
+
+      # Default false to retain backward compatibility with SemanticPuppet 0.1.4
+      options[:strict_semver] = false unless options.include?(:strict_semver)
+    end
+
+    # Given a hash of options, we should discover or create a
+    # {Puppet::Node::Environment} instance that reflects the provided options.
+    #
+    # Generally speaking, the `:modulepath` parameter should supersede all
+    # others, the `:environment` parameter should follow after that, and we
+    # should default to Puppet's current environment.
+    #
+    # @param options [{Symbol => Object}] the options to derive environment from
+    # @return [Puppet::Node::Environment] the environment described by the options
+    def self.environment_from_options(options)
+      if options[:modulepath]
+        path = options[:modulepath].split(File::PATH_SEPARATOR)
+        Puppet::Node::Environment.create(:anonymous, path, '')
+      elsif options[:environment].is_a?(Puppet::Node::Environment)
+        options[:environment]
+      elsif options[:environment]
+        # This use of looking up an environment is correct since it honours
+        # a request to get a particular environment via environment name.
+        Puppet.lookup(:environments).get!(options[:environment])
+      else
+        Puppet.lookup(:current_environment)
+      end
+    end
+
+    # Handles parsing of module dependency expressions into proper
+    # {SemanticPuppet::VersionRange}s, including reasonable error handling.
+    #
+    # @param where [String] a description of the thing we're parsing the
+    #        dependency expression for
+    # @param dep [Hash] the dependency description to parse
+    # @param strict_semver [Boolean] set to `false` to relax range semantics to include pre-releases
+    # @return [Array(String, SemanticPuppet::VersionRange, String)] a tuple of the
+    #         dependent module's name, the version range dependency, and the
+    #         unparsed range expression.
+    def self.parse_module_dependency(where, dep, strict_semver = true)
+      dep_name = dep['name'].tr('/', '-')
+      range = dep['version_requirement'] || '>= 0.0.0'
+
+      begin
+        parsed_range = Module.parse_range(range, strict_semver)
+      rescue ArgumentError => e
+        Puppet.debug "Error in #{where} parsing dependency #{dep_name} (#{e.message}); using empty range."
+        parsed_range = SemanticPuppet::VersionRange::EMPTY_RANGE
+      end
+
+      [ dep_name, parsed_range, range ]
+    end
+  end
+end
+
+# Load remaining libraries
+require 'puppet/module_tool/errors'
+require 'puppet/module_tool/applications'
+require 'puppet/module_tool/checksums'
+require 'puppet/module_tool/contents_description'
+require 'puppet/module_tool/dependency'
+require 'puppet/module_tool/metadata'
+require 'puppet/forge/cache'
+require 'puppet/forge'

data/vendored/puppet/lib/puppet/module_tool/applications.rb

@@ -0,0 +1,14 @@
+require 'puppet/module_tool'
+
+module Puppet::ModuleTool
+  module Applications
+    require 'puppet/module_tool/applications/application'
+    require 'puppet/module_tool/applications/builder'
+    require 'puppet/module_tool/applications/checksummer'
+    require 'puppet/module_tool/applications/installer'
+    require 'puppet/module_tool/applications/searcher'
+    require 'puppet/module_tool/applications/unpacker'
+    require 'puppet/module_tool/applications/uninstaller'
+    require 'puppet/module_tool/applications/upgrader'
+  end
+end

data/vendored/puppet/lib/puppet/module_tool/applications/application.rb

@@ -0,0 +1,90 @@
+require 'net/http'
+require 'json'
+require 'puppet/util/colors'
+
+module Puppet::ModuleTool
+  module Applications
+    class Application
+      include Puppet::Util::Colors
+
+      def self.run(*args)
+        new(*args).run
+      end
+
+      attr_accessor :options
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def run
+        raise NotImplementedError, "Should be implemented in child classes."
+      end
+
+      def discuss(response, success, failure)
+        case response
+        when Net::HTTPOK, Net::HTTPCreated
+          Puppet.notice success
+        else
+          errors = JSON.parse(response.body)['error'] rescue "HTTP #{response.code}, #{response.body}"
+          Puppet.warning "#{failure} (#{errors})"
+        end
+      end
+
+      def metadata(require_metadata = false)
+        return @metadata if @metadata
+        @metadata = Puppet::ModuleTool::Metadata.new
+
+        unless @path
+          raise ArgumentError, _("Could not determine module path")
+        end
+
+        if require_metadata && !Puppet::ModuleTool.is_module_root?(@path)
+          raise ArgumentError, _("Unable to find metadata.json in module root at %{path} See https://docs.puppet.com/puppet/latest/reference/modules_publishing.html for required file format.") % { path: @path }
+        end
+
+        metadata_path   = File.join(@path, 'metadata.json')
+
+        if File.file?(metadata_path)
+          File.open(metadata_path) do |f|
+            begin
+              @metadata.update(JSON.load(f))
+            rescue JSON::ParserError => ex
+              raise ArgumentError, _("Could not parse JSON %{metadata_path}") % { metadata_path: metadata_path }, ex.backtrace
+            end
+          end
+        end
+
+        if File.file?(File.join(@path, 'Modulefile'))
+          Puppet.warning _("A Modulefile was found in the root directory of the module. This file will be ignored and can safely be removed.")
+        end
+
+        return @metadata
+      end
+
+      def load_metadata!
+        @metadata = nil
+        metadata(true)
+      end
+
+      def parse_filename(filename)
+        if match = /^((.*?)-(.*?))-(\d+\.\d+\.\d+.*?)$/.match(File.basename(filename, '.tar.gz'))
+          module_name, author, shortname, version = match.captures
+        else
+          raise ArgumentError, _("Could not parse filename to obtain the username, module name and version.  (%{release_name})") % { release_name: @release_name }
+        end
+
+        unless SemanticPuppet::Version.valid?(version)
+          raise ArgumentError, _("Invalid version format: %{version} (Semantic Versions are acceptable: http://semver.org)") % { version: version }
+        end
+
+        return {
+          :module_name => module_name,
+          :author      => author,
+          :dir_name    => shortname,
+          :version     => version
+        }
+      end
+    end
+  end
+end

data/vendored/puppet/lib/puppet/module_tool/applications/builder.rb

@@ -0,0 +1,152 @@
+require 'fileutils'
+require 'json'
+require 'puppet/file_system'
+require 'pathspec'
+require 'facter'
+
+module Puppet::ModuleTool
+  module Applications
+    class Builder < Application
+
+      def initialize(path, options = {})
+        @path = File.expand_path(path)
+        @pkg_path = File.join(@path, 'pkg')
+        super(options)
+      end
+
+      def run
+        # Disallow anything that invokes md5 to avoid un-friendly termination due to FIPS
+        raise _("Module building is prohibited in FIPS mode.") if Facter.value(:fips_enabled)
+
+        load_metadata!
+        create_directory
+        copy_contents
+        write_json
+        Puppet.notice _("Building %{path} for release") % { path: @path }
+        pack
+        relative = Pathname.new(archive_file).relative_path_from(Pathname.new(File.expand_path(Dir.pwd)))
+
+        # Return the Pathname object representing the path to the release
+        # archive just created. This return value is used by the module_tool
+        # face build action, and displayed to on the console using the to_s
+        # method.
+        #
+        # Example return value:
+        #
+        #   <Pathname:puppetlabs-apache/pkg/puppetlabs-apache-0.0.1.tar.gz>
+        #
+        relative
+      end
+
+      private
+
+      def archive_file
+        File.join(@pkg_path, "#{metadata.release_name}.tar.gz")
+      end
+
+      def pack
+        FileUtils.rm archive_file rescue nil
+
+        tar = Puppet::ModuleTool::Tar.instance
+        Dir.chdir(@pkg_path) do
+          tar.pack(metadata.release_name, archive_file)
+        end
+      end
+
+      def create_directory
+        FileUtils.mkdir(@pkg_path) rescue nil
+        if File.directory?(build_path)
+          FileUtils.rm_rf(build_path, :secure => true)
+        end
+        FileUtils.mkdir(build_path)
+      end
+
+      def ignored_files
+        if @ignored_files
+          return @ignored_files
+        else
+          pmtignore = File.join(@path, '.pmtignore')
+          gitignore = File.join(@path, '.gitignore')
+
+          if File.file? pmtignore
+            @ignored_files = PathSpec.new Puppet::FileSystem.read(pmtignore, :encoding => 'utf-8')
+          elsif File.file? gitignore
+            @ignored_files = PathSpec.new Puppet::FileSystem.read(gitignore, :encoding => 'utf-8')
+          else
+            @ignored_files = PathSpec.new
+          end
+        end
+      end
+
+      def copy_contents
+        symlinks = []
+        Find.find(File.join(@path)) do |path|
+          # because Find.find finds the path itself
+          if path == @path
+            next
+          end
+
+          # Needed because pathspec looks for a trailing slash in the path to
+          # determine if a path is a directory
+          path = path.to_s + '/' if File.directory? path
+
+          # if it matches, then prune it with fire
+          unless ignored_files.match_paths([path], @path).empty?
+            Find.prune
+          end
+
+          # don't copy all the Puppet ARTIFACTS
+          rel = Pathname.new(path).relative_path_from(Pathname.new(@path))
+          case rel.to_s
+          when *Puppet::ModuleTool::ARTIFACTS
+            Find.prune
+          end
+
+          # make dir tree, copy files, and add symlinks to the symlinks list
+          dest = "#{build_path}/#{rel.to_s}"
+          if File.directory? path
+            FileUtils.mkdir dest, :mode => File.stat(path).mode
+          elsif Puppet::FileSystem.symlink? path
+            symlinks << path
+          else
+            FileUtils.cp path, dest, :preserve => true
+          end
+        end
+
+        # send a message about each symlink and raise an error if they exist
+        unless symlinks.empty?
+          symlinks.each do |s|
+            s = Pathname.new s
+            mpath = Pathname.new @path
+            Puppet.warning _("Symlinks in modules are unsupported. Please investigate symlink %{from} -> %{to}.") % { from: s.relative_path_from(mpath), to: s.realpath.relative_path_from(mpath) }
+          end
+
+          raise Puppet::ModuleTool::Errors::ModuleToolError, _("Found symlinks. Symlinks in modules are not allowed, please remove them.")
+        end
+      end
+
+      def write_json
+        metadata_path = File.join(build_path, 'metadata.json')
+
+        if metadata.to_hash.include? 'checksums'
+          Puppet.warning _("A 'checksums' field was found in metadata.json. This field will be ignored and can safely be removed.")
+        end
+
+        # TODO: This may necessarily change the order in which the metadata.json
+        # file is packaged from what was written by the user.  This is a
+        # regretable, but required for now.
+        Puppet::FileSystem.open(metadata_path, nil, 'w:UTF-8') do |f|
+          f.write(metadata.to_json)
+        end
+
+        Puppet::FileSystem.open(File.join(build_path, 'checksums.json'), nil, 'wb') do |f|
+          f.write(JSON.pretty_generate(Checksums.new(build_path)))
+        end
+      end
+
+      def build_path
+        @build_path ||= File.join(@pkg_path, metadata.release_name)
+      end
+    end
+  end
+end