puppet-parse 0.0.1 → 0.0.2

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

@@ -0,0 +1,313 @@
+require 'facter'
+require 'facter/util/plist'
+require 'puppet'
+require 'tempfile'
+
+Puppet::Type.type(:macauthorization).provide :macauthorization, :parent => Puppet::Provider do
+
+  desc "Manage Mac OS X authorization database rules and rights.
+
+  "
+
+  commands :security => "/usr/bin/security"
+  commands :sw_vers => "/usr/bin/sw_vers"
+
+  confine :operatingsystem => :darwin
+
+  # This should be confined based on macosx_productversion
+  # but puppet resource doesn't make the facts available and
+  # that interface is heavily used with this provider.
+  if FileTest.exists?("/usr/bin/sw_vers")
+    product_version = sw_vers "-productVersion"
+
+    confine :true => unless /^10\.[0-4]/.match(product_version)
+      true
+    end
+  end
+
+  defaultfor :operatingsystem => :darwin
+
+  AuthDB = "/etc/authorization"
+
+  @rights = {}
+  @rules = {}
+  @parsed_auth_db = {}
+  @comment = ""  # Not implemented yet. Is there any real need to?
+
+  # This map exists due to the use of hyphens and reserved words in
+  # the authorization schema.
+  PuppetToNativeAttributeMap = {  :allow_root => "allow-root",
+    :authenticate_user => "authenticate-user",
+    :auth_class => "class",
+    :k_of_n => "k-of-n",
+    :session_owner => "session-owner", }
+
+  class << self
+    attr_accessor :parsed_auth_db
+    attr_accessor :rights
+    attr_accessor :rules
+    attr_accessor :comments  # Not implemented yet.
+
+    def prefetch(resources)
+      self.populate_rules_rights
+    end
+
+    def instances
+      if self.parsed_auth_db == {}
+        self.prefetch(nil)
+      end
+      self.parsed_auth_db.collect do |k,v|
+        new(:name => k)
+      end
+    end
+
+    def populate_rules_rights
+      auth_plist = Plist::parse_xml(AuthDB)
+      raise Puppet::Error.new("Cannot parse: #{AuthDB}") if not auth_plist
+      self.rights = auth_plist["rights"].dup
+      self.rules = auth_plist["rules"].dup
+      self.parsed_auth_db = self.rights.dup
+      self.parsed_auth_db.merge!(self.rules.dup)
+    end
+
+  end
+
+  # standard required provider instance methods
+
+  def initialize(resource)
+    if self.class.parsed_auth_db == {}
+      self.class.prefetch(resource)
+    end
+    super
+  end
+
+
+  def create
+    # we just fill the @property_hash in here and let the flush method
+    # deal with it rather than repeating code.
+    new_values = {}
+    validprops = Puppet::Type.type(resource.class.name).validproperties
+    validprops.each do |prop|
+      next if prop == :ensure
+      if value = resource.should(prop) and value != ""
+        new_values[prop] = value
+      end
+    end
+    @property_hash = new_values.dup
+  end
+
+  def destroy
+    # We explicitly delete here rather than in the flush method.
+    case resource[:auth_type]
+    when :right
+      destroy_right
+    when :rule
+      destroy_rule
+    else
+      raise Puppet::Error.new("Must specify auth_type when destroying.")
+    end
+  end
+
+  def exists?
+    !!self.class.parsed_auth_db.has_key?(resource[:name])
+  end
+
+
+  def flush
+    # deletion happens in the destroy methods
+    if resource[:ensure] != :absent
+      case resource[:auth_type]
+      when :right
+        flush_right
+      when :rule
+        flush_rule
+      else
+        raise Puppet::Error.new("flush requested for unknown type.")
+      end
+      @property_hash.clear
+    end
+  end
+
+
+  # utility methods below
+
+  def destroy_right
+    security "authorizationdb", :remove, resource[:name]
+  end
+
+  def destroy_rule
+    authdb = Plist::parse_xml(AuthDB)
+    authdb_rules = authdb["rules"].dup
+    if authdb_rules[resource[:name]]
+      begin
+        authdb["rules"].delete(resource[:name])
+        Plist::Emit.save_plist(authdb, AuthDB)
+      rescue Errno::EACCES => e
+        raise Puppet::Error.new("Error saving #{AuthDB}: #{e}")
+      end
+    end
+  end
+
+  def flush_right
+    # first we re-read the right just to make sure we're in sync for
+    # values that weren't specified in the manifest. As we're supplying
+    # the whole plist when specifying the right it seems safest to be
+    # paranoid given the low cost of quering the db once more.
+    cmds = []
+    cmds << :security << "authorizationdb" << "read" << resource[:name]
+    output = execute(cmds, :combine => false)
+    current_values = Plist::parse_xml(output)
+    current_values ||= {}
+    specified_values = convert_plist_to_native_attributes(@property_hash)
+
+    # take the current values, merge the specified values to obtain a
+    # complete description of the new values.
+    new_values = current_values.merge(specified_values)
+    set_right(resource[:name], new_values)
+  end
+
+  def flush_rule
+    authdb = Plist::parse_xml(AuthDB)
+    authdb_rules = authdb["rules"].dup
+    current_values = {}
+    current_values = authdb_rules[resource[:name]] if authdb_rules[resource[:name]]
+    specified_values = convert_plist_to_native_attributes(@property_hash)
+    new_values = current_values.merge(specified_values)
+    set_rule(resource[:name], new_values)
+  end
+
+  def set_right(name, values)
+    # Both creates and modifies rights as it simply overwrites them.
+    # The security binary only allows for writes using stdin, so we
+    # dump the values to a tempfile.
+    values = convert_plist_to_native_attributes(values)
+    tmp = Tempfile.new('puppet_macauthorization')
+    begin
+      Plist::Emit.save_plist(values, tmp.path)
+      cmds = []
+      cmds << :security << "authorizationdb" << "write" << name
+
+        output = execute(
+          cmds, :combine => false,
+
+            :stdinfile => tmp.path.to_s)
+    rescue Errno::EACCES => e
+      raise Puppet::Error.new("Cannot save right to #{tmp.path}: #{e}")
+    ensure
+      tmp.close
+      tmp.unlink
+    end
+  end
+
+  def set_rule(name, values)
+    # Both creates and modifies rules as it overwrites the entry in the
+    # rules dictionary.  Unfortunately the security binary doesn't
+    # support modifying rules at all so we have to twiddle the whole
+    # plist... :( See Apple Bug #6386000
+    values = convert_plist_to_native_attributes(values)
+    authdb = Plist::parse_xml(AuthDB)
+    authdb["rules"][name] = values
+
+    begin
+      Plist::Emit.save_plist(authdb, AuthDB)
+    rescue
+      raise Puppet::Error.new("Error writing to: #{AuthDB}")
+    end
+  end
+
+  def convert_plist_to_native_attributes(propertylist)
+    # This mainly converts the keys from the puppet attributes to the
+    # 'native' ones, but also enforces that the keys are all Strings
+    # rather than Symbols so that any merges of the resultant Hash are
+    # sane. The exception is booleans, where we coerce to a proper bool
+    # if they come in as a symbol.
+    newplist = {}
+    propertylist.each_pair do |key, value|
+      next if key == :ensure     # not part of the auth db schema.
+      next if key == :auth_type  # not part of the auth db schema.
+      case value
+      when true, :true
+        value = true
+      when false, :false
+        value = false
+      end
+      new_key = key
+      if PuppetToNativeAttributeMap.has_key?(key)
+        new_key = PuppetToNativeAttributeMap[key].to_s
+      elsif not key.is_a?(String)
+        new_key = key.to_s
+      end
+      newplist[new_key] = value
+    end
+    newplist
+  end
+
+  def retrieve_value(resource_name, attribute)
+    # We set boolean values to symbols when retrieving values
+    raise Puppet::Error.new("Cannot find #{resource_name} in auth db") if not self.class.parsed_auth_db.has_key?(resource_name)
+
+    if PuppetToNativeAttributeMap.has_key?(attribute)
+      native_attribute = PuppetToNativeAttributeMap[attribute]
+    else
+      native_attribute = attribute.to_s
+    end
+
+    if self.class.parsed_auth_db[resource_name].has_key?(native_attribute)
+      value = self.class.parsed_auth_db[resource_name][native_attribute]
+      case value
+      when true, :true
+        value = :true
+      when false, :false
+        value = :false
+      end
+
+      @property_hash[attribute] = value
+      return value
+    else
+      @property_hash.delete(attribute)
+      return ""  # so ralsh doesn't display it.
+    end
+  end
+
+
+  # property methods below
+  #
+  # We define them all dynamically apart from auth_type which is a special
+  # case due to not being in the actual authorization db schema.
+
+  properties = [  :allow_root, :authenticate_user, :auth_class, :comment,
+    :group, :k_of_n, :mechanisms, :rule, :session_owner,
+    :shared, :timeout, :tries ]
+
+  properties.each do |field|
+    define_method(field.to_s) do
+      retrieve_value(resource[:name], field)
+    end
+
+    define_method(field.to_s + "=") do |value|
+      @property_hash[field] = value
+    end
+  end
+
+  def auth_type
+    if resource.should(:auth_type) != nil
+      return resource.should(:auth_type)
+    elsif self.exists?
+      # this is here just for ralsh, so it can work out what type it is.
+      if self.class.rights.has_key?(resource[:name])
+        return :right
+      elsif self.class.rules.has_key?(resource[:name])
+        return :rule
+      else
+        raise Puppet::Error.new("#{resource[:name]} is unknown type.")
+      end
+    else
+      raise Puppet::Error.new("auth_type required for new resources.")
+    end
+  end
+
+  def auth_type=(value)
+    @property_hash[:auth_type] = value
+  end
+
+end

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

@@ -0,0 +1,44 @@
+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)
+      # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
+      # It's not sufficient to assign to an existing hash.
+      recipient = record[:recipient].split(/\s*,\s*/).collect { |d| d.gsub(/^['"]|['"]$/, '') }
+      record[:recipient] = recipient
+      record
+    end
+
+    def process(line)
+      ret = {}
+      records = line.split(':',2)
+      ret[:name] = records[0].strip
+      ret[:recipient] = records[1].strip
+      ret
+    end
+
+    def to_line(record)
+      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}"
+    end
+  end
+end
+

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

@@ -0,0 +1,108 @@
+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/vendor/puppet/provider/mcx/mcxcontent.rb

@@ -0,0 +1,166 @@
+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 => e
+      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}"
+
+    tmp = Tempfile.new('puppet_mcx')
+    begin
+      tmp << val
+      tmp.flush
+      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