puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/provider/confine_collection.rb

@@ -0,0 +1,50 @@
+# Manage a collection of confines, returning a boolean or
+# helpful information.
+require 'puppet/provider/confine'
+
+class Puppet::Provider::ConfineCollection
+  def confine(hash)
+    if hash.include?(:for_binary)
+      for_binary = true
+      hash.delete(:for_binary)
+    else
+      for_binary = false
+    end
+    hash.each do |test, values|
+      if klass = Puppet::Provider::Confine.test(test)
+        @confines << klass.new(values)
+        @confines[-1].for_binary = true if for_binary
+      else
+        confine = Puppet::Provider::Confine.test(:variable).new(values)
+        confine.name = test
+        @confines << confine
+      end
+      @confines[-1].label = self.label
+    end
+  end
+
+  attr_reader :label
+  def initialize(label)
+    @label = label
+    @confines = []
+  end
+
+  # Return a hash of the whole confine set, used for the Provider
+  # reference.
+  def summary
+    confines = Hash.new { |hash, key| hash[key] = [] }
+    @confines.each { |confine| confines[confine.class] << confine }
+    result = {}
+    confines.each do |klass, list|
+      value = klass.summarize(list)
+      next if (value.respond_to?(:length) and value.length == 0) or (value == 0)
+      result[klass.name] = value
+
+    end
+    result
+  end
+
+  def valid?
+    ! @confines.detect { |c| ! c.valid? }
+  end
+end

data/lib/vendor/puppet/provider/confiner.rb

@@ -0,0 +1,16 @@
+require 'puppet/provider/confine_collection'
+
+module Puppet::Provider::Confiner
+  def confine(hash)
+    confine_collection.confine(hash)
+  end
+
+  def confine_collection
+    @confine_collection ||= Puppet::Provider::ConfineCollection.new(self.to_s)
+  end
+
+  # Check whether this implementation is suitable for our platform.
+  def suitable?(short = true)
+    return(short ? confine_collection.valid? : confine_collection.summary)
+  end
+end

data/lib/vendor/puppet/provider/cron/crontab.rb

@@ -0,0 +1,200 @@
+require 'puppet/provider/parsedfile'
+
+tab = case Facter.value(:operatingsystem)
+  when "Solaris"
+    :suntab
+  when "AIX"
+    :aixtab
+  else
+    :crontab
+  end
+
+
+
+Puppet::Type.type(:cron).provide(:crontab, :parent => Puppet::Provider::ParsedFile, :default_target => ENV["USER"] || "root", :filetype => tab) 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+=}
+
+  record_line :freebsd_special, :fields => %w{special command},
+    :match => %r{^@(\w+)\s+(.+)$}, :pre_gen => proc { |record|
+      record[:special] = "@" + record[:special]
+    }
+
+  crontab = record_line :crontab, :fields => %w{minute hour monthday month weekday command},
+    :match => %r{^\s*(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(.+)$},
+    :optional => %w{minute hour weekday month monthday}, :absent => "*"
+
+  class << crontab
+    def numeric_fields
+      fields - [:command]
+    end
+    # Do some post-processing of the parsed record.  Basically just
+    # split the numeric fields on ','.
+    def post_parse(record)
+      numeric_fields.each do |field|
+        if val = record[field] and val != :absent
+          record[field] = record[field].split(",")
+        end
+      end
+    end
+
+    # Join the fields back up based on ','.
+    def pre_gen(record)
+      numeric_fields.each do |field|
+        if vals = record[field] and vals.is_a?(Array)
+          record[field] = vals.join(",")
+        end
+      end
+    end
+
+
+    # Add name and environments as necessary.
+    def to_line(record)
+      str = ""
+      str = "# Puppet Name: #{record[:name]}\n" if record[:name]
+      if record[:environment] and record[:environment] != :absent and record[:environment] != [:absent]
+        record[:environment].each do |env|
+          str += env + "\n"
+        end
+      end
+
+      if record[:special]
+        str += "@#{record[:special]} #{record[:command]}"
+      else
+        str += join(record)
+      end
+      str
+    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
+
+  # See if we can match the record against an existing cron job.
+  def self.match(record, resources)
+    resources.each do |name, resource|
+      # Match the command first, since it's the most important one.
+      next unless record[:target] == resource.value(:target)
+      next unless record[:command] == resource.value(:command)
+
+      # Then check the @special stuff
+      if record[:special]
+        next unless resource.value(:special) == record[:special]
+      end
+
+      # Then the normal fields.
+      matched = true
+      record_type(record[:record_type]).fields.each do |field|
+        next if field == :command
+        next if field == :special
+        if record[field] and ! resource.value(field)
+          #Puppet.info "Cron is missing %s: %s and %s" %
+          #    [field, record[field].inspect, resource.value(field).inspect]
+          matched = false
+          break
+        end
+
+        if ! record[field] and resource.value(field)
+          #Puppet.info "Hash is missing %s: %s and %s" %
+          #    [field, resource.value(field).inspect, record[field].inspect]
+          matched = false
+          break
+        end
+
+        # Yay differing definitions of absent.
+        next if (record[field] == :absent and resource.value(field) == "*")
+
+        # Everything should be in the form of arrays, not the normal text.
+        next if (record[field] == resource.value(field))
+        #Puppet.info "Did not match %s: %s vs %s" %
+        #    [field, resource.value(field).inspect, record[field].inspect]
+        matched = false
+        break
+      end
+      return resource if matched
+    end
+
+    false
+  end
+
+  # 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
+        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)
+    @property_hash[:user] = user
+    @property_hash[:target] = user
+  end
+
+  def user
+    @property_hash[:user] || @property_hash[:target]
+  end
+end
+

data/lib/vendor/puppet/provider/exec/posix.rb

@@ -0,0 +1,39 @@
+require 'puppet/provider/exec'
+
+Puppet::Type.type(:exec).provide :posix, :parent => Puppet::Provider::Exec do
+  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 !File.exists?(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]
+      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
+end

data/lib/vendor/puppet/provider/exec/shell.rb

@@ -0,0 +1,25 @@
+Puppet::Type.type(:exec).provide :shell, :parent => :posix do
+  include Puppet::Util::Execution
+
+  confine :feature => :posix
+
+  desc <<-EOT
+    Passes the provided command through `/bin/sh`; only available on
+    POSIX systems. This allows the use of shell globbing and built-ins, and
+    does not require that the path to a command be fully-qualified. Although
+    this can be more convenient than the `posix` provider, it also means that
+    you need to be more careful with escaping; as ever, with great power comes
+    etc. etc.
+
+    This provider closely resembles the behavior of the `exec` type
+    in Puppet 0.25.x.
+  EOT
+
+  def run(command, check = false)
+    super(['/bin/sh', '-c', command], check)
+  end
+
+  def validatecmd(command)
+    true
+  end
+end

data/lib/vendor/puppet/provider/exec/windows.rb

@@ -0,0 +1,56 @@
+require 'puppet/provider/exec'
+
+Puppet::Type.type(:exec).provide :windows, :parent => Puppet::Provider::Exec do
+  include Puppet::Util::Execution
+
+  confine    :operatingsystem => :windows
+  defaultfor :operatingsystem => :windows
+
+  desc <<-'EOT'
+    Execute external binaries on Windows systems. As with the `posix`
+    provider, this provider directly calls the command with the arguments
+    given, without passing it through a shell or performing any interpolation.
+    To use shell built-ins --- that is, to emulate the `shell` provider on
+    Windows --- a command must explicitly invoke the shell:
+
+        exec {'echo foo':
+          command => 'cmd.exe /c echo "foo"',
+        }
+
+    If no extension is specified for a command, Windows will use the `PATHEXT`
+    environment variable to locate the executable.
+
+    **Note on PowerShell scripts:** PowerShell's default `restricted`
+    execution policy doesn't allow it to run saved scripts. To run PowerShell
+    scripts, specify the `remotesigned` execution policy as part of the
+    command:
+
+        exec { 'test':
+          path    => 'C:/Windows/System32/WindowsPowerShell/v1.0',
+          command => 'powershell -executionpolicy remotesigned -file C:/test.ps1',
+        }
+
+  EOT
+
+  # Verify that we have the executable
+  def checkexe(command)
+    exe = extractexe(command)
+
+    if absolute_path?(exe)
+      if !File.exists?(exe)
+        raise ArgumentError, "Could not find command '#{exe}'"
+      elsif !File.file?(exe)
+        raise ArgumentError, "'#{exe}' is a #{File.ftype(exe)}, not a file"
+      end
+      return
+    end
+
+    if resource[:path]
+      withenv :PATH => resource[:path].join(File::PATH_SEPARATOR) do
+        return if which(exe)
+      end
+    end
+
+    raise ArgumentError, "Could not find command '#{exe}'"
+  end
+end

data/lib/vendor/puppet/provider/exec.rb

@@ -0,0 +1,84 @@
+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
+
+        withenv environment do
+          Timeout::timeout(resource[:timeout]) do
+            output, status = Puppet::Util::SUIDManager.
+              run_and_capture(command, resource[:user], resource[:group])
+          end
+          # The shell returns 127 if the command is missing.
+          if status.exitstatus == 127
+            raise ArgumentError, output
+          end
+        end
+      end
+    rescue Errno::ENOENT => detail
+      self.fail detail.to_s
+    end
+
+    return output, status
+  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/lib/vendor/puppet/provider/file/posix.rb

@@ -0,0 +1,135 @@
+Puppet::Type.type(:file).provide :posix do
+  desc "Uses POSIX functionality to manage file ownership and permissions."
+
+  confine :feature => :posix
+
+  include Puppet::Util::POSIX
+  include Puppet::Util::Warnings
+
+  require 'etc'
+
+  def uid2name(id)
+    return id.to_s if id.is_a?(Symbol) or id.is_a?(String)
+    return nil if id > Puppet[:maximum_uid].to_i
+
+    begin
+      user = Etc.getpwuid(id)
+    rescue TypeError, ArgumentError
+      return nil
+    end
+
+    if user.uid == ""
+      return nil
+    else
+      return user.name
+    end
+  end
+
+  # Determine if the user is valid, and if so, return the UID
+  def name2uid(value)
+    Integer(value) rescue uid(value) || false
+  end
+
+  def gid2name(id)
+    return id.to_s if id.is_a?(Symbol) or id.is_a?(String)
+    return nil if id > Puppet[:maximum_uid].to_i
+
+    begin
+      group = Etc.getgrgid(id)
+    rescue TypeError, ArgumentError
+      return nil
+    end
+
+    if group.gid == ""
+      return nil
+    else
+      return group.name
+    end
+  end
+
+  def name2gid(value)
+    Integer(value) rescue gid(value) || false
+  end
+
+  def owner
+    unless stat = resource.stat
+      return :absent
+    end
+
+    currentvalue = stat.uid
+
+    # On OS X, files that are owned by -2 get returned as really
+    # large UIDs instead of negative ones.  This isn't a Ruby bug,
+    # it's an OS X bug, since it shows up in perl, too.
+    if currentvalue > Puppet[:maximum_uid].to_i
+      self.warning "Apparently using negative UID (#{currentvalue}) on a platform that does not consistently handle them"
+      currentvalue = :silly
+    end
+
+    currentvalue
+  end
+
+  def owner=(should)
+    # Set our method appropriately, depending on links.
+    if resource[:links] == :manage
+      method = :lchown
+    else
+      method = :chown
+    end
+
+    begin
+      File.send(method, should, nil, resource[:path])
+    rescue => detail
+      raise Puppet::Error, "Failed to set owner to '#{should}': #{detail}"
+    end
+  end
+
+  def group
+    return :absent unless stat = resource.stat
+
+    currentvalue = stat.gid
+
+    # On OS X, files that are owned by -2 get returned as really
+    # large GIDs instead of negative ones.  This isn't a Ruby bug,
+    # it's an OS X bug, since it shows up in perl, too.
+    if currentvalue > Puppet[:maximum_uid].to_i
+      self.warning "Apparently using negative GID (#{currentvalue}) on a platform that does not consistently handle them"
+      currentvalue = :silly
+    end
+
+    currentvalue
+  end
+
+  def group=(should)
+    # Set our method appropriately, depending on links.
+    if resource[:links] == :manage
+      method = :lchown
+    else
+      method = :chown
+    end
+
+    begin
+      File.send(method, nil, should, resource[:path])
+    rescue => detail
+      raise Puppet::Error, "Failed to set group to '#{should}': #{detail}"
+    end
+  end
+
+  def mode
+    if stat = resource.stat
+      return (stat.mode & 007777).to_s(8)
+    else
+      return :absent
+    end
+  end
+
+  def mode=(value)
+    begin
+      File.chmod(value.to_i(8), resource[:path])
+    rescue => detail
+      error = Puppet::Error.new("failed to set mode #{mode} on #{resource[:path]}: #{detail.message}")
+      error.set_backtrace detail.backtrace
+      raise error
+    end
+  end
+end

data/lib/vendor/puppet/provider/file/windows.rb

@@ -0,0 +1,88 @@
+Puppet::Type.type(:file).provide :windows do
+  desc "Uses Microsoft Windows functionality to manage file ownership and permissions."
+
+  confine :operatingsystem => :windows
+
+  include Puppet::Util::Warnings
+
+  if Puppet.features.microsoft_windows?
+    require 'puppet/util/windows'
+    require 'puppet/util/adsi'
+    include Puppet::Util::Windows::Security
+  end
+
+  # Determine if the account is valid, and if so, return the UID
+  def name2id(value)
+    Puppet::Util::Windows::Security.name_to_sid(value)
+  end
+
+  # If it's a valid SID, get the name. Otherwise, it's already a name,
+  # so just return it.
+  def id2name(id)
+    if Puppet::Util::Windows::Security.valid_sid?(id)
+      Puppet::Util::Windows::Security.sid_to_name(id)
+    else
+      id
+    end
+  end
+
+  # We use users and groups interchangeably, so use the same methods for both
+  # (the type expects different methods, so we have to oblige).
+  alias :uid2name :id2name
+  alias :gid2name :id2name
+
+  alias :name2gid :name2id
+  alias :name2uid :name2id
+
+  def owner
+    return :absent unless resource.exist?
+    get_owner(resource[:path])
+  end
+
+  def owner=(should)
+    begin
+      set_owner(should, resource[:path])
+    rescue => detail
+      raise Puppet::Error, "Failed to set owner to '#{should}': #{detail}"
+    end
+  end
+
+  def group
+    return :absent unless resource.exist?
+    get_group(resource[:path])
+  end
+
+  def group=(should)
+    begin
+      set_group(should, resource[:path])
+    rescue => detail
+      raise Puppet::Error, "Failed to set group to '#{should}': #{detail}"
+    end
+  end
+
+  def mode
+    if resource.exist?
+      mode = get_mode(resource[:path])
+      mode ? mode.to_s(8) : :absent
+    else
+      :absent
+    end
+  end
+
+  def mode=(value)
+    begin
+      set_mode(value.to_i(8), resource[:path])
+    rescue => detail
+      error = Puppet::Error.new("failed to set mode #{mode} on #{resource[:path]}: #{detail.message}")
+      error.set_backtrace detail.backtrace
+      raise error
+    end
+    :file_changed
+  end
+
+  def validate
+    if [:owner, :group, :mode].any?{|p| resource[p]} and !supports_acl?(resource[:path])
+      resource.fail("Can only manage owner, group, and mode on filesystems that support Windows ACLs, such as NTFS")
+    end
+  end
+end