bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/file_system/uniquefile.rb

@@ -1,190 +0,0 @@
-require 'puppet/file_system'
-require 'delegate'
-require 'tmpdir'
-
-# A class that provides `Tempfile`-like capabilities, but does not attempt to
-# manage the deletion of the file for you.  API is identical to the
-# normal `Tempfile` class.
-#
-# @api public
-class Puppet::FileSystem::Uniquefile < DelegateClass(File)
-  # Convenience method which ensures that the file is closed and
-  # unlinked before returning
-  #
-  # @param identifier [String] additional part of generated pathname
-  # @yieldparam file [File] the temporary file object
-  # @return result of the passed block
-  # @api private
-  def self.open_tmp(identifier)
-    f = new(identifier)
-    yield f
-  ensure
-    if f
-      f.close!
-    end
-  end
-
-  def initialize(basename, *rest)
-    create_tmpname(basename, *rest) do |tmpname, n, opts|
-      mode = File::RDWR|File::CREAT|File::EXCL
-      perm = 0600
-      if opts
-        mode |= opts.delete(:mode) || 0
-        opts[:perm] = perm
-        perm = nil
-      else
-        opts = perm
-      end
-      self.class.locking(tmpname) do
-        @tmpfile = File.open(tmpname, mode, opts)
-        @tmpname = tmpname
-      end
-      @mode = mode & ~(File::CREAT|File::EXCL)
-      perm or opts.freeze
-      @opts = opts
-    end
-
-    super(@tmpfile)
-  end
-
-  # Opens or reopens the file with mode "r+".
-  def open
-    @tmpfile.close if @tmpfile
-    @tmpfile = File.open(@tmpname, @mode, @opts)
-    __setobj__(@tmpfile)
-  end
-
-  def _close
-    begin
-      @tmpfile.close if @tmpfile
-    ensure
-      @tmpfile = nil
-    end
-  end
-  protected :_close
-
-  def close(unlink_now=false)
-    if unlink_now
-      close!
-    else
-      _close
-    end
-  end
-
-  def close!
-    _close
-    unlink
-  end
-
-  def unlink
-    return unless @tmpname
-    begin
-      File.unlink(@tmpname)
-    rescue Errno::ENOENT
-    rescue Errno::EACCES
-      # may not be able to unlink on Windows; just ignore
-      return
-    end
-    @tmpname = nil
-  end
-  alias delete unlink
-
-  # Returns the full path name of the temporary file.
-  # This will be nil if #unlink has been called.
-  def path
-    @tmpname
-  end
-
-  private
-
-  def make_tmpname(prefix_suffix, n)
-    case prefix_suffix
-      when String
-        prefix = prefix_suffix
-        suffix = ""
-      when Array
-        prefix = prefix_suffix[0]
-        suffix = prefix_suffix[1]
-      else
-        raise ArgumentError, _("unexpected prefix_suffix: %{value}") % { value: prefix_suffix.inspect }
-    end
-    t = Time.now.strftime("%Y%m%d")
-    path = "#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}"
-    path << "-#{n}" if n
-    path << suffix
-  end
-
-  def create_tmpname(basename, *rest)
-    if opts = try_convert_to_hash(rest[-1])
-      opts = opts.dup if rest.pop.equal?(opts)
-      max_try = opts.delete(:max_try)
-      opts = [opts]
-    else
-      opts = []
-    end
-    tmpdir, = *rest
-    if $SAFE > 0 and tmpdir.tainted?
-      tmpdir = '/tmp'
-    else
-      tmpdir ||= tmpdir()
-    end
-    n = nil
-    begin
-      path = File.expand_path(make_tmpname(basename, n), tmpdir)
-      yield(path, n, *opts)
-    rescue Errno::EEXIST
-      n ||= 0
-      n += 1
-      retry if !max_try or n < max_try
-      raise _("cannot generate temporary name using `%{basename}' under `%{tmpdir}'") % { basename: basename, tmpdir: tmpdir }
-    end
-    path
-  end
-
-  def try_convert_to_hash(h)
-    begin
-      h.to_hash
-    rescue NoMethodError
-      nil
-    end
-  end
-
-  @@systmpdir ||= defined?(Etc.systmpdir) ? Etc.systmpdir : '/tmp'
-
-  def tmpdir
-    tmp = '.'
-    if $SAFE > 0
-      @@systmpdir
-    else
-      for dir in [ Puppet::Util.get_env('TMPDIR'), Puppet::Util.get_env('TMP'), Puppet::Util.get_env('TEMP'), @@systmpdir, '/tmp']
-        if dir and stat = File.stat(dir) and stat.directory? and stat.writable?
-          tmp = dir
-          break
-        end rescue nil
-      end
-      File.expand_path(tmp)
-    end
-  end
-
-
-  class << self
-    # yields with locking for +tmpname+ and returns the result of the
-    # block.
-    def locking(tmpname)
-      lock = tmpname + '.lock'
-      mkdir(lock)
-      yield
-    ensure
-      rmdir(lock) if Puppet::FileSystem.exist?(lock)
-    end
-
-    def mkdir(*args)
-      Dir.mkdir(*args)
-    end
-
-    def rmdir(*args)
-      Dir.rmdir(*args)
-    end
-  end
-
-end

data/vendored/puppet/lib/puppet/file_system/windows.rb

@@ -1,130 +0,0 @@
-require 'puppet/file_system/posix'
-require 'puppet/util/windows'
-
-class Puppet::FileSystem::Windows < Puppet::FileSystem::Posix
-
-  def open(path, mode, options, &block)
-    # PUP-6959 mode is explicitly ignored until it can be implemented
-    # Ruby on Windows uses mode for setting file attributes like read-only and
-    # archived, not for setting permissions like POSIX
-    raise TypeError.new('mode must be specified as an Integer') if mode && !mode.is_a?(Numeric)
-    ::File.open(path, options, nil, &block)
-  end
-
-  def expand_path(path, dir_string = nil)
-    # ensure `nil` values behave like underlying File.expand_path
-    string_path = ::File.expand_path(path.nil? ? nil : path_string(path), dir_string)
-    # if no tildes, nothing to expand, no need to call Windows API, return original string
-    return string_path if !string_path.index('~')
-
-    begin
-      # no need to do existence check up front as GetLongPathName implies that check is performed
-      # and it should be the exception that files aren't actually present
-      string_path = Puppet::Util::Windows::File.get_long_pathname(string_path)
-    rescue Puppet::Util::Windows::Error => e
-      # preserve original File.expand_path behavior for file / path not found by returning string
-      raise if (e.code != Puppet::Util::Windows::File::ERROR_FILE_NOT_FOUND &&
-        e.code != Puppet::Util::Windows::File::ERROR_PATH_NOT_FOUND)
-    end
-
-    string_path
-  end
-
-  def exist?(path)
-    return Puppet::Util::Windows::File.exist?(path)
-  end
-
-  def symlink(path, dest, options = {})
-    raise_if_symlinks_unsupported
-
-    dest_exists = exist?(dest) # returns false on dangling symlink
-    dest_stat = Puppet::Util::Windows::File.stat(dest) if dest_exists
-
-    # silent fail to preserve semantics of original FileUtils
-    return 0 if dest_exists && dest_stat.ftype == 'directory'
-
-    if dest_exists && dest_stat.ftype == 'file' && options[:force] != true
-      raise(Errno::EEXIST, _("%{dest} already exists and the :force option was not specified") % { dest: dest })
-    end
-
-    if options[:noop] != true
-      ::File.delete(dest) if dest_exists # can only be file
-      Puppet::Util::Windows::File.symlink(path, dest)
-    end
-
-    0
-  end
-
-  def symlink?(path)
-    return false if ! Puppet.features.manages_symlinks?
-    Puppet::Util::Windows::File.symlink?(path)
-  end
-
-  def readlink(path)
-    raise_if_symlinks_unsupported
-    Puppet::Util::Windows::File.readlink(path)
-  end
-
-  def unlink(*file_names)
-    if ! Puppet.features.manages_symlinks?
-      return ::File.unlink(*file_names)
-    end
-
-    file_names.each do |file_name|
-      file_name = file_name.to_s # handle PathName
-      stat = Puppet::Util::Windows::File.stat(file_name) rescue nil
-
-      # sigh, Ruby + Windows :(
-      if !stat
-        ::File.unlink(file_name) rescue Dir.rmdir(file_name)
-      elsif stat.ftype == 'directory'
-        if Puppet::Util::Windows::File.symlink?(file_name)
-          Dir.rmdir(file_name)
-        else
-          raise Errno::EPERM.new(file_name)
-        end
-      else
-        ::File.unlink(file_name)
-      end
-    end
-
-    file_names.length
-  end
-
-  def stat(path)
-    Puppet::Util::Windows::File.stat(path)
-  end
-
-  def lstat(path)
-    if ! Puppet.features.manages_symlinks?
-      return Puppet::Util::Windows::File.stat(path)
-    end
-    Puppet::Util::Windows::File.lstat(path)
-  end
-
-  def chmod(mode, path)
-    Puppet::Util::Windows::Security.set_mode(mode, path.to_s)
-  end
-
-  def read_preserve_line_endings(path)
-    contents = path.read( :mode => 'rb', :encoding => Encoding::UTF_8)
-    contents = path.read( :mode => 'rb', :encoding => Encoding::default_external) unless contents.valid_encoding?
-    contents = path.read unless contents.valid_encoding?
-
-    contents
-  end
-
-  private
-
-  def raise_if_symlinks_unsupported
-    if ! Puppet.features.manages_symlinks?
-      msg = _("This version of Windows does not support symlinks.  Windows Vista / 2008 or higher is required.")
-      raise Puppet::Util::Windows::Error.new(msg)
-    end
-
-    if ! Puppet::Util::Windows::Process.process_privilege_symlink?
-      Puppet.warning _("The current user does not have the necessary permission to manage symlinks.")
-    end
-  end
-
-end

data/vendored/puppet/lib/puppet/forge.rb

@@ -1,241 +0,0 @@
-require 'puppet/vendor'
-Puppet::Vendor.load_vendored
-
-require 'net/http'
-require 'tempfile'
-require 'uri'
-require 'pathname'
-require 'puppet/util/json'
-require 'semantic_puppet'
-
-class Puppet::Forge < SemanticPuppet::Dependency::Source
-  require 'puppet/forge/cache'
-  require 'puppet/forge/repository'
-  require 'puppet/forge/errors'
-
-  include Puppet::Forge::Errors
-
-  USER_AGENT = "PMT/1.1.1 (v3; Net::HTTP)".freeze
-
-  attr_reader :host, :repository
-
-  def initialize(host = Puppet[:module_repository])
-    @host = host
-    @repository = Puppet::Forge::Repository.new(host, USER_AGENT)
-  end
-
-  # Return a list of module metadata hashes that match the search query.
-  # This return value is used by the module_tool face install search,
-  # and displayed to on the console.
-  #
-  # Example return value:
-  #
-  # [
-  #   {
-  #     "author"      => "puppetlabs",
-  #     "name"        => "bacula",
-  #     "tag_list"    => ["backup", "bacula"],
-  #     "releases"    => [{"version"=>"0.0.1"}, {"version"=>"0.0.2"}],
-  #     "full_name"   => "puppetlabs/bacula",
-  #     "version"     => "0.0.2",
-  #     "project_url" => "https://github.com/puppetlabs/puppetlabs-bacula",
-  #     "desc"        => "bacula"
-  #   }
-  # ]
-  #
-  # @param term [String] search term
-  # @return [Array] modules found
-  # @raise [Puppet::Forge::Errors::CommunicationError] if there is a network
-  #   related error
-  # @raise [Puppet::Forge::Errors::SSLVerifyError] if there is a problem
-  #   verifying the remote SSL certificate
-  # @raise [Puppet::Forge::Errors::ResponseError] if the repository returns a
-  #   bad HTTP response
-  def search(term)
-    matches = []
-    uri = "/v3/modules?query=#{term}"
-    if Puppet[:module_groups]
-      uri += "&module_groups=#{Puppet[:module_groups].gsub('+', ' ')}"
-    end
-
-    while uri
-      # make_http_request URI encodes parameters
-      response = make_http_request(uri)
-
-      if response.code == '200'
-        result = Puppet::Util::Json.load(response.body)
-        uri = decode_uri(result['pagination']['next'])
-        matches.concat result['results']
-      else
-        raise ResponseError.new(:uri => URI.parse(@host).merge(uri), :response => response)
-      end
-    end
-
-    matches.each do |mod|
-      mod['author'] = mod['owner']['username']
-      mod['tag_list'] = mod['current_release']['tags']
-      mod['full_name'] = "#{mod['author']}/#{mod['name']}"
-      mod['version'] = mod['current_release']['version']
-      mod['project_url'] = mod['homepage_url']
-      mod['desc'] = mod['current_release']['metadata']['summary'] || ''
-    end
-  end
-
-  # Fetches {ModuleRelease} entries for each release of the named module.
-  #
-  # @param input [String] the module name to look up
-  # @return [Array<SemanticPuppet::Dependency::ModuleRelease>] a list of releases for
-  #         the given name
-  # @see SemanticPuppet::Dependency::Source#fetch
-  def fetch(input)
-    name = input.tr('/', '-')
-    uri = "/v3/releases?module=#{name}&sort_by=version"
-    if Puppet[:module_groups]
-      uri += "&module_groups=#{Puppet[:module_groups].gsub('+', ' ')}"
-    end
-    releases = []
-
-    while uri
-      # make_http_request URI encodes parameters
-      response = make_http_request(uri)
-
-      if response.code == '200'
-        response = Puppet::Util::Json.load(response.body)
-      else
-        raise ResponseError.new(:uri => URI.parse(@host).merge(uri), :response => response)
-      end
-
-      releases.concat(process(response['results']))
-      uri = decode_uri(response['pagination']['next'])
-    end
-
-    return releases
-  end
-
-  def make_http_request(*args)
-    @repository.make_http_request(*args)
-  end
-
-  class ModuleRelease < SemanticPuppet::Dependency::ModuleRelease
-    attr_reader :install_dir, :metadata
-
-    def initialize(source, data)
-      @data = data
-      @metadata = meta = data['metadata']
-
-      name = meta['name'].tr('/', '-')
-      version = SemanticPuppet::Version.parse(meta['version'])
-      release = "#{name}@#{version}"
-
-      if meta['dependencies']
-        dependencies = meta['dependencies'].collect do |dep|
-          begin
-            Puppet::ModuleTool::Metadata.new.add_dependency(dep['name'], dep['version_requirement'], dep['repository'])
-            Puppet::ModuleTool.parse_module_dependency(release, dep)[0..1]
-          rescue ArgumentError => e
-            raise ArgumentError, _("Malformed dependency: %{name}.") % { name: dep['name'] } +
-                ' ' + _("Exception was: %{detail}") % { detail: e }
-          end
-        end
-      else
-        dependencies = []
-      end
-
-      super(source, name, version, Hash[dependencies])
-    end
-
-    def install(dir)
-      staging_dir = self.prepare
-
-      module_dir = dir + 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)
-      @install_dir = dir
-
-      # Return the Pathname object representing the directory where the
-      # module release archive was unpacked the to.
-      return module_dir
-    ensure
-      staging_dir.rmtree if staging_dir.exist?
-    end
-
-    def prepare
-      return @unpacked_into if @unpacked_into
-
-      Puppet.warning "#{@metadata['name']} has been deprecated by its author! View module on Puppet Forge for more info." if deprecated?
-
-      download(@data['file_uri'], tmpfile)
-      validate_checksum(tmpfile, @data['file_md5'])
-      unpack(tmpfile, tmpdir)
-
-      @unpacked_into = Pathname.new(tmpdir)
-    end
-
-    private
-
-    # Obtain a suitable temporary path for unpacking tarballs
-    #
-    # @return [Pathname] path to temporary unpacking location
-    def tmpdir
-      @dir ||= Dir.mktmpdir(name, Puppet::Forge::Cache.base_path)
-    end
-
-    def tmpfile
-      @file ||= Tempfile.new(name, Puppet::Forge::Cache.base_path).tap do |f|
-        f.binmode
-      end
-    end
-
-    def download(uri, destination)
-      response = @source.make_http_request(uri, destination)
-      destination.flush and destination.close
-      unless response.code == '200'
-        raise Puppet::Forge::Errors::ResponseError.new(:uri => uri, :response => response)
-      end
-    end
-
-    def validate_checksum(file, checksum)
-      if Digest::MD5.file(file.path).hexdigest != checksum
-        raise RuntimeError, _("Downloaded release for %{name} did not match expected checksum") % { name: name }
-      end
-    end
-
-    def unpack(file, destination)
-      begin
-        Puppet::ModuleTool::Applications::Unpacker.unpack(file.path, destination)
-      rescue Puppet::ExecutionFailure => e
-        raise RuntimeError, _("Could not extract contents of module archive: %{message}") % { message: e.message }
-      end
-    end
-
-    def deprecated?
-      @data['module'] && (@data['module']['deprecated_at'] != nil)
-    end
-  end
-
-  private
-
-  def process(list)
-    l = list.map do |release|
-      metadata = release['metadata']
-      begin
-        ModuleRelease.new(self, release)
-      rescue ArgumentError => e
-        Puppet.warning _("Cannot consider release %{name}-%{version}: %{error}") % { name: metadata['name'], version: metadata['version'], error: e }
-        false
-      end
-    end
-
-    l.select { |r| r }
-  end
-
-  def decode_uri(uri)
-    return if uri.nil?
-
-    URI.decode(uri.gsub('+', ' '))
-  end
-end