puppet 0.25.5 → 2.6.0

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

@@ -1,41 +1,44 @@
 require 'puppet/provider/parsedfile'
 
-Puppet::Type.type(:mailalias).provide(:aliases,
-    :parent => Puppet::Provider::ParsedFile,
-    :default_target => "/etc/aliases",
-    :filetype => :flat
+
+  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*$/
+  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
+  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 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(",")
-            return "%s: %s" % [record[:name], dest]
+    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/puppet/provider/maillist/mailman.rb

@@ -1,116 +1,110 @@
 require 'puppet/provider/parsedfile'
 
 Puppet::Type.type(:maillist).provide(:mailman) do
-    if [ "CentOS", "RedHat", "Fedora" ].any? { |os|  Facter.value(:operatingsystem) == os } then
-        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
+  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
+  mk_resource_methods
 
-    # Return a list of existing mailman instances.
-    def self.instances
-        list_lists.split("\n").reject { |line| line.include?("matching mailing lists") }.collect do |line|
-            name, description = line.sub(/^\s+/, '').sub(/\s+$/, '').split(/\s+-\s+/)
-            if description.include?("no description available")
-                description = :absent
-            end
-            new(:ensure => :present, :name => name, :description => description)
-        end
+  # Return a list of existing mailman instances.
+  def self.instances
+    list_lists.split("\n").reject { |line| line.include?("matching mailing lists") }.collect do |line|
+      name, description = line.sub(/^\s+/, '').sub(/\s+$/, '').split(/\s+-\s+/)
+      description = :absent if description.include?("no description available")
+      new(:ensure => :present, :name => name, :description => description)
     end
+  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
+  # 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["%s-%s" % [name, address]] = "| %s %s %s" % [mailman, address, name]
-        end
-        aliases
+  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)
+  # Create the list.
+  def create
+    args = []
+    if val = @resource[:mailserver]
+      args << "--emailhost" << val
     end
-
-    # Delete the list.
-    def destroy(purge = false)
-        args = []
-        if purge
-            args << "--archives"
-        end
-        args << self.name
-        rmlist(*args)
+    if val = @resource[:webserver]
+      args << "--urlhost" << val
     end
 
-    # Does our list exist already?
-    def exists?
-        properties[:ensure] != :absent
+    args << self.name
+    if val = @resource[:admin]
+      args << val
+    else
+      raise ArgumentError, "Mailman lists require an administrator email address"
     end
-
-    # Clear out the cached values.
-    def flush
-        @property_hash.clear
+    if val = @resource[:password]
+      args << val
+    else
+      raise ArgumentError, "Mailman lists require an administrator password"
     end
+    newlist(*args)
+  end
 
-    # Look up the current status.
-    def properties
-        if @property_hash.empty?
-            @property_hash = query || {:ensure => :absent}
-            if @property_hash.empty?
-                @property_hash[:ensure] = :absent
-            end
-        end
-        @property_hash.dup
-    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
 
-    # Remove the list and its archives.
-    def purge
-        destroy(true)
+  # 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
+  # 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

@@ -21,181 +21,185 @@ require 'tempfile'
 
 Puppet::Type.type(:mcx).provide :mcxcontent, :parent => Puppet::Provider do
 
-    desc "MCX Settings management using DirectoryService on OS X.
+  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.
+  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.
+  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)
+  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
-
-    # self.instances is all important.
-    # This is the only class method, it returns
-    # an array of instances of this class.
-    def self.instances
-        mcx_list = []
-        for ds_type in TypeMap.keys
-            ds_path = "/Local/Default/#{TypeMap[ds_type]}"
-            output = dscl 'localhost', '-list', ds_path
-            member_list = output.split
-            for ds_name in member_list
-                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.
-                    rsrc = self.new(:name => "/#{TypeMap[ds_type]}/#{ds_name}",
-                                 :ds_type => ds_type,
-                                 :ds_name => ds_name,
-                                 :content => content)
-                    mcx_list << rsrc
-                end
-            end
+  # 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
+
+  # self.instances is all important.
+  # This is the only class method, it returns
+  # an array of instances of this class.
+  def self.instances
+    mcx_list = []
+    for ds_type in TypeMap.keys
+      ds_path = "/Local/Default/#{TypeMap[ds_type]}"
+      output = dscl 'localhost', '-list', ds_path
+      member_list = output.split
+      for ds_name in member_list
+        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.
+
+            rsrc = self.new(
+              :name => "/#{TypeMap[ds_type]}/#{ds_name}",
+                :ds_type => ds_type,
+                :ds_name => ds_name,
+
+                :content => content)
+          mcx_list << rsrc
         end
-        return mcx_list
+      end
     end
-
-    private
-
-    # mcxexport is used by instances, and therefore
-    # a class method.
-    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
+    mcx_list
+  end
+
+  private
+
+  # mcxexport is used by instances, and therefore
+  # a class method.
+  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 mcximport(ds_type, ds_name, val)
+    ds_t = TypeMap[ds_type]
+    ds_n = ds_name.to_s
+    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
-
-    def mcximport(ds_type, ds_name, val)
-        ds_t = TypeMap[ds_type]
-        ds_n = ds_name.to_s
-        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)
+    tmp = name.split('/')[1]
+    if ! tmp.is_a? String
+      raise MCXContentProviderException,
+      "Coult not parse ds_type from resource name '#{name}'.  Specify with ds_type parameter."
     end
-
-    # Given the resource name string, parse ds_type out.
-    def parse_type(name)
-        tmp = name.split('/')[1]
-        if ! tmp.is_a? String
-            raise MCXContentProviderException,
-            "Coult not parse ds_type from resource name '#{name}'.  Specify with ds_type parameter."
-        end
-        # De-pluralize and downcase.
-        tmp = tmp.chop.downcase.to_sym
-        if not TypeMap.keys.member? tmp
-            raise MCXContentProviderException,
-            "Coult not parse ds_type from resource name '#{name}'.  Specify with ds_type parameter."
-        end
-        return tmp
+    # De-pluralize and downcase.
+    tmp = tmp.chop.downcase.to_sym
+    if not TypeMap.keys.member? tmp
+      raise MCXContentProviderException,
+      "Coult not parse ds_type from resource name '#{name}'.  Specify with ds_type parameter."
     end
-
-    # Given the resource name string, parse ds_name out.
-    def parse_name(name)
-        ds_name = name.split('/')[2]
-        if ! ds_name.is_a? String
-            raise MCXContentProviderException,
-            "Could not parse ds_name from resource name '#{name}'.  Specify with ds_name parameter."
-        end
-        return ds_name
+    tmp
+  end
+
+  # Given the resource name string, parse ds_name out.
+  def parse_name(name)
+    ds_name = name.split('/')[2]
+    if ! ds_name.is_a? String
+      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.
+  # This is a private instance method, not a class method.
+  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])
+
+    rval = {
+      :ds_type => ds_type.to_sym,
+      :ds_name => ds_name,
+    }
 
-    # Gather ds_type and ds_name from resource or
-    # parse it out of the name.
-    # This is a private instance method, not a class method.
-    def get_dsparams
-        ds_type = resource[:ds_type]
-        if ds_type.nil?
-            ds_type = parse_type(resource[:name])
-        end
-        raise MCXContentProviderException unless TypeMap.keys.include? ds_type.to_sym
+    return rval
 
-        ds_name = resource[:ds_name]
-        if ds_name.nil?
-            ds_name = parse_name(resource[:name])
-        end
+  end
 
-        rval = {
-            :ds_type => ds_type.to_sym,
-            :ds_name => ds_name,
-        }
+  public
 
-        return rval
+  def create
+    self.content=(resource[:content])
+  end
 
-    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}"
 
-    public
+    dscl 'localhost', '-mcxdelete', ds_path
+  end
 
-    def create
-        self.content=(resource[:content])
+  def exists?
+    # JJM Just re-use the content method and see if it's empty.
+    begin
+      mcx = content
+    rescue Puppet::ExecutionFailure => e
+      return false
     end
+    has_mcx = ! mcx.empty?
+  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}"
+  def content
+    ds_parms = get_dsparams
 
-        dscl 'localhost', '-mcxdelete', ds_path
-    end
+      mcx = self.class.mcxexport(
+        ds_parms[:ds_type],
 
-    def exists?
-        # JJM Just re-use the content method and see if it's empty.
-        begin
-            mcx = content
-        rescue Puppet::ExecutionFailure => e
-            return false
-        end
-        has_mcx = ! mcx.empty?
-        return has_mcx
-    end
+          ds_parms[:ds_name])
+    mcx
+  end
 
-    def content
-        ds_parms = get_dsparams
-        mcx = self.class.mcxexport(ds_parms[:ds_type],
-                                   ds_parms[:ds_name])
-        return mcx
-    end
+  def content=(value)
+    # dscl localhost -mcximport
+    ds_parms = get_dsparams
 
-    def content=(value)
-        # dscl localhost -mcximport
-        ds_parms = get_dsparams
-        mcx = mcximport(ds_parms[:ds_type],
-                        ds_parms[:ds_name],
-                        resource[:content])
-        return mcx
-    end
+      mcx = mcximport(
+        ds_parms[:ds_type],
+          ds_parms[:ds_name],
+
+          resource[:content])
+    mcx
+  end
 
 end