RubyGems - bolt - Versions diffs - 0.24.0 → 0.25.0 - Mend

bolt 0.24.0 → 0.25.0

Potentially problematic release.

This version of bolt might be problematic. Click here for more details.

Files changed (1155) hide show

data/vendored/puppet/lib/puppet/provider/package/opkg.rb DELETED

@@ -1,81 +0,0 @@
-require 'puppet/provider/package'
-Puppet::Type.type(:package).provide :opkg, :source => :opkg, :parent => Puppet::Provider::Package do
-  desc "Opkg packaging support. Common on OpenWrt and OpenEmbedded platforms"
-  commands :opkg => "opkg"
-  confine     :operatingsystem => :openwrt
-  defaultfor  :operatingsystem => :openwrt
-  def self.instances
-    packages = []
-    execpipe("#{command(:opkg)} list-installed") do |process|
-      regex = %r{^(\S+) - (\S+)}
-      fields = [:name, :ensure]
-      hash = {}
-      process.each_line { |line|
-        if match = regex.match(line)
-          fields.zip(match.captures) { |field,value| hash[field] = value }
-          hash[:provider] = self.name
-          packages << new(hash)
-          hash = {}
-        else
-          warning(_("Failed to match line %{line}") % { line: line })
-        end
-      }
-    end
-    packages
-  rescue Puppet::ExecutionFailure
-    return nil
-  end
-  def latest
-    output = opkg( "list", @resource[:name])
-    matches = /^(\S+) - (\S+)/.match(output).captures
-    matches[1]
-  end
-  def install
-    # OpenWrt package lists are ephemeral, make sure we have at least
-    # some entries in the list directory for opkg to use
-    opkg('update') if package_lists.size <= 2
-    if @resource[:source]
-      opkg( '--force-overwrite', 'install', @resource[:source] )
-    else
-      opkg( '--force-overwrite', 'install', @resource[:name] )
-    end
-  end
-  def uninstall
-    opkg( 'remove', @resource[:name] )
-  end
-  def update
-    self.install
-  end
-  def query
-    # list out our specific package
-    output = opkg( 'list-installed', @resource[:name] )
-    if output =~ /^(\S+) - (\S+)/
-      return { :ensure => $2 }
-    end
-    nil
-  rescue Puppet::ExecutionFailure
-    return {
-      :ensure => :purged,
-      :status => 'missing',
-      :name => @resource[:name],
-      :error => 'ok',
-    }
-  end
-  private
-  def package_lists
-    Dir.entries('/var/opkg-lists/')
-  end
-end

data/vendored/puppet/lib/puppet/provider/package/pacman.rb DELETED

@@ -1,267 +0,0 @@
-require 'puppet/provider/package'
-require 'set'
-require 'uri'
-Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Package do
-  desc "Support for the Package Manager Utility (pacman) used in Archlinux.
-  This provider supports the `install_options` attribute, which allows command-line flags to be passed to pacman.
-  These options should be specified as a string (e.g. '--flag'), a hash (e.g. {'--flag' => 'value'}),
-  or an array where each element is either a string or a hash."
-  # If yaourt is installed, we can make use of it
-  def self.yaourt?
-    @yaourt ||= Puppet::FileSystem.exist?('/usr/bin/yaourt')
-  end
-  commands :pacman => "/usr/bin/pacman"
-  # Yaourt is a common AUR helper which, if installed, we can use to query the AUR
-  commands :yaourt => "/usr/bin/yaourt" if yaourt?
-  confine     :operatingsystem => [:archlinux, :manjarolinux]
-  defaultfor  :operatingsystem => [:archlinux, :manjarolinux]
-  has_feature :install_options
-  has_feature :uninstall_options
-  has_feature :upgradeable
-  has_feature :virtual_packages
-  # Checks if a given name is a group
-  def self.group?(name)
-    begin
-      !pacman("-Sg", name).empty?
-    rescue Puppet::ExecutionFailure
-      # pacman returns an expected non-zero exit code when the name is not a group
-      false
-    end
-  end
-  # Install a package using 'pacman', or 'yaourt' if available.
-  # Installs quietly, without confirmation or progress bar, updates package
-  # list from servers defined in pacman.conf.
-  def install
-    if @resource[:source]
-      install_from_file
-    else
-      install_from_repo
-    end
-    unless self.query
-      fail(_("Could not find package '%{name}'") % { name: @resource[:name] })
-    end
-  end
-  # Fetch the list of packages and package groups that are currently installed on the system.
-  # Only package groups that are fully installed are included. If a group adds packages over time, it will not
-  # be considered as fully installed any more, and we would install the new packages on the next run.
-  # If a group removes packages over time, nothing will happen. This is intended.
-  def self.instances
-    instances = []
-    # Get the installed packages
-    installed_packages = get_installed_packages
-    installed_packages.sort_by { |k, _| k }.each do |package, version|
-      instances << new(to_resource_hash(package, version))
-    end
-    # Get the installed groups
-    get_installed_groups(installed_packages).each do |group, version|
-      instances << new(to_resource_hash(group, version))
-    end
-    instances
-  end
-  # returns a hash package => version of installed packages
-  def self.get_installed_packages
-    begin
-      packages = {}
-      execpipe([command(:pacman), "-Q"]) do |pipe|
-        # pacman -Q output is 'packagename version-rel'
-        regex = %r{^(\S+)\s(\S+)}
-        pipe.each_line do |line|
-          if match = regex.match(line)
-            packages[match.captures[0]] = match.captures[1]
-          else
-            warning(_("Failed to match line '%{line}'") % { line: line })
-          end
-        end
-      end
-      packages
-    rescue Puppet::ExecutionFailure
-      fail(_("Error getting installed packages"))
-    end
-  end
-  # returns a hash of group => version of installed groups
-  def self.get_installed_groups(installed_packages, filter = nil)
-    groups = {}
-    begin
-      # Build a hash of group name => list of packages
-      command = [command(:pacman), "-Sgg"]
-      command << filter if filter
-      execpipe(command) do |pipe|
-        pipe.each_line do |line|
-          name, package = line.split
-          packages = (groups[name] ||= [])
-          packages << package
-        end
-      end
-      # Remove any group that doesn't have all its packages installed
-      groups.delete_if do |_, packages|
-        !packages.all? { |package| installed_packages[package] }
-      end
-      # Replace the list of packages with a version string consisting of packages that make up the group
-      groups.each do |name, packages|
-        groups[name] = packages.sort.map {|package| "#{package} #{installed_packages[package]}"}.join ', '
-      end
-    rescue Puppet::ExecutionFailure
-      # pacman returns an expected non-zero exit code when the filter name is not a group
-      raise unless filter
-    end
-    groups
-  end
-  # Because Archlinux is a rolling release based distro, installing a package
-  # should always result in the newest release.
-  def update
-    # Install in pacman can be used for update, too
-    self.install
-  end
-  # We rescue the main check from Pacman with a check on the AUR using yaourt, if installed
-  def latest
-    # Synchronize the database
-    pacman "-Sy"
-    resource_name = @resource[:name]
-    # If target is a group, construct the group version
-    return pacman("-Sp", "--print-format", "%n %v", resource_name).lines.map{ |line| line.chomp }.sort.join(', ') if self.class.group?(resource_name)
-    # Start by querying with pacman first
-    # If that fails, retry using yaourt against the AUR
-    pacman_check = true
-    begin
-      if pacman_check
-        output = pacman "-Sp", "--print-format", "%v", resource_name
-        return output.chomp
-      else
-        output = yaourt "-Qma", resource_name
-        output.split("\n").each do |line|
-          return line.split[1].chomp if line =~ /^aur/
-        end
-      end
-    rescue Puppet::ExecutionFailure
-      if pacman_check and self.class.yaourt?
-        pacman_check = false # now try the AUR
-        retry
-      else
-        raise
-      end
-    end
-  end
-  # Queries information for a package or package group
-  def query
-    installed_packages = self.class.get_installed_packages
-    resource_name = @resource[:name]
-    # Check for the resource being a group
-    version = self.class.get_installed_groups(installed_packages, resource_name)[resource_name]
-    if version
-      unless @resource.allow_virtual?
-        warning(_("%{resource_name} is a group, but allow_virtual is false.") % { resource_name: resource_name })
-        return nil
-      end
-    else
-      version = installed_packages[resource_name]
-    end
-    # Return nil if no package or group found
-    return nil unless version
-    self.class.to_resource_hash(resource_name, version)
-  end
-  def self.to_resource_hash(name, version)
-    {
-      :name     => name,
-      :ensure   => version,
-      :provider => self.name
-    }
-  end
-  # Removes a package from the system.
-  def uninstall
-    resource_name = @resource[:name]
-    is_group = self.class.group?(resource_name)
-    fail(_("Refusing to uninstall package group %{resource_name}, because allow_virtual is false.") % { resource_name: resource_name }) if is_group && !@resource.allow_virtual?
-    cmd = %w{--noconfirm --noprogressbar}
-    cmd += uninstall_options if @resource[:uninstall_options]
-    cmd << "-R"
-    cmd << '-s' if is_group
-    cmd << resource_name
-    if self.class.yaourt?
-      yaourt(*cmd)
-    else
-      pacman(*cmd)
-    end
-  end
-  private
-  def install_options
-    join_options(@resource[:install_options])
-  end
-  def uninstall_options
-    join_options(@resource[:uninstall_options])
-  end
-  def install_from_file
-    source = @resource[:source]
-    begin
-      source_uri = URI.parse source
-    rescue => detail
-      self.fail Puppet::Error, _("Invalid source '%{source}': %{detail}") % { source: source, detail: detail }, detail
-    end
-    source = case source_uri.scheme
-    when nil then source
-    when /https?/i then source
-    when /ftp/i then source
-    when /file/i then source_uri.path
-    when /puppet/i
-      fail _("puppet:// URL is not supported by pacman")
-    else
-      fail _("Source %{source} is not supported by pacman") % { source: source }
-    end
-    pacman "--noconfirm", "--noprogressbar", "-Sy"
-    pacman "--noconfirm", "--noprogressbar", "-U", source
-  end
-  def install_from_repo
-    resource_name = @resource[:name]
-    # Refuse to install if not allowing virtual packages and the resource is a group
-    fail(_("Refusing to install package group %{resource_name}, because allow_virtual is false.") % { resource_name: resource_name }) if self.class.group?(resource_name) && !@resource.allow_virtual?
-    cmd = %w{--noconfirm --needed --noprogressbar}
-    cmd += install_options if @resource[:install_options]
-    cmd << "-Sy" << resource_name
-    if self.class.yaourt?
-      yaourt(*cmd)
-    else
-      pacman(*cmd)
-    end
-  end
-end

data/vendored/puppet/lib/puppet/provider/package/pip.rb DELETED

@@ -1,188 +0,0 @@
-# Puppet package provider for Python's `pip` package management frontend.
-# <http://pip.pypa.io/>
-require 'puppet/provider/package'
-require 'puppet/util/http_proxy'
-Puppet::Type.type(:package).provide :pip,
-  :parent => ::Puppet::Provider::Package do
-  desc "Python packages via `pip`.
-  This provider supports the `install_options` attribute, which allows command-line flags to be passed to pip.
-  These options should be specified as a string (e.g. '--flag'), a hash (e.g. {'--flag' => 'value'}),
-  or an array where each element is either a string or a hash."
-  has_feature :installable, :uninstallable, :upgradeable, :versionable, :install_options
-  # Parse lines of output from `pip freeze`, which are structured as
-  # _package_==_version_.
-  def self.parse(line)
-    if line.chomp =~ /^([^=]+)==([^=]+)$/
-      {:ensure => $2, :name => $1, :provider => name}
-    else
-      nil
-    end
-  end
-  # Return an array of structured information about every installed package
-  # that's managed by `pip` or an empty array if `pip` is not available.
-  def self.instances
-    packages = []
-    pip_cmd = self.pip_cmd
-    return [] unless pip_cmd
-    command = [pip_cmd, 'freeze']
-    if Puppet::Util::Package.versioncmp(self.pip_version, '8.1.0') >= 0 # a >= b
-      command << '--all'
-    end
-    execpipe command do |process|
-      process.collect do |line|
-        next unless options = parse(line)
-        packages << new(options)
-      end
-    end
-    # Pip can also upgrade pip, but it's not listed in freeze so need to special case it
-    # Pip list would also show pip installed version, but "pip list" doesn't exist for older versions of pip (E.G v1.0)
-    # Not needed when "pip freeze --all" is available
-    if Puppet::Util::Package.versioncmp(self.pip_version, '8.1.0') == -1 && version = self.pip_version
-      packages << new({:ensure => version, :name => File.basename(pip_cmd), :provider => name})
-    end
-    packages
-  end
-  def self.cmd
-    if Puppet::Util::Platform.windows?
-      ["pip.exe"]
-    else
-      ["pip", "pip-python"]
-    end
-  end
-  def self.pip_cmd
-    self.cmd.map { |c| which(c) }.find { |c| c != nil }
-  end
-  def self.pip_version
-    pip_cmd = self.pip_cmd
-    return nil unless pip_cmd
-    execpipe [pip_cmd, '--version'] do |process|
-      process.collect do |line|
-        return line.strip.match(/^pip (\d+\.\d+\.?\d*).*$/)[1]
-      end
-    end
-  end
-  # Return structured information about a particular package or `nil` if
-  # it is not installed or `pip` itself is not available.
-  def query
-    self.class.instances.each do |provider_pip|
-      return provider_pip.properties if @resource[:name].downcase == provider_pip.name.downcase
-    end
-    return nil
-  end
-  # Use pip CLI to look up versions from PyPI repositories, honoring local pip config such as custom repositories
-  def latest
-    return nil unless self.class.pip_cmd
-    if Puppet::Util::Package.versioncmp(self.class.pip_version, '1.5.4') == -1 # a < b
-      return latest_with_old_pip
-    end
-    latest_with_new_pip
-  end
-  # Install a package.  The ensure parameter may specify installed,
-  # latest, a version number, or, in conjunction with the source
-  # parameter, an SCM revision.  In that case, the source parameter
-  # gives the fully-qualified URL to the repository.
-  def install
-    args = %w{install -q}
-    args +=  install_options if @resource[:install_options]
-    if @resource[:source]
-      if String === @resource[:ensure]
-        args << "#{@resource[:source]}@#{@resource[:ensure]}#egg=#{
-          @resource[:name]}"
-      else
-        args << "#{@resource[:source]}#egg=#{@resource[:name]}"
-      end
-    else
-      case @resource[:ensure]
-      when String
-        args << "#{@resource[:name]}==#{@resource[:ensure]}"
-      when :latest
-        args << "--upgrade" << @resource[:name]
-      else
-        args << @resource[:name]
-      end
-    end
-    lazy_pip(*args)
-  end
-  # Uninstall a package.  Uninstall won't work reliably on Debian/Ubuntu
-  # unless this issue gets fixed.
-  # <http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=562544>
-  def uninstall
-    lazy_pip "uninstall", "-y", "-q", @resource[:name]
-  end
-  def update
-    install
-  end
-  # Execute a `pip` command.  If Puppet doesn't yet know how to do so,
-  # try to teach it and if even that fails, raise the error.
-  private
-  def lazy_pip(*args)
-    pip(*args)
-  rescue NoMethodError => e
-    # Ensure pip can upgrade pip, which usually puts pip into a new path /usr/local/bin/pip (compared to /usr/bin/pip)
-    # The path to pip needs to be looked up again in the subsequent request. Using the preferred approach as noted
-    # in provider.rb ensures this (copied below for reference)
-    #
-    # @note From provider.rb; It is preferred if the commands are not entered with absolute paths as this allows puppet
-    # to search for them using the PATH variable.
-    if pathname = self.class.cmd.map { |c| which(c) }.find { |c| c != nil }
-      self.class.commands :pip => File.basename(pathname)
-      pip(*args)
-    else
-      raise e, "Could not locate command #{self.class.cmd.join(' and ')}.", e.backtrace
-    end
-  end
-  def install_options
-    join_options(@resource[:install_options])
-  end
-  def latest_with_new_pip
-    # Less resource intensive approach for pip version 1.5.4 and above
-    execpipe ["#{self.class.pip_cmd}", "install", "#{@resource[:name]}==versionplease"] do |process|
-      process.collect do |line|
-        # PIP OUTPUT: Could not find a version that satisfies the requirement Django==versionplease (from versions: 1.1.3, 1.8rc1)
-        if line =~ /from versions: /
-          textAfterLastMatch = $'.chomp(")\n")
-          versionList = textAfterLastMatch.split(', ').sort do |x,y|
-            Puppet::Util::Package.versioncmp(x, y)
-          end
-          return versionList.last
-        end
-      end
-      return nil
-    end
-  end
-  def latest_with_old_pip
-    Dir.mktmpdir("puppet_pip") do |dir|
-      execpipe ["#{self.class.pip_cmd}", "install", "#{@resource[:name]}", "-d", "#{dir}", "-v"] do |process|
-        process.collect do |line|
-          # PIP OUTPUT: Using version 0.10.1 (newest of versions: 0.10.1, 0.10, 0.9, 0.8.1, 0.8, 0.7.2, 0.7.1, 0.7, 0.6.1, 0.6, 0.5.2, 0.5.1, 0.5, 0.4, 0.3.1, 0.3, 0.2, 0.1)
-          if line =~ /Using version (.+?) \(newest of versions/
-            return $1
-          end
-        end
-        return nil
-      end
-    end
-  end
-end