puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/provider/mcx/mcxcontent.rb

@@ -0,0 +1,172 @@
+require 'tempfile'
+
+Puppet::Type.type(:mcx).provide :mcxcontent, :parent => Puppet::Provider do
+
+  desc "MCX Settings management using DirectoryService on OS X.
+
+  This provider manages the entire MCXSettings attribute available
+  to some directory services nodes.  This management is 'all or nothing'
+  in that discrete application domain key value pairs are not managed
+  by this provider.
+
+  It is recommended to use WorkGroup Manager to configure Users, Groups,
+  Computers, or ComputerLists, then use 'ralsh mcx' to generate a puppet
+  manifest from the resulting configuration.
+
+  Original Author: Jeff McCune (mccune.jeff@gmail.com)
+
+"
+
+  # This provides a mapping of puppet types to DirectoryService
+  # type strings.
+  TypeMap = {
+    :user => "Users",
+    :group => "Groups",
+    :computer => "Computers",
+    :computerlist => "ComputerLists",
+  }
+
+  class MCXContentProviderException < Exception
+
+  end
+
+  commands :dscl => "/usr/bin/dscl"
+  confine :operatingsystem => :darwin
+  defaultfor :operatingsystem => :darwin
+
+  def self.instances
+    mcx_list = []
+    TypeMap.keys.each do |ds_type|
+      ds_path = "/Local/Default/#{TypeMap[ds_type]}"
+      output = dscl 'localhost', '-list', ds_path
+      member_list = output.split
+      member_list.each do |ds_name|
+        content = mcxexport(ds_type, ds_name)
+        if content.empty?
+          Puppet.debug "/#{TypeMap[ds_type]}/#{ds_name} has no MCX data."
+        else
+          # This node has MCX data.
+
+          mcx_list << self.new(
+            :name => "/#{TypeMap[ds_type]}/#{ds_name}",
+            :ds_type => ds_type,
+            :ds_name => ds_name,
+            :content => content
+          )
+        end
+      end
+    end
+    mcx_list
+  end
+
+  def self.mcxexport(ds_type, ds_name)
+    ds_t = TypeMap[ds_type]
+    ds_n = ds_name.to_s
+    ds_path = "/Local/Default/#{ds_t}/#{ds_n}"
+    dscl 'localhost', '-mcxexport', ds_path
+  end
+
+
+  def create
+    self.content=(resource[:content])
+  end
+
+  def destroy
+    ds_parms = get_dsparams
+    ds_t = TypeMap[ds_parms[:ds_type]]
+    ds_n = ds_parms[:ds_name].to_s
+    ds_path = "/Local/Default/#{ds_t}/#{ds_n}"
+
+    dscl 'localhost', '-mcxdelete', ds_path
+  end
+
+  def exists?
+    begin
+      has_mcx?
+    rescue Puppet::ExecutionFailure
+      return false
+    end
+  end
+
+  def content
+    ds_parms = get_dsparams
+
+    self.class.mcxexport(ds_parms[:ds_type], ds_parms[:ds_name])
+  end
+
+  def content=(value)
+    # dscl localhost -mcximport
+    ds_parms = get_dsparams
+
+    mcximport(ds_parms[:ds_type], ds_parms[:ds_name], resource[:content])
+  end
+
+  private
+
+  def has_mcx?
+    !content.empty?
+  end
+
+  def mcximport(ds_type, ds_name, val)
+    ds_t = TypeMap[ds_type]
+    ds_path = "/Local/Default/#{ds_t}/#{ds_name}"
+
+    if has_mcx?
+      Puppet.debug "Removing MCX from #{ds_path}"
+      dscl 'localhost', '-mcxdelete', ds_path
+    end
+
+    tmp = Tempfile.new('puppet_mcx')
+    begin
+      tmp << val
+      tmp.flush
+      Puppet.debug "Importing MCX into #{ds_path}"
+      dscl 'localhost', '-mcximport', ds_path, tmp.path
+    ensure
+      tmp.close
+      tmp.unlink
+    end
+  end
+
+  # Given the resource name string, parse ds_type out.
+  def parse_type(name)
+    ds_type = name.split('/')[1]
+    unless ds_type
+      raise MCXContentProviderException,
+      "Coult not parse ds_type from resource name '#{name}'.  Specify with ds_type parameter."
+    end
+    # De-pluralize and downcase.
+    ds_type = ds_type.chop.downcase.to_sym
+    unless TypeMap.key? ds_type
+      raise MCXContentProviderException,
+      "Coult not parse ds_type from resource name '#{name}'.  Specify with ds_type parameter."
+    end
+    ds_type
+  end
+
+  # Given the resource name string, parse ds_name out.
+  def parse_name(name)
+    ds_name = name.split('/')[2]
+    unless ds_name
+      raise MCXContentProviderException,
+      "Could not parse ds_name from resource name '#{name}'.  Specify with ds_name parameter."
+    end
+    ds_name
+  end
+
+  # Gather ds_type and ds_name from resource or parse it out of the name.
+  def get_dsparams
+    ds_type = resource[:ds_type]
+    ds_type ||= parse_type(resource[:name])
+    raise MCXContentProviderException unless TypeMap.keys.include? ds_type.to_sym
+
+    ds_name = resource[:ds_name]
+    ds_name ||= parse_name(resource[:name])
+
+    {
+      :ds_type => ds_type.to_sym,
+      :ds_name => ds_name,
+    }
+  end
+
+end

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

@@ -0,0 +1,58 @@
+require 'puppet'
+
+# A module just to store the mount/unmount methods.  Individual providers
+# still need to add the mount commands manually.
+module Puppet::Provider::Mount
+  # This only works when the mount point is synced to the fstab.
+  def mount
+    args = []
+
+    # In general we do not have to pass mountoptions because we always
+    # flush /etc/fstab before attempting to mount. But old code suggests
+    # that MacOS always needs the mount options to be explicitly passed to
+    # the mount command
+    if Facter.value(:kernel) == 'Darwin'
+      args << "-o" << self.options if self.options and self.options != :absent
+    end
+    args << resource[:name]
+
+    mountcmd(*args)
+    case get(:ensure)
+    when :absent; set(:ensure => :ghost)
+    when :unmounted; set(:ensure => :mounted)
+    end
+  end
+
+  def remount
+    info "Remounting"
+    if resource[:remounts] == :true
+      mountcmd "-o", "remount", resource[:name]
+    elsif ["FreeBSD", "DragonFly", "OpenBSD"].include?(Facter.value(:operatingsystem))
+      if self.options && !self.options.empty?
+        options = self.options + ",update"
+      else
+        options = "update"
+      end
+      mountcmd "-o", options, resource[:name]
+    else
+      unmount
+      mount
+    end
+  end
+
+  # This only works when the mount point is synced to the fstab.
+  def unmount
+    umount(resource[:name])
+
+    # Update property hash for future queries (e.g. refresh is called)
+    case get(:ensure)
+    when :mounted; set(:ensure => :unmounted)
+    when :ghost; set(:ensure => :absent)
+    end
+  end
+
+  # Is the mount currently mounted?
+  def mounted?
+    [:mounted, :ghost].include?(get(:ensure))
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/provider/mount/parsed.rb

@@ -0,0 +1,123 @@
+require 'puppet/provider/parsedfile'
+require 'puppet/provider/mount'
+
+fstab = nil
+case Facter.value(:osfamily)
+when "Solaris"; fstab = "/etc/vfstab"
+else
+  fstab = "/etc/fstab"
+end
+
+Puppet::Type.type(:mount).provide(
+  :parsed,
+  :parent => Puppet::Provider::ParsedFile,
+  :default_target => fstab,
+  :filetype => :flat
+) do
+  include Puppet::Provider::Mount
+
+  commands :mountcmd => "mount", :umount => "umount"
+
+  case Facter.value(:osfamily)
+  when "Solaris"
+    @fields = [:device, :blockdevice, :name, :fstype, :pass, :atboot, :options]
+  else
+    @fields = [:device, :name, :fstype, :options, :dump, :pass]
+  end
+
+  text_line :comment, :match => /^\s*#/
+  text_line :blank, :match => /^\s*$/
+
+  optional_fields  = @fields - [:device, :name, :blockdevice]
+  mandatory_fields = @fields - optional_fields
+
+  # fstab will ignore lines that have fewer than the mandatory number of columns,
+  # so we should, too.
+  field_pattern = '(\s*(?>\S+))'
+  text_line :incomplete, :match => /^(?!#{field_pattern}{#{mandatory_fields.length}})/
+
+  record_line self.name, :fields => @fields, :separator => /\s+/, :joiner => "\t", :optional => optional_fields
+
+  # Every entry in fstab is :unmounted until we can prove different
+  def self.prefetch_hook(target_records)
+    target_records.collect do |record|
+      record[:ensure] = :unmounted if record[:record_type] == :parsed
+      record
+    end
+  end
+
+  def self.instances
+    providers = super
+    mounts = mountinstances.dup
+
+    # Update fstab entries that are mounted
+    providers.each do |prov|
+      if mounts.delete({:name => prov.get(:name), :mounted => :yes}) then
+        prov.set(:ensure => :mounted)
+      end
+    end
+
+    # Add mounts that are not in fstab but mounted
+    mounts.each do |mount|
+      providers << new(:ensure => :ghost, :name => mount[:name])
+    end
+    providers
+  end
+
+  def self.prefetch(resources = nil)
+    # Get providers for all resources the user defined and that match
+    # a record in /etc/fstab.
+    super
+    # We need to do two things now:
+    # - Update ensure from :unmounted to :mounted if the resource is mounted
+    # - Check for mounted devices that are not in fstab and
+    #   set ensure to :ghost (if the user wants to add an entry
+    #   to fstab we need to know if the device was mounted before)
+    mountinstances.each do |hash|
+      if mount = resources[hash[:name]]
+        case mount.provider.get(:ensure)
+        when :absent  # Mount not in fstab
+          mount.provider.set(:ensure => :ghost)
+        when :unmounted # Mount in fstab
+          mount.provider.set(:ensure => :mounted)
+        end
+      end
+    end
+  end
+
+  def self.mountinstances
+    # XXX: Will not work for mount points that have spaces in path (does fstab support this anyways?)
+    regex = case Facter.value(:osfamily)
+      when "Darwin"
+        / on (?:\/private\/var\/automount)?(\S*)/
+      when "Solaris", "HP-UX"
+        /^(\S*) on /
+      when "AIX"
+        /^(?:\S*\s+\S+\s+)(\S+)/
+      else
+        / on (\S*)/
+    end
+    instances = []
+    mount_output = mountcmd.split("\n")
+    if mount_output.length >= 2 and mount_output[1] =~ /^[- \t]*$/
+      # On some OSes (e.g. AIX) mount output begins with a header line
+      # followed by a line consisting of dashes and whitespace.
+      # Discard these two lines.
+      mount_output[0..1] = []
+    end
+    mount_output.each do |line|
+      if match = regex.match(line) and name = match.captures.first
+        instances << {:name => name, :mounted => :yes} # Only :name is important here
+      else
+        raise Puppet::Error, "Could not understand line #{line} from mount output"
+      end
+    end
+    instances
+  end
+
+  def flush
+    needs_mount = @property_hash.delete(:needs_mount)
+    super
+    mount if needs_mount
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'puppet'
+require 'puppet/provider/parsedfile'
+require 'puppet/external/nagios'
+
+# The base class for all Naginator providers.
+class Puppet::Provider::Naginator < Puppet::Provider::ParsedFile
+  NAME_STRING = "## --PUPPET_NAME-- (called '_naginator_name' in the manifest)"
+  # Retrieve the associated class from Nagios::Base.
+  def self.nagios_type
+    unless @nagios_type
+      name = resource_type.name.to_s.sub(/^nagios_/, '')
+      unless @nagios_type = Nagios::Base.type(name.to_sym)
+        raise Puppet::DevError, "Could not find nagios type '#{name}'"
+      end
+
+      # And add our 'ensure' settings, since they aren't a part of
+      # Naginator by default
+      @nagios_type.send(:attr_accessor, :ensure, :target, :on_disk)
+    end
+    @nagios_type
+  end
+
+  def self.parse(text)
+      Nagios::Parser.new.parse(text.gsub(NAME_STRING, "_naginator_name"))
+  rescue => detail
+      raise Puppet::Error, "Could not parse configuration for #{resource_type.name}: #{detail}", detail.backtrace
+  end
+
+  def self.to_file(records)
+    header + records.collect { |record|
+        # Remap the TYPE_name or _naginator_name params to the
+        # name if the record is a template (register == 0)
+        if record.to_s =~ /register\s+0/
+            record.to_s.sub("_naginator_name", "name").sub(record.type.to_s + "_name", "name")
+        else
+            record.to_s.sub("_naginator_name", NAME_STRING)
+        end
+    }.join("\n")
+  end
+
+  def self.skip_record?(record)
+    false
+  end
+
+  def self.valid_attr?(klass, attr_name)
+    nagios_type.parameters.include?(attr_name)
+  end
+
+  def initialize(resource = nil)
+    if resource.is_a?(Nagios::Base)
+      # We don't use a duplicate here, because some providers (ParsedFile, at least)
+      # use the hash here for later events.
+      @property_hash = resource
+    elsif resource
+      @resource = resource if resource
+      # LAK 2007-05-09: Keep the model stuff around for backward compatibility
+      @model = resource
+      @property_hash = self.class.nagios_type.new
+    else
+      @property_hash = self.class.nagios_type.new
+    end
+  end
+end

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

@@ -0,0 +1,292 @@
+require 'puppet'
+
+# This is the parent class of all NSS classes.  They're very different in
+# their backend, but they're pretty similar on the front-end.  This class
+# provides a way for them all to be as similar as possible.
+class Puppet::Provider::NameService < Puppet::Provider
+  class << self
+    def autogen_default(param)
+      defined?(@autogen_defaults) ? @autogen_defaults[param.intern] : nil
+    end
+
+    def autogen_defaults(hash)
+      @autogen_defaults ||= {}
+      hash.each do |param, value|
+        @autogen_defaults[param.intern] = value
+      end
+    end
+
+    def initvars
+      @checks = {}
+      @options = {}
+      super
+    end
+
+    def instances
+      objects = []
+      listbyname do |name|
+        objects << new(:name => name, :ensure => :present)
+      end
+
+      objects
+    end
+
+    def option(name, option)
+      name = name.intern if name.is_a? String
+      (defined?(@options) and @options.include? name and @options[name].include? option) ? @options[name][option] : nil
+    end
+
+    def options(name, hash)
+      raise Puppet::DevError, "#{name} is not a valid attribute for #{resource_type.name}" unless resource_type.valid_parameter?(name)
+      @options ||= {}
+      @options[name] ||= {}
+
+      # Set options individually, so we can call the options method
+      # multiple times.
+      hash.each do |param, value|
+        @options[name][param] = value
+      end
+    end
+
+    # List everything out by name.  Abstracted a bit so that it works
+    # for both users and groups.
+    def listbyname
+      names = []
+      Etc.send("set#{section()}ent")
+      begin
+        while ent = Etc.send("get#{section()}ent")
+          names << ent.name
+          yield ent.name if block_given?
+        end
+      ensure
+        Etc.send("end#{section()}ent")
+      end
+
+      names
+    end
+
+    def resource_type=(resource_type)
+      super
+      @resource_type.validproperties.each do |prop|
+        next if prop == :ensure
+        define_method(prop) { get(prop) || :absent} unless public_method_defined?(prop)
+        define_method(prop.to_s + "=") { |*vals| set(prop, *vals) } unless public_method_defined?(prop.to_s + "=")
+      end
+    end
+
+    # This is annoying, but there really aren't that many options,
+    # and this *is* built into Ruby.
+    def section
+      unless resource_type
+        raise Puppet::DevError,
+          "Cannot determine Etc section without a resource type"
+      end
+
+      if @resource_type.name == :group
+        "gr"
+      else
+        "pw"
+      end
+    end
+
+    def validate(name, value)
+      name = name.intern if name.is_a? String
+      if @checks.include? name
+        block = @checks[name][:block]
+        raise ArgumentError, "Invalid value #{value}: #{@checks[name][:error]}" unless block.call(value)
+      end
+    end
+
+    def verify(name, error, &block)
+      name = name.intern if name.is_a? String
+      @checks[name] = {:error => error, :block => block}
+    end
+
+    private
+
+    def op(property)
+      @ops[property.name] || ("-#{property.name}")
+    end
+  end
+
+  # Autogenerate a value.  Mostly used for uid/gid, but also used heavily
+  # with DirectoryServices, because DirectoryServices is stupid.
+  def autogen(field)
+    field = field.intern
+    id_generators = {:user => :uid, :group => :gid}
+    if id_generators[@resource.class.name] == field
+      return self.class.autogen_id(field, @resource.class.name)
+    else
+      if value = self.class.autogen_default(field)
+        return value
+      elsif respond_to?("autogen_#{field}")
+        return send("autogen_#{field}")
+      else
+        return nil
+      end
+    end
+  end
+
+  # Autogenerate either a uid or a gid.  This is not very flexible: we can
+  # only generate one field type per class, and get kind of confused if asked
+  # for both.
+  def self.autogen_id(field, resource_type)
+    # Figure out what sort of value we want to generate.
+    case resource_type
+    when :user;   database = :passwd;  method = :uid
+    when :group;  database = :group;   method = :gid
+    else
+      raise Puppet::DevError, "Invalid resource name #{resource}"
+    end
+
+    # Initialize from the data set, if needed.
+    unless @prevauto
+      # Sadly, Etc doesn't return an enumerator, it just invokes the block
+      # given, or returns the first record from the database.  There is no
+      # other, more convenient enumerator for these, so we fake one with this
+      # loop.  Thanks, Ruby, for your awesome abstractions. --daniel 2012-03-23
+      highest = []
+      Etc.send(database) {|entry| highest << entry.send(method) }
+      highest = highest.reject {|x| x > 65000 }.max
+
+      @prevauto = highest || 1000
+    end
+
+    # ...and finally increment and return the next value.
+    @prevauto += 1
+  end
+
+  def create
+    if exists?
+      info "already exists"
+      # The object already exists
+      return nil
+    end
+
+    begin
+      execute(self.addcmd, {:failonfail => true, :combine => true, :custom_environment => @custom_environment})
+      if feature?(:manages_password_age) && (cmd = passcmd)
+        execute(cmd)
+      end
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error, "Could not create #{@resource.class.name} #{@resource.name}: #{detail}", detail.backtrace
+    end
+  end
+
+  def delete
+    unless exists?
+      info "already absent"
+      # the object already doesn't exist
+      return nil
+    end
+
+    begin
+      execute(self.deletecmd)
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error, "Could not delete #{@resource.class.name} #{@resource.name}: #{detail}", detail.backtrace
+    end
+  end
+
+  def ensure
+    if exists?
+      :present
+    else
+      :absent
+    end
+  end
+
+  # Does our object exist?
+  def exists?
+    !!getinfo(true)
+  end
+
+  # Retrieve a specific value by name.
+  def get(param)
+    (hash = getinfo(false)) ? unmunge(param, hash[param]) : nil
+  end
+
+  def munge(name, value)
+    if block = self.class.option(name, :munge) and block.is_a? Proc
+      block.call(value)
+    else
+      value
+    end
+  end
+
+  def unmunge(name, value)
+    if block = self.class.option(name, :unmunge) and block.is_a? Proc
+      block.call(value)
+    else
+      value
+    end
+  end
+
+  # Retrieve what we can about our object
+  def getinfo(refresh)
+    if @objectinfo.nil? or refresh == true
+      @etcmethod ||= ("get" + self.class.section.to_s + "nam").intern
+      begin
+        @objectinfo = Etc.send(@etcmethod, @resource[:name])
+      rescue ArgumentError
+        @objectinfo = nil
+      end
+    end
+
+    # Now convert our Etc struct into a hash.
+    @objectinfo ? info2hash(@objectinfo) : nil
+  end
+
+  # The list of all groups the user is a member of.  Different
+  # user mgmt systems will need to override this method.
+  def groups
+    groups = []
+
+    # Reset our group list
+    Etc.setgrent
+
+    user = @resource[:name]
+
+    # Now iterate across all of the groups, adding each one our
+    # user is a member of
+    while group = Etc.getgrent
+      members = group.mem
+
+      groups << group.name if members.include? user
+    end
+
+    # We have to close the file, so each listing is a separate
+    # reading of the file.
+    Etc.endgrent
+
+    groups.join(",")
+  end
+
+  # Convert the Etc struct into a hash.
+  def info2hash(info)
+    hash = {}
+    self.class.resource_type.validproperties.each do |param|
+      method = posixmethod(param)
+      hash[param] = info.send(posixmethod(param)) if info.respond_to? method
+    end
+
+    hash
+  end
+
+  def initialize(resource)
+    super
+    @custom_environment = {}
+    @objectinfo = nil
+  end
+
+  def set(param, value)
+    self.class.validate(param, value)
+    cmd = modifycmd(param, munge(param, value))
+    raise Puppet::DevError, "Nameservice command must be an array" unless cmd.is_a?(Array)
+    begin
+      execute(cmd)
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error, "Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}", detail.backtrace
+    end
+  end
+end
+