openvox 7.37.1

data/lib/puppet/module_tool/metadata.rb

@@ -0,0 +1,221 @@
+require_relative '../../puppet/module_tool'
+require_relative '../../puppet/network/format_support'
+require 'uri'
+require_relative '../../puppet/util/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
+
+      dup = @data['dependencies'].find { |d| d.full_module_name == name && d.version_requirement != version_requirement }
+      raise ArgumentError, _("Dependency conflict for %{module_name}: Dependency %{name} was given conflicting version requirements %{version_requirement} and %{dup_version}. Verify that there are no duplicates in the metadata.json.") % { module_name: full_module_name, name: name, version_requirement: version_requirement, dup_version: dup.version_requirement } if dup
+
+      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 = (Puppet::Util::Json.dump(data[k], :pretty => true) rescue data[k].to_json)
+        %Q("#{k}": #{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}") % { err: err }
+    end
+
+    # Validates that the version string can be parsed as per SemVer.
+    def validate_version(version)
+      return if SemanticPuppet::Version.valid?(version)
+
+      err = _("version string cannot be parsed as a valid Semantic Version")
+      raise ArgumentError, _("Invalid 'version' field in metadata.json: %{err}") % { err: 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)
+      if value.is_a?(String)
+        unless value =~ /^[a-zA-Z][a-zA-Z0-9_]*$/
+          if value =~ /^[a-zA-Z]/
+            raise ArgumentError, _("field 'data_provider' contains non-alphanumeric characters")
+          else
+            raise ArgumentError, _("field 'data_provider' must begin with a letter")
+          end
+        end
+      else
+        raise ArgumentError, _("field 'data_provider' must be a string")
+      end
+    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: %{err}") % { err: e }
+    end
+  end
+end

data/lib/puppet/module_tool/shared_behaviors.rb

@@ -0,0 +1,181 @@
+module Puppet::ModuleTool::Shared
+
+  include Puppet::ModuleTool::Errors
+
+  def get_local_constraints
+    @local      = Hash.new { |h,k| h[k] = { } }
+    @conditions = Hash.new { |h,k| h[k] = [] }
+    @installed  = Hash.new { |h,k| h[k] = [] }
+
+    @environment.modules_by_path.values.flatten.each do |mod|
+      mod_name = (mod.forge_name || mod.name).tr('/', '-')
+      @installed[mod_name] << mod
+      d = @local["#{mod_name}@#{mod.version}"]
+      (mod.dependencies || []).each do |hash|
+        name, conditions = hash['name'], hash['version_requirement']
+        name = name.tr('/', '-')
+        d[name] = conditions
+        @conditions[name] << {
+          :module => mod_name,
+          :version => mod.version,
+          :dependency => conditions
+        }
+      end
+    end
+  end
+
+  def get_remote_constraints(forge)
+    @remote   = Hash.new { |h,k| h[k] = { } }
+    @urls     = {}
+    @versions = Hash.new { |h,k| h[k] = [] }
+
+    Puppet.notice _("Downloading from %{uri} ...") % { uri: forge.uri }
+    author, modname = Puppet::ModuleTool.username_and_modname_from(@module_name)
+    info = forge.remote_dependency_info(author, modname, @options[:version])
+    info.each do |pair|
+      mod_name, releases = pair
+      mod_name = mod_name.tr('/', '-')
+      releases.each do |rel|
+        semver = SemanticPuppet::Version.parse(rel['version']) rescue SemanticPuppet::Version::MIN
+        @versions[mod_name] << { :vstring => rel['version'], :semver => semver }
+        @versions[mod_name].sort! { |a, b| a[:semver] <=> b[:semver] }
+        @urls["#{mod_name}@#{rel['version']}"] = rel['file']
+        d = @remote["#{mod_name}@#{rel['version']}"]
+        (rel['dependencies'] || []).each do |name, conditions|
+          d[name.tr('/', '-')] = conditions
+        end
+      end
+    end
+  end
+
+  def implicit_version(mod)
+    return :latest if @conditions[mod].empty?
+    if @conditions[mod].all? { |c| c[:queued] || c[:module] == :you }
+      return :latest
+    end
+    return :best
+  end
+
+  def annotated_version(mod, versions)
+    if versions.empty?
+      return implicit_version(mod)
+    else
+      return "#{implicit_version(mod)}: #{versions.last}"
+    end
+  end
+
+  def resolve_constraints(dependencies, source = [{:name => :you}], seen = {}, action = @action)
+    dependencies = dependencies.map do |mod, range|
+      source.last[:dependency] = range
+
+      @conditions[mod] << {
+        :module     => source.last[:name],
+        :version    => source.last[:version],
+        :dependency => range,
+        :queued     => true
+      }
+
+      if forced?
+        range = Puppet::Module.parse_range(@version) rescue Puppet::Module.parse_range('>= 0.0.0')
+      else
+        range = (@conditions[mod]).map do |r|
+          Puppet::Module.parse_range(r[:dependency]) rescue Puppet::Module.parse_range('>= 0.0.0')
+        end.inject(&:&)
+      end
+
+      if @action == :install && seen.include?(mod)
+        next if range === seen[mod][:semver]
+
+        req_module   = @module_name
+        req_versions = @versions["#{@module_name}"].map { |v| v[:semver] }
+        raise InvalidDependencyCycleError,
+          :module_name       => mod,
+          :source            => (source + [{ :name => mod, :version => source.last[:dependency] }]),
+          :requested_module  => req_module,
+          :requested_version => @version || annotated_version(req_module, req_versions),
+          :conditions        => @conditions
+      end
+
+      if !(forced? || @installed[mod].empty? || source.last[:name] == :you)
+        next if range === SemanticPuppet::Version.parse(@installed[mod].first.version)
+        action = :upgrade
+      elsif @installed[mod].empty?
+        action = :install
+      end
+
+      if action == :upgrade
+        @conditions.each { |_, conds| conds.delete_if { |c| c[:module] == mod } }
+      end
+
+      versions = @versions["#{mod}"].select { |h| range === h[:semver] }
+      valid_versions = versions.select { |x| x[:semver].special == '' }
+      valid_versions = versions if valid_versions.empty?
+
+      version = valid_versions.last
+      unless version
+        req_module   = @module_name
+        req_versions = @versions["#{@module_name}"].map { |v| v[:semver] }
+        raise NoVersionsSatisfyError,
+          :requested_name    => req_module,
+          :requested_version => @version || annotated_version(req_module, req_versions),
+          :installed_version => @installed[@module_name].empty? ? nil : @installed[@module_name].first.version,
+          :dependency_name   => mod,
+          :conditions        => @conditions[mod],
+          :action            => @action
+      end
+
+      seen[mod] = version
+
+      {
+        :module           => mod,
+        :version          => version,
+        :action           => action,
+        :previous_version => @installed[mod].empty? ? nil : @installed[mod].first.version,
+        :file             => @urls["#{mod}@#{version[:vstring]}"],
+        :path             => action == :install ? @options[:target_dir] : (@installed[mod].empty? ? @options[:target_dir] : @installed[mod].first.modulepath),
+        :dependencies     => []
+      }
+    end.compact
+    dependencies.each do |mod|
+      deps = @remote["#{mod[:module]}@#{mod[:version][:vstring]}"].sort_by(&:first)
+      mod[:dependencies] = resolve_constraints(deps, source + [{ :name => mod[:module], :version => mod[:version][:vstring] }], seen, :install)
+    end unless @ignore_dependencies
+    return dependencies
+  end
+
+  def download_tarballs(graph, default_path, forge)
+    graph.map do |release|
+      begin
+        if release[:tarball]
+          cache_path = Pathname(release[:tarball])
+        else
+          cache_path = forge.retrieve(release[:file])
+        end
+      rescue OpenURI::HTTPError => e
+        raise RuntimeError, _("Could not download module: %{message}") % { message: e.message }, e.backtrace
+      end
+
+      [
+        { (release[:path] ||= default_path) => cache_path},
+        *download_tarballs(release[:dependencies], default_path, forge)
+      ]
+    end.flatten
+  end
+
+  def forced?
+    options[:force]
+  end
+
+  def add_module_name_constraints_to_graph(graph)
+    # Puppet modules are installed by "module name", but resolved by
+    # "full name" (including namespace).  So that we don't run into
+    # problems at install time, we should reject any solution that
+    # depends on multiple nodes with the same "module name".
+    graph.add_graph_constraint('PMT') do |nodes|
+      names = nodes.map { |x| x.dependency_names + [ x.name ] }.flatten
+      names = names.map { |x| x.tr('/', '-') }.uniq
+      names = names.map { |x| x[/-(.*)/, 1] }
+      names.length == names.uniq.length
+    end
+  end
+end

data/lib/puppet/module_tool/tar/gnu.rb

@@ -0,0 +1,19 @@
+require 'shellwords'
+
+class Puppet::ModuleTool::Tar::Gnu
+  def unpack(sourcefile, destdir, owner)
+    sourcefile = File.expand_path(sourcefile)
+    destdir = File.expand_path(destdir)
+
+    Dir.chdir(destdir) do
+      Puppet::Util::Execution.execute("gzip -dc #{Shellwords.shellescape(sourcefile)} | tar xof -")
+      Puppet::Util::Execution.execute("find . -type d -exec chmod 755 {} +")
+      Puppet::Util::Execution.execute("find . -type f -exec chmod u+rw,g+r,a-st {} +")
+      Puppet::Util::Execution.execute("chown -R #{owner} .")
+    end
+  end
+
+  def pack(sourcedir, destfile)
+    Puppet::Util::Execution.execute("tar cf - #{sourcedir} | gzip -c > #{File.basename(destfile)}")
+  end
+end

data/lib/puppet/module_tool/tar/mini.rb

@@ -0,0 +1,116 @@
+class Puppet::ModuleTool::Tar::Mini
+  def unpack(sourcefile, destdir, _)
+    Zlib::GzipReader.open(sourcefile) do |reader|
+      # puppet doesn't have a hard dependency on minitar, so we
+      # can't be certain which version is installed. If it's 0.9
+      # or above then we can prevent minitar from fsync'ing each
+      # extracted file and directory, otherwise fallback to the
+      # old behavior
+      args = [reader, destdir, find_valid_files(reader)]
+      spec = Gem::Specification.find_by_name('minitar')
+      if spec && spec.version >= Gem::Version.new('0.9')
+        args << {:fsync => false}
+      end
+      Archive::Tar::Minitar.unpack(*args) do |action, name, stats|
+        case action
+        when :dir
+          validate_entry(destdir, name)
+          set_dir_mode!(stats)
+          Puppet.debug("Extracting: #{destdir}/#{name}")
+        when :file_start
+          # Octal string of the old file mode.
+          validate_entry(destdir, name)
+          set_file_mode!(stats)
+          Puppet.debug("Extracting: #{destdir}/#{name}")
+        end
+        set_default_user_and_group!(stats)
+        stats
+      end
+    end
+  end
+
+  def pack(sourcedir, destfile)
+    Zlib::GzipWriter.open(destfile) do |writer|
+      Archive::Tar::Minitar.pack(sourcedir, writer) do |step, name, stats|
+        # TODO smcclellan 2017-10-31 Set permissions here when this yield block
+        # executes before the header is written. As it stands, the `stats`
+        # argument isn't mutable in a way that will effect the desired mode for
+        # the file.
+      end
+    end
+  end
+
+  private
+
+  EXECUTABLE = 0755
+  NOT_EXECUTABLE = 0644
+  USER_EXECUTE = 0100
+
+  def set_dir_mode!(stats)
+    if stats.key?(:mode)
+      # This is only the case for `pack`, so this code will not run.
+      stats[:mode] = EXECUTABLE
+    elsif stats.key?(:entry)
+      old_mode = stats[:entry].instance_variable_get(:@mode)
+      if old_mode.is_a?(Integer)
+        stats[:entry].instance_variable_set(:@mode, EXECUTABLE)
+      end
+    end
+  end
+
+  # Sets a file mode to 0755 if the file is executable by the user.
+  # Sets a file mode to 0644 if the file mode is set (non-Windows).
+  def sanitized_mode(old_mode)
+    old_mode & USER_EXECUTE != 0 ? EXECUTABLE : NOT_EXECUTABLE
+  end
+
+  def set_file_mode!(stats)
+    if stats.key?(:mode)
+      # This is only the case for `pack`, so this code will not run.
+      stats[:mode] = sanitized_mode(stats[:mode])
+    elsif stats.key?(:entry)
+      old_mode = stats[:entry].instance_variable_get(:@mode)
+      # If the user can execute the file, set 0755, otherwise 0644.
+      if old_mode.is_a?(Integer)
+        new_mode = sanitized_mode(old_mode)
+        stats[:entry].instance_variable_set(:@mode, new_mode)
+      end
+    end
+  end
+
+  # Sets UID and GID to 0 for standardization.
+  def set_default_user_and_group!(stats)
+    stats[:uid] = 0
+    stats[:gid] = 0
+  end
+
+  # Find all the valid files in tarfile.
+  #
+  # This check was mainly added to ignore 'x' and 'g' flags from the PAX
+  # standard but will also ignore any other non-standard tar flags.
+  # tar format info: https://pic.dhe.ibm.com/infocenter/zos/v1r13/index.jsp?topic=%2Fcom.ibm.zos.r13.bpxa500%2Ftaf.htm
+  # pax format info: https://pic.dhe.ibm.com/infocenter/zos/v1r13/index.jsp?topic=%2Fcom.ibm.zos.r13.bpxa500%2Fpxarchfm.htm
+  def find_valid_files(tarfile)
+    Archive::Tar::Minitar.open(tarfile).collect do |entry|
+      flag = entry.typeflag
+      if flag.nil? || flag =~ /[[:digit:]]/ && (0..7).cover?(flag.to_i)
+        entry.full_name
+      else
+        Puppet.debug "Invalid tar flag '#{flag}' will not be extracted: #{entry.name}"
+        next
+      end
+    end
+  end
+
+  def validate_entry(destdir, path)
+    if Pathname.new(path).absolute?
+      raise Puppet::ModuleTool::Errors::InvalidPathInPackageError, :entry_path => path, :directory => destdir
+    end
+
+    path = Pathname.new(File.join(destdir, path)).cleanpath.to_path
+
+    if path !~ /\A#{Regexp.escape destdir}/
+      raise Puppet::ModuleTool::Errors::InvalidPathInPackageError, :entry_path => path, :directory => destdir
+    end
+  end
+end

data/lib/puppet/module_tool/tar.rb

@@ -0,0 +1,18 @@
+require_relative '../../puppet/module_tool'
+require_relative '../../puppet/util'
+
+module Puppet::ModuleTool::Tar
+  require_relative 'tar/gnu'
+  require_relative '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
+      #TRANSLATORS "tar" is a program name and should not be translated
+      raise RuntimeError, _('No suitable tar implementation found')
+    end
+  end
+end