puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/provider/cisco.rb

@@ -0,0 +1,9 @@
+require 'puppet/util/network_device/cisco/device'
+require 'puppet/provider/network_device'
+
+# This is the base class of all prefetched cisco device providers
+class Puppet::Provider::Cisco < Puppet::Provider::NetworkDevice
+  def self.device(url)
+    Puppet::Util::NetworkDevice::Cisco::Device.new(url)
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/provider/command.rb

@@ -0,0 +1,25 @@
+# A command that can be executed on the system
+class Puppet::Provider::Command
+  attr_reader :executable
+  attr_reader :name
+
+  # @param [String] name A way of referencing the name
+  # @param [String] executable The path to the executable file
+  # @param resolver An object for resolving the executable to an absolute path (usually Puppet::Util)
+  # @param executor An object for performing the actual execution of the command (usually Puppet::Util::Execution)
+  # @param [Hash] options Extra options to be used when executing (see Puppet::Util::Execution#execute)
+  def initialize(name, executable, resolver, executor, options = {})
+    @name = name
+    @executable = executable
+    @resolver = resolver
+    @executor = executor
+    @options = options
+  end
+
+  # @param args [Array<String>] Any command line arguments to pass to the executable
+  # @return The output from the command
+  def execute(*args)
+    resolved_executable = @resolver.which(@executable) or raise Puppet::Error, "Command #{@name} is missing"
+    @executor.execute([resolved_executable] + args, @options)
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/provider/computer/computer.rb

@@ -0,0 +1,20 @@
+require 'puppet/provider/nameservice/directoryservice'
+
+Puppet::Type.type(:computer).provide :directoryservice, :parent => Puppet::Provider::NameService::DirectoryService do
+  desc "Computer object management using DirectoryService on OS X.
+  Note that these are distinctly different kinds of objects to 'hosts',
+  as they require a MAC address and can have all sorts of policy attached to
+  them.
+
+  This provider only manages Computer objects in the local directory service
+  domain, not in remote directories.
+
+  If you wish to manage /etc/hosts on Mac OS X, then simply use the host
+  type as per other platforms."
+
+  confine :operatingsystem => :darwin
+  defaultfor :operatingsystem => :darwin
+
+  # hurray for abstraction. The nameservice directoryservice provider can
+  # handle everything we need. super.
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/provider/confine.rb

@@ -0,0 +1,6 @@
+# Confines have been moved out of the provider as they are also used for other things.
+# This provides backwards compatibility for people still including this old location.
+require 'puppet/provider'
+require 'puppet/confine'
+
+Puppet::Provider::Confine = Puppet::Confine

data/vendor/gems/puppet-3.7.3/lib/puppet/provider/cron/crontab.rb

@@ -0,0 +1,260 @@
+require 'puppet/provider/parsedfile'
+
+Puppet::Type.type(:cron).provide(:crontab, :parent => Puppet::Provider::ParsedFile, :default_target => ENV["USER"] || "root") do
+  commands :crontab => "crontab"
+
+  text_line :comment, :match => %r{^\s*#}, :post_parse => proc { |record|
+    record[:name] = $1 if record[:line] =~ /Puppet Name: (.+)\s*$/
+  }
+
+  text_line :blank, :match => %r{^\s*$}
+
+  text_line :environment, :match => %r{^\s*\w+=}
+
+  def self.filetype
+  tabname = case Facter.value(:osfamily)
+            when "Solaris"
+              :suntab
+            when "AIX"
+              :aixtab
+            else
+              :crontab
+            end
+
+    Puppet::Util::FileType.filetype(tabname)
+  end
+
+  self::TIME_FIELDS = [:minute, :hour, :monthday, :month, :weekday]
+
+  record_line :crontab,
+    :fields     => %w{time command},
+    :match      => %r{^\s*(@\w+|\S+\s+\S+\s+\S+\s+\S+\s+\S+)\s+(.+)$},
+    :absent     => '*',
+    :block_eval => :instance do
+
+    def post_parse(record)
+      time = record.delete(:time)
+      if match = /@(\S+)/.match(time)
+        # is there another way to access the constant?
+        Puppet::Type::Cron::ProviderCrontab::TIME_FIELDS.each { |f| record[f] = :absent }
+        record[:special] = match.captures[0]
+      elsif match = /(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)/.match(time)
+        record[:special] = :absent
+        Puppet::Type::Cron::ProviderCrontab::TIME_FIELDS.zip(match.captures).each do |field,value|
+          if value == self.absent
+            record[field] = :absent
+          else
+            record[field] = value.split(",")
+          end
+        end
+      else
+        raise Puppet::Error, "Line got parsed as a crontab entry but cannot be handled. Please file a bug with the contents of your crontab"
+      end
+      record
+    end
+
+    def pre_gen(record)
+      if record[:special] and record[:special] != :absent
+        record[:special] = "@#{record[:special]}"
+      end
+
+      Puppet::Type::Cron::ProviderCrontab::TIME_FIELDS.each do |field|
+        if vals = record[field] and vals.is_a?(Array)
+          record[field] = vals.join(",")
+        end
+      end
+      record
+    end
+
+    def to_line(record)
+      str = ""
+      record[:name] = nil if record[:unmanaged]
+      str = "# Puppet Name: #{record[:name]}\n" if record[:name]
+      if record[:environment] and record[:environment] != :absent
+        str += record[:environment].map {|line| "#{line}\n"}.join('')
+      end
+      if record[:special] and record[:special] != :absent
+        fields = [:special, :command]
+      else
+        fields = Puppet::Type::Cron::ProviderCrontab::TIME_FIELDS + [:command]
+      end
+      str += record.values_at(*fields).map do |field|
+        if field.nil? or field == :absent
+          self.absent
+        else
+          field
+        end
+      end.join(self.joiner)
+      str
+    end
+  end
+
+  def create
+    if resource.should(:command) then
+      super
+    else
+      resource.err "no command specified, cannot create"
+    end
+  end
+
+  # Look up a resource with a given name whose user matches a record target
+  #
+  # @api private
+  #
+  # @note This overrides the ParsedFile method for finding resources by name,
+  #   so that only records for a given user are matched to resources of the
+  #   same user so that orphaned records in other crontabs don't get falsely
+  #   matched (#2251)
+  #
+  # @param [Hash<Symbol, Object>] record
+  # @param [Array<Puppet::Resource>] resources
+  #
+  # @return [Puppet::Resource, nil] The resource if found, else nil
+  def self.resource_for_record(record, resources)
+    resource = super
+
+    if resource
+      target = resource[:target] || resource[:user]
+      if record[:target] == target
+        resource
+      end
+    end
+  end
+
+  # Return the header placed at the top of each generated file, warning
+  # users that modifying this file manually is probably a bad idea.
+  def self.header
+%{# HEADER: This file was autogenerated at #{Time.now} by puppet.
+# HEADER: While it can still be managed manually, it is definitely not recommended.
+# HEADER: Note particularly that the comments starting with 'Puppet Name' should
+# HEADER: not be deleted, as doing so could cause duplicate cron jobs.\n}
+  end
+
+  # Regex for finding one vixie cron header.
+  def self.native_header_regex
+    /# DO NOT EDIT THIS FILE.*?Cron version.*?vixie.*?\n/m
+  end
+
+  # If a vixie cron header is found, it should be dropped, cron will insert
+  # a new one in any case, so we need to avoid duplicates.
+  def self.drop_native_header
+    true
+  end
+
+  # See if we can match the record against an existing cron job.
+  def self.match(record, resources)
+    # if the record is named, do not even bother (#19876)
+    # except the resource name was implicitly generated (#3220)
+    return false if record[:name] and !record[:unmanaged]
+    resources.each do |name, resource|
+      # Match the command first, since it's the most important one.
+      next unless record[:target] == resource[:target]
+      next unless record[:command] == resource.value(:command)
+
+      # Now check the time fields
+      compare_fields = self::TIME_FIELDS + [:special]
+
+      matched = true
+      compare_fields.each do |field|
+        # If the resource does not manage a property (say monthday) it should
+        # always match. If it is the other way around (e.g. resource defines
+        # a should value for :special but the record does not have it, we do
+        # not match
+        next unless resource[field]
+        unless record.include?(field)
+          matched = false
+          break
+        end
+
+        if record_value = record[field] and resource_value = resource.value(field)
+          # The record translates '*' into absent in the post_parse hook and
+          # the resource type does exactly the opposite (alias :absent to *)
+          next if resource_value == '*' and record_value == :absent
+          next if resource_value == record_value
+        end
+        matched =false
+        break
+      end
+      return resource if matched
+    end
+    false
+  end
+
+  @name_index = 0
+
+  # Collapse name and env records.
+  def self.prefetch_hook(records)
+    name = nil
+    envs = nil
+    result = records.each { |record|
+      case record[:record_type]
+      when :comment
+        if record[:name]
+          name = record[:name]
+          record[:skip] = true
+
+          # Start collecting env values
+          envs = []
+        end
+      when :environment
+        # If we're collecting env values (meaning we're in a named cronjob),
+        # store the line and skip the record.
+        if envs
+          envs << record[:line]
+          record[:skip] = true
+        end
+      when :blank
+        # nothing
+      else
+        if name
+          record[:name] = name
+          name = nil
+        else
+          cmd_string = record[:command].gsub(/\s+/, "_")
+          index = ( @name_index += 1 )
+          record[:name] = "unmanaged:#{cmd_string}-#{ index.to_s }"
+          record[:unmanaged] = true
+        end
+        if envs.nil? or envs.empty?
+          record[:environment] = :absent
+        else
+          # Collect all of the environment lines, and mark the records to be skipped,
+          # since their data is included in our crontab record.
+          record[:environment] = envs
+
+          # And turn off env collection again
+          envs = nil
+        end
+      end
+    }.reject { |record| record[:skip] }
+    result
+  end
+
+  def self.to_file(records)
+    text = super
+    # Apparently Freebsd will "helpfully" add a new TZ line to every
+    # single cron line, but not in all cases (e.g., it doesn't do it
+    # on my machine).  This is my attempt to fix it so the TZ lines don't
+    # multiply.
+    if text =~ /(^TZ=.+\n)/
+      tz = $1
+      text.sub!(tz, '')
+      text = tz + text
+    end
+    text
+  end
+
+  def user=(user)
+    # we have to mark the target as modified first, to make sure that if
+    # we move a cronjob from userA to userB, userA's crontab will also
+    # be rewritten
+    mark_target_modified
+    @property_hash[:user] = user
+    @property_hash[:target] = user
+  end
+
+  def user
+    @property_hash[:user] || @property_hash[:target]
+  end
+end
+

data/vendor/gems/puppet-3.7.3/lib/puppet/provider/exec.rb

@@ -0,0 +1,100 @@
+require 'puppet/provider'
+require 'puppet/util/execution'
+
+class Puppet::Provider::Exec < Puppet::Provider
+  include Puppet::Util::Execution
+
+  def run(command, check = false)
+    output = nil
+    status = nil
+    dir = nil
+
+    checkexe(command)
+
+    if dir = resource[:cwd]
+      unless File.directory?(dir)
+        if check
+          dir = nil
+        else
+          self.fail "Working directory '#{dir}' does not exist"
+        end
+      end
+    end
+
+    dir ||= Dir.pwd
+
+    debug "Executing#{check ? " check": ""} '#{command}'"
+    begin
+      # Do our chdir
+      Dir.chdir(dir) do
+        environment = {}
+
+        environment[:PATH] = resource[:path].join(File::PATH_SEPARATOR) if resource[:path]
+
+        if envlist = resource[:environment]
+          envlist = [envlist] unless envlist.is_a? Array
+          envlist.each do |setting|
+            if setting =~ /^(\w+)=((.|\n)+)$/
+              env_name = $1
+              value = $2
+              if environment.include?(env_name) || environment.include?(env_name.to_sym)
+                warning "Overriding environment setting '#{env_name}' with '#{value}'"
+              end
+              environment[env_name] = value
+            else
+              warning "Cannot understand environment setting #{setting.inspect}"
+            end
+          end
+        end
+
+        if Puppet.features.microsoft_windows?
+          exec_user = resource[:user]
+        # Etc.getpwuid() returns nil on Windows
+        elsif resource.current_username == resource[:user]
+          exec_user = nil
+        else
+          exec_user = resource[:user]
+        end
+
+        Timeout::timeout(resource[:timeout]) do
+          # note that we are passing "false" for the "override_locale" parameter, which ensures that the user's
+          # default/system locale will be respected.  Callers may override this behavior by setting locale-related
+          # environment variables (LANG, LC_ALL, etc.) in their 'environment' configuration.
+          output = Puppet::Util::Execution.execute(command, :failonfail => false, :combine => true,
+                                  :uid => exec_user, :gid => resource[:group],
+                                  :override_locale => false,
+                                  :custom_environment => environment)
+        end
+        # The shell returns 127 if the command is missing.
+        if output.exitstatus == 127
+          raise ArgumentError, output
+        end
+
+      end
+    rescue Errno::ENOENT => detail
+      self.fail Puppet::Error, detail.to_s, detail
+    end
+
+    # Return output twice as processstatus was returned before, but only exitstatus was ever called.
+    # Output has the exitstatus on it so it is returned instead. This is here twice as changing this
+    #  would result in a change to the underlying API.
+    return output, output
+  end
+
+  def extractexe(command)
+    if command.is_a? Array
+      command.first
+    elsif match = /^"([^"]+)"|^'([^']+)'/.match(command)
+      # extract whichever of the two sides matched the content.
+      match[1] or match[2]
+    else
+      command.split(/ /)[0]
+    end
+  end
+
+  def validatecmd(command)
+    exe = extractexe(command)
+    # if we're not fully qualified, require a path
+    self.fail "'#{command}' is not qualified and no path was specified. Please qualify the command or specify a path." if !absolute_path?(exe) and resource[:path].nil?
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/provider/exec/posix.rb

@@ -0,0 +1,48 @@
+require 'puppet/provider/exec'
+
+Puppet::Type.type(:exec).provide :posix, :parent => Puppet::Provider::Exec do
+  has_feature :umask
+  confine :feature => :posix
+  defaultfor :feature => :posix
+
+  desc <<-EOT
+    Executes external binaries directly, without passing through a shell or
+    performing any interpolation. This is a safer and more predictable way
+    to execute most commands, but prevents the use of globbing and shell
+    built-ins (including control logic like "for" and "if" statements).
+  EOT
+
+  # Verify that we have the executable
+  def checkexe(command)
+    exe = extractexe(command)
+
+    if File.expand_path(exe) == exe
+      if !Puppet::FileSystem.exist?(exe)
+        raise ArgumentError, "Could not find command '#{exe}'"
+      elsif !File.file?(exe)
+        raise ArgumentError, "'#{exe}' is a #{File.ftype(exe)}, not a file"
+      elsif !File.executable?(exe)
+        raise ArgumentError, "'#{exe}' is not executable"
+      end
+      return
+    end
+
+    if resource[:path]
+      Puppet::Util.withenv :PATH => resource[:path].join(File::PATH_SEPARATOR) do
+        return if which(exe)
+      end
+    end
+
+    # 'which' will only return the command if it's executable, so we can't
+    # distinguish not found from not executable
+    raise ArgumentError, "Could not find command '#{exe}'"
+  end
+
+  def run(command, check = false)
+    if resource[:umask]
+      Puppet::Util::withumask(resource[:umask]) { super(command, check) }
+    else
+      super(command, check)
+    end
+  end
+end