bolt 0.19.1 → 0.20.0

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

@@ -1,309 +0,0 @@
-# Basic classes for reading, writing, and emptying files.  Not much
-# to see here.
-
-require 'puppet/util/selinux'
-require 'tempfile'
-require 'fileutils'
-
-class Puppet::Util::FileType
-  attr_accessor :loaded, :path, :synced
-
-  class FileReadError < Puppet::Error; end
-
-  include Puppet::Util::SELinux
-
-  class << self
-    attr_accessor :name
-    include Puppet::Util::ClassGen
-  end
-
-  # Create a new filetype.
-  def self.newfiletype(name, &block)
-    @filetypes ||= {}
-
-    klass = genclass(
-      name,
-      :block => block,
-      :prefix => "FileType",
-      :hash => @filetypes
-    )
-
-    # Rename the read and write methods, so that we're sure they
-    # maintain the stats.
-    klass.class_eval do
-      # Rename the read method
-      define_method(:real_read, instance_method(:read))
-      define_method(:read) do
-        begin
-          val = real_read
-          @loaded = Time.now
-          if val
-            return val.gsub(/# HEADER.*\n/,'')
-          else
-            return ""
-          end
-        rescue Puppet::Error
-          raise
-        rescue => detail
-          message = _("%{klass} could not read %{path}: %{detail}") % { klass: self.class, path: @path, detail: detail }
-          Puppet.log_exception(detail, message)
-          raise Puppet::Error, message, detail.backtrace
-        end
-      end
-
-      # And then the write method
-      define_method(:real_write, instance_method(:write))
-      define_method(:write) do |text|
-        begin
-          val = real_write(text)
-          @synced = Time.now
-          return val
-        rescue Puppet::Error
-          raise
-        rescue => detail
-          message = _("%{klass} could not write %{path}: %{detail}") % { klass: self.class, path: @path, detail: detail }
-          Puppet.log_exception(detail, message)
-          raise Puppet::Error, message, detail.backtrace
-        end
-      end
-    end
-  end
-
-  def self.filetype(type)
-    @filetypes[type]
-  end
-
-  # Pick or create a filebucket to use.
-  def bucket
-    @bucket ||= Puppet::Type.type(:filebucket).mkdefaultbucket.bucket
-  end
-
-  def initialize(path, default_mode = nil)
-    raise ArgumentError.new(_("Path is nil")) if path.nil?
-    @path = path
-    @default_mode = default_mode
-  end
-
-  # Arguments that will be passed to the execute method. Will set the uid
-  # to the target user if the target user and the current user are not
-  # the same
-  def cronargs
-    if uid = Puppet::Util.uid(@path) and uid == Puppet::Util::SUIDManager.uid
-      {:failonfail => true, :combine => true}
-    else
-      {:failonfail => true, :combine => true, :uid => @path}
-    end
-  end
-
-  # Operate on plain files.
-  newfiletype(:flat) do
-    # Back the file up before replacing it.
-    def backup
-      bucket.backup(@path) if Puppet::FileSystem.exist?(@path)
-    end
-
-    # Read the file.
-    def read
-      if Puppet::FileSystem.exist?(@path)
-        # this code path is used by many callers so the original default is
-        # being explicitly preserved
-        Puppet::FileSystem.read(@path, :encoding => Encoding.default_external)
-      else
-        return nil
-      end
-    end
-
-    # Remove the file.
-    def remove
-      Puppet::FileSystem.unlink(@path) if Puppet::FileSystem.exist?(@path)
-    end
-
-    # Overwrite the file.
-    def write(text)
-      # this file is managed by the OS and should be using system encoding
-      tf = Tempfile.new("puppet", :encoding => Encoding.default_external)
-      tf.print text; tf.flush
-      File.chmod(@default_mode, tf.path) if @default_mode
-      FileUtils.cp(tf.path, @path)
-      tf.close
-      # If SELinux is present, we need to ensure the file has its expected context
-      set_selinux_default_context(@path)
-    end
-  end
-
-  # Operate on plain files.
-  newfiletype(:ram) do
-    @@tabs = {}
-
-    def self.clear
-      @@tabs.clear
-    end
-
-    def initialize(path, default_mode = nil)
-      # default_mode is meaningless for this filetype,
-      # supported only for compatibility with :flat
-      super
-      @@tabs[@path] ||= ""
-    end
-
-    # Read the file.
-    def read
-      Puppet.info _("Reading %{path} from RAM") % { path: @path }
-      @@tabs[@path]
-    end
-
-    # Remove the file.
-    def remove
-      Puppet.info _("Removing %{path} from RAM") % { path: @path }
-      @@tabs[@path] = ""
-    end
-
-    # Overwrite the file.
-    def write(text)
-      Puppet.info _("Writing %{path} to RAM") % { path: @path }
-      @@tabs[@path] = text
-    end
-  end
-
-  # Handle Linux-style cron tabs.
-  newfiletype(:crontab) do
-    def initialize(user)
-      self.path = user
-    end
-
-    def path=(user)
-      begin
-        @uid = Puppet::Util.uid(user)
-      rescue Puppet::Error => detail
-        raise FileReadError, _("Could not retrieve user %{user}: %{detail}") % { user: user, detail: detail }, detail.backtrace
-      end
-
-      # XXX We have to have the user name, not the uid, because some
-      # systems *cough*linux*cough* require it that way
-      @path = user
-    end
-
-    # Read a specific @path's cron tab.
-    def read
-      %x{#{cmdbase} -l 2>/dev/null}
-    end
-
-    # Remove a specific @path's cron tab.
-    def remove
-      if %w{Darwin FreeBSD DragonFly}.include?(Facter.value("operatingsystem"))
-        %x{/bin/echo yes | #{cmdbase} -r 2>/dev/null}
-      else
-        %x{#{cmdbase} -r 2>/dev/null}
-      end
-    end
-
-    # Overwrite a specific @path's cron tab; must be passed the @path name
-    # and the text with which to create the cron tab.
-    def write(text)
-      # this file is managed by the OS and should be using system encoding
-      IO.popen("#{cmdbase()} -", "w", :encoding => Encoding.default_external) { |p|
-        p.print text
-      }
-    end
-
-    private
-
-    # Only add the -u flag when the @path is different.  Fedora apparently
-    # does not think I should be allowed to set the @path to my own user name
-    def cmdbase
-      if @uid == Puppet::Util::SUIDManager.uid || Facter.value(:operatingsystem) == "HP-UX"
-        return "crontab"
-      else
-        return "crontab -u #{@path}"
-      end
-    end
-  end
-
-  # SunOS has completely different cron commands; this class implements
-  # its versions.
-  newfiletype(:suntab) do
-    # Read a specific @path's cron tab.
-    def read
-      Puppet::Util::Execution.execute(%w{crontab -l}, cronargs)
-    rescue => detail
-      case detail.to_s
-      when /can't open your crontab/
-        return ""
-      when /you are not authorized to use cron/
-        raise FileReadError, _("User %{path} not authorized to use cron") % { path: @path }, detail.backtrace
-      else
-        raise FileReadError, _("Could not read crontab for %{path}: %{detail}") % { path: @path, detail: detail }, detail.backtrace
-      end
-    end
-
-    # Remove a specific @path's cron tab.
-    def remove
-      Puppet::Util::Execution.execute(%w{crontab -r}, cronargs)
-    rescue => detail
-      raise FileReadError, _("Could not remove crontab for %{path}: %{detail}") % { path: @path, detail: detail }, detail.backtrace
-    end
-
-    # Overwrite a specific @path's cron tab; must be passed the @path name
-    # and the text with which to create the cron tab.
-    def write(text)
-      # this file is managed by the OS and should be using system encoding
-      output_file = Tempfile.new("puppet_suntab", :encoding => Encoding.default_external)
-      begin
-        output_file.print text
-        output_file.close
-        # We have to chown the stupid file to the user.
-        File.chown(Puppet::Util.uid(@path), nil, output_file.path)
-        Puppet::Util::Execution.execute(["crontab", output_file.path], cronargs)
-      rescue => detail
-        raise FileReadError, _("Could not write crontab for %{path}: %{detail}") % { path: @path, detail: detail }, detail.backtrace
-      ensure
-        output_file.close
-        output_file.unlink
-      end
-    end
-  end
-
-  #  Support for AIX crontab with output different than suntab's crontab command.
-  newfiletype(:aixtab) do
-    # Read a specific @path's cron tab.
-    def read
-      Puppet::Util::Execution.execute(%w{crontab -l}, cronargs)
-    rescue => detail
-      case detail.to_s
-      when /Cannot open a file in the .* directory/
-        return ""
-      when /You are not authorized to use the cron command/
-        raise FileReadError, _("User %{path} not authorized to use cron") % { path: @path }, detail.backtrace
-      else
-        raise FileReadError, _("Could not read crontab for %{path}: %{detail}") % { path: @path, detail: detail }, detail.backtrace
-      end
-    end
-
-    # Remove a specific @path's cron tab.
-    def remove
-      Puppet::Util::Execution.execute(%w{crontab -r}, cronargs)
-    rescue => detail
-      raise FileReadError, _("Could not remove crontab for %{path}: %{detail}") % { path: @path, detail: detail }, detail.backtrace
-    end
-
-    # Overwrite a specific @path's cron tab; must be passed the @path name
-    # and the text with which to create the cron tab.
-    def write(text)
-      # this file is managed by the OS and should be using system encoding
-      output_file = Tempfile.new("puppet_aixtab", :encoding => Encoding.default_external)
-
-      begin
-        output_file.print text
-        output_file.close
-        # We have to chown the stupid file to the user.
-        File.chown(Puppet::Util.uid(@path), nil, output_file.path)
-        Puppet::Util::Execution.execute(["crontab", output_file.path], cronargs)
-      rescue => detail
-        raise FileReadError, _("Could not write crontab for %{path}: %{detail}") % { path: @path, detail: detail }, detail.backtrace
-      ensure
-        output_file.close
-        output_file.unlink
-      end
-    end
-  end
-end

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

@@ -1,207 +0,0 @@
-require 'uri'
-require 'openssl'
-require 'puppet/network/http'
-
-module Puppet::Util::HttpProxy
-  def self.proxy(uri)
-    if self.no_proxy?(uri)
-      proxy_class = Net::HTTP::Proxy(nil)
-    else
-      proxy_class = Net::HTTP::Proxy(self.http_proxy_host, self.http_proxy_port, self.http_proxy_user, self.http_proxy_password)
-    end
-
-    return proxy_class.new(uri.host, uri.port)
-  end
-
-  def self.http_proxy_env
-    # Returns a URI object if proxy is set, or nil
-    proxy_env = ENV["http_proxy"] || ENV["HTTP_PROXY"]
-    begin
-      return URI.parse(proxy_env) if proxy_env
-    rescue URI::InvalidURIError
-      return nil
-    end
-    return nil
-  end
-
-  # The documentation around the format of the no_proxy variable seems
-  # inconsistent.  Some suggests the use of the * as a way of matching any
-  # hosts under a domain, e.g.:
-  #   *.example.com
-  # Other documentation suggests that just a leading '.' indicates a domain
-  # level exclusion, e.g.:
-  #   .example.com
-  # We'll accommodate both here.
-  def self.no_proxy?(dest)
-    unless no_proxy_env = ENV["no_proxy"] || ENV["NO_PROXY"]
-      return false
-    end
-
-    unless dest.is_a? URI
-      begin
-        dest = URI.parse(dest)
-      rescue URI::InvalidURIError
-        return false
-      end
-    end
-
-    no_proxy_env.split(/\s*,\s*/).each do |d|
-      host, port = d.split(':')
-      host = Regexp.escape(host).gsub('\*', '.*')
-
-      #If the host of this no_proxy value starts with '.', this entry is
-      #a domain level entry. Don't pin the regex to the beginning of the entry.
-      #If it does not start with a '.' then it is a host specific entry and
-      #should be matched to the destination starting at the beginning.
-      unless host =~ /^\\\./
-        host = "^#{host}"
-      end
-
-      #If this no_proxy entry specifies a port, we want to match it against
-      #the destination port.  Otherwise just match hosts.
-      if port
-        no_proxy_regex  = %r(#{host}:#{port}$)
-        dest_string     = "#{dest.host}:#{dest.port}"
-      else
-        no_proxy_regex  = %r(#{host}$)
-        dest_string     = "#{dest.host}"
-      end
-
-      if no_proxy_regex.match(dest_string)
-        return true
-      end
-    end
-
-    return false
-  end
-
-  def self.http_proxy_host
-    env = self.http_proxy_env
-
-    if env and env.host
-      return env.host
-    end
-
-    if Puppet.settings[:http_proxy_host] == 'none'
-      return nil
-    end
-
-    return Puppet.settings[:http_proxy_host]
-  end
-
-  def self.http_proxy_port
-    env = self.http_proxy_env
-
-    if env and env.port
-      return env.port
-    end
-
-    return Puppet.settings[:http_proxy_port]
-  end
-
-  def self.http_proxy_user
-    env = self.http_proxy_env
-
-    if env and env.user
-      return env.user
-    end
-
-    if Puppet.settings[:http_proxy_user] == 'none'
-      return nil
-    end
-
-    return Puppet.settings[:http_proxy_user]
-  end
-
-  def self.http_proxy_password
-    env = self.http_proxy_env
-
-    if env and env.password
-      return env.password
-    end
-
-    if Puppet.settings[:http_proxy_user] == 'none' or Puppet.settings[:http_proxy_password] == 'none'
-      return nil
-    end
-
-    return Puppet.settings[:http_proxy_password]
-  end
-
-  # Return a Net::HTTP::Proxy object.
-  #
-  # This method optionally configures SSL correctly if the URI scheme is
-  # 'https', including setting up the root certificate store so remote server
-  # SSL certificates can be validated.
-  #
-  # @param [URI] uri The URI that is to be accessed.
-  # @return [Net::HTTP::Proxy] object constructed tailored for the passed URI
-  def self.get_http_object(uri)
-    proxy = proxy(uri)
-
-    if uri.scheme == 'https'
-      cert_store = OpenSSL::X509::Store.new
-      cert_store.set_default_paths
-
-      proxy.use_ssl = true
-      proxy.verify_mode = OpenSSL::SSL::VERIFY_PEER
-      proxy.cert_store = cert_store
-    end
-
-    if Puppet[:http_debug]
-      proxy.set_debug_output($stderr)
-    end
-
-    proxy.open_timeout = Puppet[:http_connect_timeout]
-    proxy.read_timeout = Puppet[:http_read_timeout]
-
-    proxy
-  end
-
-  # Retrieve a document through HTTP(s), following redirects if necessary. The
-  # returned response body may be compressed, and it is the caller's
-  # responsibility to decompress it based on the 'content-encoding' header.
-  #
-  # Based on the the client implementation in the HTTP pool.
-  #
-  # @see Puppet::Network::HTTP::Connection#request_with_redirects
-  #
-  # @param [URI] uri The address of the resource to retrieve.
-  # @param [symbol] method The name of the Net::HTTP method to use, typically :get, :head, :post etc.
-  # @param [FixNum] redirect_limit The number of redirections that can be followed.
-  # @return [Net::HTTPResponse] a response object
-  def self.request_with_redirects(uri, method, redirect_limit = 10, &block)
-    current_uri = uri
-    response = nil
-
-    0.upto(redirect_limit) do |redirection|
-      proxy = get_http_object(current_uri)
-
-      headers = { 'Accept' => '*/*', 'User-Agent' => Puppet[:http_user_agent] }
-      if Puppet.features.zlib?
-        headers.merge!({"Accept-Encoding" => Puppet::Network::HTTP::Compression::ACCEPT_ENCODING})
-      end
-
-      response = proxy.send(:head, current_uri.path, headers)
-
-      if [301, 302, 307].include?(response.code.to_i)
-        # handle the redirection
-        current_uri = URI.parse(response['location'])
-        next
-      end
-
-      if method != :head
-        if block_given?
-          response = proxy.send("request_#{method}".to_sym, current_uri.path, headers, &block)
-        else
-          response = proxy.send(method, current_uri.path, headers)
-        end
-      end
-
-      Puppet.debug("HTTP #{method.to_s.upcase} request to #{current_uri} returned #{response.code} #{response.message}")
-
-      return response
-    end
-
-    raise RedirectionLimitExceededException, _("Too many HTTP redirections for %{uri}") % { uri: uri }
-  end
-end