puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

data/lib/puppet/provider/mailalias/aliases.rb

@@ -1,50 +0,0 @@
-require 'puppet/provider/parsedfile'
-
-Puppet::Type.type(:mailalias).provide(
-  :aliases,
-  :parent => Puppet::Provider::ParsedFile,
-  :default_target => "/etc/aliases",
-  :filetype => :flat
-) do
-  text_line :comment, :match => /^#/
-  text_line :blank, :match => /^\s*$/
-
-  record_line :aliases, :fields => %w{name recipient}, :separator => /\s*:\s*/, :block_eval => :instance do
-    def post_parse(record)
-      if record[:recipient]
-        record[:recipient] = record[:recipient].split(/\s*,\s*(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/).collect { |d| d.gsub(/^['"]|['"]$/, '') }
-      end
-      record
-    end
-
-    def process(line)
-      ret = {}
-      records = line.split(':',4)
-      ret[:name] = records[0].strip
-      if records.length == 4 and records[2].strip == 'include'
-	ret[:file] = records[3].strip
-      else
-	records = line.split(':',2)
-	ret[:recipient] = records[1].strip
-      end
-      ret
-    end
-
-    def to_line(record)
-      if record[:recipient]
-	dest = record[:recipient].collect do |d|
-	  # Quote aliases that have non-alpha chars
-	  if d =~ /[^-+\w@.]/
-	    '"%s"' % d
-	  else
-	    d
-	  end
-	end.join(",")
-	"#{record[:name]}: #{dest}"
-      elsif record[:file]
-	"#{record[:name]}: :include: #{record[:file]}"
-      end
-    end
-  end
-end
-

data/lib/puppet/provider/maillist/mailman.rb

@@ -1,108 +0,0 @@
-require 'puppet/provider/parsedfile'
-
-Puppet::Type.type(:maillist).provide(:mailman) do
-  if [ "CentOS", "RedHat", "Fedora" ].any? { |os|  Facter.value(:operatingsystem) == os }
-    commands :list_lists => "/usr/lib/mailman/bin/list_lists", :rmlist => "/usr/lib/mailman/bin/rmlist", :newlist => "/usr/lib/mailman/bin/newlist"
-    commands :mailman => "/usr/lib/mailman/mail/mailman"
-  else
-    # This probably won't work for non-Debian installs, but this path is sure not to be in the PATH.
-    commands :list_lists => "list_lists", :rmlist => "rmlist", :newlist => "newlist"
-    commands :mailman => "/var/lib/mailman/mail/mailman"
-  end
-
-  mk_resource_methods
-
-  # Return a list of existing mailman instances.
-  def self.instances
-    list_lists('--bare').
-      split("\n").
-      collect { |line| new(:ensure => :present, :name => line.strip) }
-  end
-
-  # Prefetch our list list, yo.
-  def self.prefetch(lists)
-    instances.each do |prov|
-      if list = lists[prov.name] || lists[prov.name.downcase]
-        list.provider = prov
-      end
-    end
-  end
-
-  def aliases
-    mailman = self.class.command(:mailman)
-    name = self.name.downcase
-    aliases = {name => "| #{mailman} post #{name}"}
-    %w{admin bounces confirm join leave owner request subscribe unsubscribe}.each do |address|
-      aliases["#{name}-#{address}"] = "| #{mailman} #{address} #{name}"
-    end
-    aliases
-  end
-
-  # Create the list.
-  def create
-    args = []
-    if val = @resource[:mailserver]
-      args << "--emailhost" << val
-    end
-    if val = @resource[:webserver]
-      args << "--urlhost" << val
-    end
-
-    args << self.name
-    if val = @resource[:admin]
-      args << val
-    else
-      raise ArgumentError, _("Mailman lists require an administrator email address")
-    end
-    if val = @resource[:password]
-      args << val
-    else
-      raise ArgumentError, _("Mailman lists require an administrator password")
-    end
-    newlist(*args)
-  end
-
-  # Delete the list.
-  def destroy(purge = false)
-    args = []
-    args << "--archives" if purge
-    args << self.name
-    rmlist(*args)
-  end
-
-  # Does our list exist already?
-  def exists?
-    properties[:ensure] != :absent
-  end
-
-  # Clear out the cached values.
-  def flush
-    @property_hash.clear
-  end
-
-  # Look up the current status.
-  def properties
-    if @property_hash.empty?
-      @property_hash = query || {:ensure => :absent}
-      @property_hash[:ensure] = :absent if @property_hash.empty?
-    end
-    @property_hash.dup
-  end
-
-  # Remove the list and its archives.
-  def purge
-    destroy(true)
-  end
-
-  # Pull the current state of the list from the full list.  We're
-  # getting some double entendre here....
-  def query
-    self.class.instances.each do |list|
-      if list.name == self.name or list.name.downcase == self.name
-        return list.properties
-      end
-    end
-    nil
-  end
-end
-

data/lib/puppet/provider/mcx/mcxcontent.rb

@@ -1,173 +0,0 @@
-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.each_key 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
-
-    # val being passed in is resource[:content] which should be UTF-8
-    tmp = Tempfile.new('puppet_mcx', :encoding => Encoding::UTF_8)
-    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,
-      _("Could not parse ds_type from resource name '%{name}'.  Specify with ds_type parameter.") % { name: name }
-    end
-    # De-pluralize and downcase.
-    ds_type = ds_type.chop.downcase.to_sym
-    unless TypeMap.key? ds_type
-      raise MCXContentProviderException,
-      _("Could not parse ds_type from resource name '%{name}'.  Specify with ds_type parameter.") % { name: name }
-    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.") % { name: name }
-    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/lib/puppet/provider/mount.rb

@@ -1,76 +0,0 @@
-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
-    #TRANSLATORS refers to remounting a file system
-    info _("Remounting")
-    os = Facter.value(:operatingsystem)
-    supports_remounts = (resource[:remounts] == :true)
-    if supports_remounts && os == 'AIX'
-      remount_with_option("remount")
-    elsif os =~ /^(FreeBSD|DragonFly|OpenBSD)$/
-      remount_with_option("update")
-    elsif supports_remounts
-      mountcmd "-o", "remount", resource[:name]
-    else
-      unmount
-      mount
-    end
-  end
-
-  # Remount by appending the supplied param "option" to any existing explicitly
-  # defined options. If resource has no explicitly defined options, will mount
-  # with only "option".
-  # @param [String] option A remount option to use or append with existing options
-  #
-  def remount_with_option(option)
-    if using_explicit_options?
-      options = self.options + "," + option
-    else
-      options = option
-    end
-    mountcmd "-o", options, resource[:name]
-  end
-
-  def using_explicit_options?
-    !self.options.nil? && !self.options.empty?
-  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/lib/puppet/provider/mount/parsed.rb

@@ -1,285 +0,0 @@
-require 'puppet/provider/parsedfile'
-require 'puppet/provider/mount'
-
-fstab = nil
-case Facter.value(:osfamily)
-when "Solaris"; fstab = "/etc/vfstab"
-when "AIX"; fstab = "/etc/filesystems"
-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
-
-  if Facter.value(:osfamily) == "AIX"
-    # * is the comment character on AIX /etc/filesystems
-    text_line :comment, :match => /^\s*\*/
-  else
-    text_line :comment, :match => /^\s*#/
-  end
-  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}})/
-
-  case Facter.value(:osfamily)
-  when "AIX"
-    # The only field that is actually ordered is :name. See `man filesystems` on AIX
-    @fields = [:name, :account, :boot, :check, :dev, :free, :mount, :nodename,
-               :options, :quota, :size, :type, :vfs, :vol, :log]
-    self.line_separator = "\n"
-    # Override lines and use scan instead of split, because we DON'T want to
-    # remove the separators
-    def self.lines(text)
-      lines = text.split("\n")
-      filesystem_stanza = false
-      filesystem_index = 0
-      ret = Array.new
-      lines.each_with_index do |line,i|
-        if line =~ %r{^\S+:}
-          # Begin new filesystem stanza and save the index
-          ret[filesystem_index] = filesystem_stanza.join("\n") if filesystem_stanza
-          filesystem_stanza = Array(line)
-          filesystem_index = i
-          # Eat the preceding blank line
-          ret[i-1] = nil if i > 0 and ret[i-1] and ret[i-1] =~ %r{^\s*$}
-          nil
-        elsif line =~ %r{^(\s*\*.*|\s*)$}
-          # Just a comment or blank line; add in place
-          ret[i] = line
-        else
-          # Non-comments or blank lines must be part of a stanza
-          filesystem_stanza << line
-        end
-      end
-      # Add the final stanza to the return
-      ret[filesystem_index] = filesystem_stanza.join("\n") if filesystem_stanza
-      ret = ret.compact.flatten
-      ret.reject { |line| line =~ /^\* HEADER/ }
-    end
-    def self.header
-      super.gsub(/^#/,'*')
-    end
-
-    record_line self.name,
-      :fields    => @fields,
-      :separator => /\n/,
-      :block_eval => :instance do
-
-      def post_parse(result)
-        property_map = {
-          :dev      => :device,
-          :nodename => :nodename,
-          :options  => :options,
-          :vfs      => :fstype,
-        }
-        # Result is modified in-place instead of being returned; icky!
-        memo = result.dup
-        result.clear
-        # Save the line for later, just in case it is unparsable
-        result[:line] = @fields.collect do |field|
-          memo[field] if memo[field] != :absent
-        end.compact.join("\n")
-        result[:record_type] = memo[:record_type]
-        special_options = Array.new
-        result[:name] = memo[:name].sub(%r{:\s*$},'').strip
-        memo.each do |_,k_v|
-          if k_v and k_v.is_a?(String) and k_v.include?("=")
-            attr_name, attr_value = k_v.split("=",2).map(&:strip)
-            if attr_map_name = property_map[attr_name.to_sym]
-              # These are normal "options" options (see `man filesystems`)
-              result[attr_map_name] = attr_value
-            else
-              # These /etc/filesystem attributes have no mount resource simile,
-              # so are added to the "options" property for puppet's sake
-              special_options << "#{attr_name}=#{attr_value}"
-            end
-            if result[:nodename]
-              result[:device] = "#{result[:nodename]}:#{result[:device]}"
-              result.delete(:nodename)
-            end
-          end
-        end
-        result[:options] = [result[:options],special_options.sort].flatten.compact.join(',')
-        if ! result[:device]
-          result[:device] = :absent
-          #TRANSLATORS "prefetch" is a program name and should not be translated
-          Puppet.err _("Prefetch: Mount[%{name}]: Field 'device' is missing") % { name: result[:name] }
-        end
-        if ! result[:fstype]
-          result[:fstype] = :absent
-          #TRANSLATORS "prefetch" is a program name and should not be translated
-          Puppet.err _("Prefetch: Mount[%{name}]: Field 'fstype' is missing") % { name: result[:name] }
-        end
-      end
-      def to_line(result)
-        output = Array.new
-        output << "#{result[:name]}:"
-        if result[:device] and result[:device] =~ %r{^/}
-          output << "\tdev\t\t= #{result[:device]}"
-        elsif result[:device] and result[:device] != :absent
-          if ! result[:device] =~ %{^.+:/}
-            # Just skip this entry; it was malformed to begin with
-            Puppet.err _("Mount[%{name}]: Field 'device' must be in the format of <absolute path> or <host>:<absolute path>") % { name: result[:name] }
-            return result[:line]
-          end
-          nodename, path = result[:device].split(":")
-          output << "\tdev\t\t= #{path}"
-          output << "\tnodename\t= #{nodename}"
-        else
-          # Just skip this entry; it was malformed to begin with
-          Puppet.err _("Mount[%{name}]: Field 'device' is required") % { name: result[:name] }
-          return result[:line]
-        end
-        if result[:fstype] and result[:fstype] != :absent
-          output << "\tvfs\t\t= #{result[:fstype]}"
-        else
-          # Just skip this entry; it was malformed to begin with
-          Puppet.err _("Mount[%{name}]: Field 'device' is required") % { name: result[:name] }
-          return result[:line]
-        end
-        if result[:options]
-          options = result[:options].split(',')
-          special_options = options.select do |x|
-            x.include?('=') and
-              ["account", "boot", "check", "free", "mount", "size", "type",
-               "vol", "log", "quota"].include? x.split('=').first
-          end
-          options = options - special_options
-          special_options.sort.each do |x|
-            k, v = x.split("=")
-            output << "\t#{k}\t\t= #{v}"
-          end
-          output << "\toptions\t\t= #{options.join(",")}" unless options.empty?
-        end
-        if result[:line] and result[:line].split("\n").sort == output.sort
-          return "\n#{result[:line]}"
-        else
-          return "\n#{output.join("\n")}"
-        end
-      end
-    end
-  else
-    record_line self.name, :fields => @fields, :separator => /\s+/, :joiner => "\t", :optional => optional_fields, :block_eval => :instance do
-      def pre_gen(record)
-        if !record[:options] || record[:options].empty?
-          if Facter.value(:kernel) == 'Linux'
-            record[:options] = 'defaults'
-          else
-            raise Puppet::Error, _("Mount[%{name}]: Field 'options' is required") % { name: record[:name] }
-          end
-        end
-        if !record[:fstype] || record[:fstype].empty?
-          raise Puppet::Error, _("Mount[%{name}]: Field 'fstype' is required") % { name: record[:name] }
-        end
-        record
-      end
-    end
-  end
-
-  # Every entry in fstab is :unmounted until we can prove different
-  def self.prefetch_hook(target_records)
-    target_records.collect do |record|
-      # Eat the trailing slash(es) of mountpoints in fstab
-      # This mimics the behavior of munging the resource title
-      record[:name].gsub!(%r{^(.+?)/*$}, '\1') unless record[:name].nil?
-      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") % { line: line }
-      end
-    end
-    instances
-  end
-
-  def flush
-    needs_mount = @property_hash.delete(:needs_mount)
-    super
-    mount if needs_mount
-  end
-end