bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/util/network_device/transport/telnet.rb

@@ -1,47 +0,0 @@
-require 'puppet/util/network_device'
-require 'puppet/util/network_device/transport'
-require 'puppet/util/network_device/transport/base'
-
-if Puppet.features.telnet?
-  require 'net/telnet'
-
-  class Puppet::Util::NetworkDevice::Transport::Telnet < Puppet::Util::NetworkDevice::Transport::Base
-      def initialize(verbose = false)
-        super()
-        @verbose = verbose
-      end
-
-      def handles_login?
-        false
-      end
-
-      def connect
-        @telnet = Net::Telnet::new("Host" => host, "Port" => port || 23,
-                                   "Timeout" => 10,
-                                   "Prompt" => default_prompt)
-      end
-
-      def close
-        @telnet.close if @telnet
-        @telnet = nil
-      end
-
-      def expect(prompt)
-        @telnet.waitfor(prompt) do |out|
-          yield out if block_given?
-        end
-      end
-
-      def command(cmd, options = {})
-        send(cmd)
-        expect(options[:prompt] || default_prompt) do |output|
-          yield output if block_given?
-        end
-      end
-
-      def send(line)
-        Puppet.debug("telnet: send #{line}") if @verbose
-        @telnet.puts(line)
-      end
-  end
-end

data/vendored/puppet/lib/puppet/util/package.rb

@@ -1,31 +0,0 @@
-module Puppet::Util::Package
-  def versioncmp(version_a, version_b)
-    vre = /[-.]|\d+|[^-.\d]+/
-    ax = version_a.scan(vre)
-    bx = version_b.scan(vre)
-
-    while (ax.length>0 && bx.length>0)
-      a = ax.shift
-      b = bx.shift
-
-      if( a == b )                 then next
-      elsif (a == '-' && b == '-') then next
-      elsif (a == '-')             then return -1
-      elsif (b == '-')             then return 1
-      elsif (a == '.' && b == '.') then next
-      elsif (a == '.' )            then return -1
-      elsif (b == '.' )            then return 1
-      elsif (a =~ /^\d+$/ && b =~ /^\d+$/) then
-        if( a =~ /^0/ or b =~ /^0/ ) then
-          return a.to_s.upcase <=> b.to_s.upcase
-        end
-        return a.to_i <=> b.to_i
-      else
-        return a.upcase <=> b.upcase
-      end
-    end
-    version_a <=> version_b;
-  end
-
-  module_function :versioncmp
-end

data/vendored/puppet/lib/puppet/util/pidlock.rb

@@ -1,62 +0,0 @@
-require 'fileutils'
-require 'puppet/util/lockfile'
-
-class Puppet::Util::Pidlock
-
-  def initialize(lockfile)
-    @lockfile = Puppet::Util::Lockfile.new(lockfile)
-  end
-
-  def locked?
-    clear_if_stale
-    @lockfile.locked?
-  end
-
-  def mine?
-    Process.pid == lock_pid
-  end
-
-  def lock
-    return mine? if locked?
-
-    @lockfile.lock(Process.pid)
-  end
-
-  def unlock
-    if mine?
-      return @lockfile.unlock
-    else
-      false
-    end
-  end
-
-  def lock_pid
-    pid = @lockfile.lock_data
-    begin
-      Integer(pid)
-    rescue ArgumentError, TypeError
-      nil
-    end
-  end
-
-  def file_path
-    @lockfile.file_path
-  end
-
-  def clear_if_stale
-    return @lockfile.unlock if lock_pid.nil?
-
-    errors = [Errno::ESRCH]
-    # Win32::Process now throws SystemCallError. Since this could be
-    # defined anywhere, only add when on Windows.
-    errors << SystemCallError if Puppet::Util::Platform.windows?
-
-    begin
-      Process.kill(0, lock_pid)
-    rescue *errors
-      @lockfile.unlock
-    end
-  end
-  private :clear_if_stale
-
-end

data/vendored/puppet/lib/puppet/util/platform.rb

@@ -1,35 +0,0 @@
-module Puppet
-  module Util
-    module Platform
-
-      FIPS_STATUS_FILE = "/proc/sys/crypto/fips_enabled".freeze
-
-      def windows?
-        # Ruby only sets File::ALT_SEPARATOR on Windows and the Ruby standard
-        # library uses that to test what platform it's on. In some places we
-        # would use Puppet.features.microsoft_windows?, but this method can be
-        # used to determine the behavior of the underlying system without
-        # requiring features to be initialized and without side effect.
-        !!File::ALT_SEPARATOR
-      end
-      module_function :windows?
-
-      def default_paths
-        return [] if windows?
-
-        %w{/usr/sbin /sbin}
-      end
-      module_function :default_paths
-
-      @fips_enabled = !windows? &&
-                       File.exist?(FIPS_STATUS_FILE) &&  
-                       File.read(FIPS_STATUS_FILE, 1) == '1'
-
-      def fips_enabled?
-        @fips_enabled
-      end
-      module_function :fips_enabled?
-
-    end
-  end
-end

data/vendored/puppet/lib/puppet/util/plist.rb

@@ -1,155 +0,0 @@
-require 'cfpropertylist' if Puppet.features.cfpropertylist?
-require 'puppet/util/execution'
-
-module Puppet::Util::Plist
-
-  class FormatError < RuntimeError; end
-
-  # So I don't have to prepend every method name with 'self.' Most of the
-  # methods are going to be Provider methods (as opposed to methods of the
-  # INSTANCE of the provider).
-  class << self
-    # Defines the magic number for binary plists
-    #
-    # @api private
-    def binary_plist_magic_number
-      "bplist00"
-    end
-
-    # Defines a default doctype string that should be at the top of most plist
-    # files. Useful if we need to modify an invalid doctype string in memory.
-    # In version 10.9 and lower of OS X the plist at
-    # /System/Library/LaunchDaemons/org.ntp.ntpd.plist had an invalid doctype
-    # string. This corrects for that.
-    def plist_xml_doctype
-      '<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">'
-    end
-
-    # Read a plist file, whether its format is XML or in Apple's "binary1"
-    # format, using the CFPropertyList gem.
-    def read_plist_file(file_path)
-      # We can't really read the file until we know the source encoding in
-      # Ruby 1.9.x, so we use the magic number to detect it.
-      # NOTE: We used IO.read originally to be Ruby 1.8.x compatible.
-      if read_file_with_offset(file_path, binary_plist_magic_number.length) == binary_plist_magic_number
-        plist_obj = new_cfpropertylist(:file => file_path)
-        return convert_cfpropertylist_to_native_types(plist_obj)
-      else
-        plist_data = open_file_with_args(file_path, "r:UTF-8")
-        plist = parse_plist(plist_data, file_path)
-        return plist if plist
-
-        Puppet.debug "Plist #{file_path} ill-formatted, converting with plutil"
-        begin
-          plist = Puppet::Util::Execution.execute(['/usr/bin/plutil', '-convert', 'xml1', '-o', '/dev/stdout', file_path],
-                                                  {:failonfail => true, :combine => true})
-          return parse_plist(plist)
-        rescue Puppet::ExecutionFailure => detail
-          message = _("Cannot read file %{file_path}; Puppet is skipping it.") % { file_path: file_path }
-          message += '\n' + _("Details: %{detail}") % { detail: detail }
-          Puppet.warning(message)
-        end
-      end
-      return nil
-    end
-
-    # Read plist text using the CFPropertyList gem.
-    def parse_plist(plist_data, file_path = '')
-      bad_xml_doctype = /^.*<!DOCTYPE plist PUBLIC -\/\/Apple Computer.*$/
-      begin
-        if plist_data =~ bad_xml_doctype
-          plist_data.gsub!( bad_xml_doctype, plist_xml_doctype )
-          Puppet.debug("Had to fix plist with incorrect DOCTYPE declaration: #{file_path}")
-        end
-      rescue ArgumentError => e
-        Puppet.debug "Failed with #{e.class} on #{file_path}: #{e.inspect}"
-        return nil
-      end
-
-      begin
-        plist_obj = new_cfpropertylist(:data => plist_data)
-      # CFPropertyList library will raise NoMethodError for invalid data
-      rescue CFFormatError, NoMethodError => e
-        Puppet.debug "Failed with #{e.class} on #{file_path}: #{e.inspect}"
-        return nil
-      end
-      convert_cfpropertylist_to_native_types(plist_obj)
-    end
-
-    # Helper method to assist in reading a file. It's its own method for
-    # stubbing purposes
-    #
-    # @api private
-    #
-    # @param args [String] Extra file operation mode information to use
-    #   (defaults to read-only mode 'r')
-    #   This is the standard mechanism Ruby uses in the IO class, and therefore
-    #   encoding may be explicitly like fmode : encoding or fmode : "BOM|UTF-*"
-    #   for example, a:ASCII or w+:UTF-8
-    def open_file_with_args(file, args)
-      File.open(file, args).read
-    end
-
-    # Helper method to assist in generating a new CFPropertyList Plist. It's
-    # its own method for stubbing purposes
-    #
-    # @api private
-    def new_cfpropertylist(plist_opts)
-      CFPropertyList::List.new(plist_opts)
-    end
-
-    # Helper method to assist in converting a native CFPropertyList object to a
-    # native Ruby object (hash). It's its own method for stubbing purposes
-    #
-    # @api private
-    def convert_cfpropertylist_to_native_types(plist_obj)
-      CFPropertyList.native_types(plist_obj.value)
-    end
-
-    # Helper method to convert a string into a CFProperty::Blob, which is
-    # needed to properly handle binary strings
-    #
-    # @api private
-    def string_to_blob(str)
-      CFPropertyList::Blob.new(str)
-    end
-
-    # Helper method to assist in reading a file with an offset value. It's its
-    # own method for stubbing purposes
-    #
-    # @api private
-    def read_file_with_offset(file_path, offset)
-      IO.read(file_path, offset)
-    end
-
-    def to_format(format)
-      if format.to_sym == :xml
-        CFPropertyList::List::FORMAT_XML
-      elsif format.to_sym == :binary
-        CFPropertyList::List::FORMAT_BINARY
-      elsif format.to_sym == :plain
-        CFPropertyList::List::FORMAT_PLAIN
-      else
-        raise FormatError.new "Unknown plist format #{format}"
-      end
-    end
-
-    # This method will write a plist file using a specified format (or XML
-    # by default)
-    def write_plist_file(plist, file_path, format = :xml)
-      begin
-        plist_to_save       = CFPropertyList::List.new
-        plist_to_save.value = CFPropertyList.guess(plist)
-        plist_to_save.save(file_path, to_format(format), :formatted => true)
-      rescue IOError => e
-        Puppet.err(_("Unable to write the file %{file_path}. %{error}") % { file_path: file_path, error: e.inspect })
-      end
-    end
-
-    def dump_plist(plist_data, format = :xml)
-      plist_to_save       = CFPropertyList::List.new
-      plist_to_save.value = CFPropertyList.guess(plist_data)
-      plist_to_save.to_str(to_format(format), :formatted => true)
-    end
-  end
-end

data/vendored/puppet/lib/puppet/util/posix.rb

@@ -1,137 +0,0 @@
-# Utility methods for interacting with POSIX objects; mostly user and group
-module Puppet::Util::POSIX
-
-  # This is a list of environment variables that we will set when we want to override the POSIX locale
-  LOCALE_ENV_VARS = ['LANG', 'LC_ALL', 'LC_MESSAGES', 'LANGUAGE',
-                           'LC_COLLATE', 'LC_CTYPE', 'LC_MONETARY', 'LC_NUMERIC', 'LC_TIME']
-
-  # This is a list of user-related environment variables that we will unset when we want to provide a pristine
-  # environment for "exec" runs
-  USER_ENV_VARS = ['HOME', 'USER', 'LOGNAME']
-
-
-
-  # Retrieve a field from a POSIX Etc object.  The id can be either an integer
-  # or a name.  This only works for users and groups.  It's also broken on
-  # some platforms, unfortunately, which is why we fall back to the other
-  # method search_posix_field in the gid and uid methods if a sanity check
-  # fails
-  def get_posix_field(space, field, id)
-    raise Puppet::DevError, _("Did not get id from caller") unless id
-
-    if id.is_a?(Integer)
-      if id > Puppet[:maximum_uid].to_i
-        Puppet.err _("Tried to get %{field} field for silly id %{id}") % { field: field, id: id }
-        return nil
-      end
-      method = methodbyid(space)
-    else
-      method = methodbyname(space)
-    end
-
-    begin
-      return Etc.send(method, id).send(field)
-    rescue NoMethodError, ArgumentError
-      # ignore it; we couldn't find the object
-      return nil
-    end
-  end
-
-  # A degenerate method of retrieving name/id mappings.  The job of this method is
-  # to retrieve all objects of a certain type, search for a specific entry
-  # and then return a given field from that entry.
-  def search_posix_field(type, field, id)
-    idmethod = idfield(type)
-    integer = false
-    if id.is_a?(Integer)
-      integer = true
-      if id > Puppet[:maximum_uid].to_i
-        Puppet.err _("Tried to get %{field} field for silly id %{id}") % { field: field, id: id }
-        return nil
-      end
-    end
-
-    Etc.send(type) do |object|
-      if integer and object.send(idmethod) == id
-        return object.send(field)
-      elsif object.name == id
-        return object.send(field)
-      end
-    end
-
-    # Apparently the group/passwd methods need to get reset; if we skip
-    # this call, then new users aren't found.
-    case type
-    when :passwd; Etc.send(:endpwent)
-    when :group; Etc.send(:endgrent)
-    end
-    nil
-  end
-
-  # Determine what the field name is for users and groups.
-  def idfield(space)
-    case space.intern
-    when :gr, :group; return :gid
-    when :pw, :user, :passwd; return :uid
-    else
-      raise ArgumentError.new(_("Can only handle users and groups"))
-    end
-  end
-
-  # Determine what the method is to get users and groups by id
-  def methodbyid(space)
-    case space.intern
-    when :gr, :group; return :getgrgid
-    when :pw, :user, :passwd; return :getpwuid
-    else
-      raise ArgumentError.new(_("Can only handle users and groups"))
-    end
-  end
-
-  # Determine what the method is to get users and groups by name
-  def methodbyname(space)
-    case space.intern
-    when :gr, :group; return :getgrnam
-    when :pw, :user, :passwd; return :getpwnam
-    else
-      raise ArgumentError.new(_("Can only handle users and groups"))
-    end
-  end
-
-  # Get the GID
-  def gid(group)
-      get_posix_value(:group, :gid, group)
-  end
-
-  # Get the UID
-  def uid(user)
-      get_posix_value(:passwd, :uid, user)
-  end
-
-  private
-
-  # Get the specified id_field of a given field (user or group), 
-  # whether an ID name is provided
-  def get_posix_value(location, id_field, field)
-    begin
-      field = Integer(field)
-    rescue ArgumentError
-      # pass
-    end
-    if field.is_a?(Integer)
-      return nil unless name = get_posix_field(location, :name, field)
-      id = get_posix_field(location, id_field, name)
-      check_value = id
-    else
-      return nil unless id = get_posix_field(location, id_field, field)
-      name = get_posix_field(location, :name, id)
-      check_value = name
-    end
-    if check_value != field
-      return search_posix_field(location, id_field, field)
-    else
-      return id
-    end
-  end
-end
-