puppet 0.25.5 → 2.6.0

data/lib/puppet/provider/user/useradd.rb

@@ -1,70 +1,69 @@
 require 'puppet/provider/nameservice/objectadd'
 
 Puppet::Type.type(:user).provide :useradd, :parent => Puppet::Provider::NameService::ObjectAdd do
-    desc "User management via ``useradd`` and its ilk.  Note that you will need to install the ``Shadow Password`` Ruby library often known as ruby-libshadow to manage user passwords."
+  desc "User management via ``useradd`` and its ilk.  Note that you will need to install the ``Shadow Password`` Ruby library often known as ruby-libshadow to manage user passwords."
 
-    commands :add => "useradd", :delete => "userdel", :modify => "usermod"
+  commands :add => "useradd", :delete => "userdel", :modify => "usermod"
 
-    options :home, :flag => "-d", :method => :dir
-    options :comment, :method => :gecos
-    options :groups, :flag => "-G"
+  options :home, :flag => "-d", :method => :dir
+  options :comment, :method => :gecos
+  options :groups, :flag => "-G"
 
-    verify :gid, "GID must be an integer" do |value|
-        value.is_a? Integer
-    end
+  verify :gid, "GID must be an integer" do |value|
+    value.is_a? Integer
+  end
 
-    verify :groups, "Groups must be comma-separated" do |value|
-        value !~ /\s/
-    end
+  verify :groups, "Groups must be comma-separated" do |value|
+    value !~ /\s/
+  end
 
-    has_features :manages_homedir, :allows_duplicates
+  has_features :manages_homedir, :allows_duplicates
 
-    if Puppet.features.libshadow?
-        has_feature :manages_passwords
-    end
+  has_feature :manages_passwords if Puppet.features.libshadow?
 
-    def check_allow_dup
-        @resource.allowdupe? ? ["-o"] : []
-    end
+  def check_allow_dup
+    @resource.allowdupe? ? ["-o"] : []
+  end
 
-    def check_manage_home
-        cmd = []
-        if @resource.managehome?
-            cmd << "-m"
-        elsif %w{Fedora RedHat CentOS OEL OVS}.include?(Facter.value("operatingsystem"))
-            cmd << "-M"
-        end
-        cmd
+  def check_manage_home
+    cmd = []
+    if @resource.managehome?
+      cmd << "-m"
+    elsif %w{Fedora RedHat CentOS OEL OVS}.include?(Facter.value("operatingsystem"))
+      cmd << "-M"
     end
+    cmd
+  end
 
-    def add_properties
-        cmd = []
-        Puppet::Type.type(:user).validproperties.each do |property|
-            next if property == :ensure
-            # the value needs to be quoted, mostly because -c might
-            # have spaces in it
-            if value = @resource.should(property) and value != ""
-                cmd << flag(property) << value
-            end
-        end
-        cmd
+  def add_properties
+    cmd = []
+    Puppet::Type.type(:user).validproperties.each do |property|
+      next if property == :ensure
+      # the value needs to be quoted, mostly because -c might
+      # have spaces in it
+      if value = @resource.should(property) and value != ""
+        cmd << flag(property) << value
+      end
     end
+    cmd
+  end
 
-    def addcmd
-        cmd = [command(:add)]
-        cmd += add_properties
-        cmd += check_allow_dup
-        cmd += check_manage_home
-        cmd << @resource[:name]
-    end
+  def addcmd
+    cmd = [command(:add)]
+    cmd += add_properties
+    cmd += check_allow_dup
+    cmd += check_manage_home
+    cmd << @resource[:name]
+  end
 
-    # Retrieve the password using the Shadow Password library
-    def password
-        if ent = Shadow::Passwd.getspnam(@resource.name)
-            return ent.sp_pwdp
-        else
-            return :absent
-        end
+  # Retrieve the password using the Shadow Password library
+  def password
+    if Puppet.features.libshadow?
+      if ent = Shadow::Passwd.getspnam(@resource.name)
+        return ent.sp_pwdp
+      end
     end
+    :absent
+  end
 end
 

data/lib/puppet/provider/zfs/solaris.rb

@@ -1,45 +1,45 @@
 Puppet::Type.type(:zfs).provide(:solaris) do
-    desc "Provider for Solaris zfs."
-
-    commands :zfs => "/usr/sbin/zfs"
-    defaultfor :operatingsystem => :solaris
-
-    def add_properties
-        properties = []
-        Puppet::Type.type(:zfs).validproperties.each do |property|
-            next if property == :ensure
-            if value = @resource[property] and value != ""
-                properties << "-o" << "#{property}=#{value}"
-            end
-        end
-        properties
+  desc "Provider for Solaris zfs."
+
+  commands :zfs => "/usr/sbin/zfs"
+  defaultfor :operatingsystem => :solaris
+
+  def add_properties
+    properties = []
+    Puppet::Type.type(:zfs).validproperties.each do |property|
+      next if property == :ensure
+      if value = @resource[property] and value != ""
+        properties << "-o" << "#{property}=#{value}"
+      end
     end
-
-    def create
-        zfs *([:create] + add_properties + [@resource[:name]])
-    end
-
-    def destroy
-        zfs(:destroy, @resource[:name])
+    properties
+  end
+
+  def create
+    zfs *([:create] + add_properties + [@resource[:name]])
+  end
+
+  def destroy
+    zfs(:destroy, @resource[:name])
+  end
+
+  def exists?
+    if zfs(:list).split("\n").detect { |line| line.split("\s")[0] == @resource[:name] }
+      true
+    else
+      false
     end
+  end
 
-    def exists?
-        if zfs(:list).split("\n").detect { |line| line.split("\s")[0] == @resource[:name] }
-            true
-        else
-            false
-        end
+  [:mountpoint, :compression, :copies, :quota, :reservation, :sharenfs, :snapdir].each do |field|
+    define_method(field) do
+      zfs(:get, "-H", "-o", "value", field, @resource[:name]).strip
     end
 
-    [:mountpoint, :compression, :copies, :quota, :reservation, :sharenfs, :snapdir].each do |field|
-        define_method(field) do
-            zfs(:get, "-H", "-o", "value", field, @resource[:name]).strip
-        end
-
-        define_method(field.to_s + "=") do |should|
-            zfs(:set, "#{field}=#{should}", @resource[:name])
-        end
+    define_method(field.to_s + "=") do |should|
+      zfs(:set, "#{field}=#{should}", @resource[:name])
     end
+  end
 
 end
 

data/lib/puppet/provider/zone/solaris.rb

@@ -1,256 +1,257 @@
 Puppet::Type.type(:zone).provide(:solaris) do
-    desc "Provider for Solaris Zones."
+  desc "Provider for Solaris Zones."
 
-    commands :adm => "/usr/sbin/zoneadm", :cfg => "/usr/sbin/zonecfg"
-    defaultfor :operatingsystem => :solaris
+  commands :adm => "/usr/sbin/zoneadm", :cfg => "/usr/sbin/zonecfg"
+  defaultfor :operatingsystem => :solaris
 
-    mk_resource_methods
+  mk_resource_methods
 
-    # Convert the output of a list into a hash
-    def self.line2hash(line)
-        fields = [:id, :name, :ensure, :path]
+  # Convert the output of a list into a hash
+  def self.line2hash(line)
+    fields = [:id, :name, :ensure, :path]
 
-        properties = {}
-        line.split(":").each_with_index { |value, index|
-            next unless fields[index]
-            properties[fields[index]] = value
-        }
+    properties = {}
+    line.split(":").each_with_index { |value, index|
+      next unless fields[index]
+      properties[fields[index]] = value
+    }
 
-        # Configured but not installed zones do not have IDs
-        if properties[:id] == "-"
-            properties.delete(:id)
-        end
+    # Configured but not installed zones do not have IDs
+    properties.delete(:id) if properties[:id] == "-"
 
-        properties[:ensure] = symbolize(properties[:ensure])
+    properties[:ensure] = symbolize(properties[:ensure])
 
-        return properties
-    end
+    properties
+  end
 
-    def self.instances
-        # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
-        x = adm(:list, "-cp").split("\n").collect do |line|
-            new(line2hash(line))
-        end
+  def self.instances
+    # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
+    x = adm(:list, "-cp").split("\n").collect do |line|
+      new(line2hash(line))
     end
-
-    # Perform all of our configuration steps.
-    def configure
-        # If the thing is entirely absent, then we need to create the config.
-        # Is there someway to get this on one line?
-        str = "create -b #{@resource[:create_args]}\nset zonepath=%s\n" % @resource[:path]
-
-        # Then perform all of our configuration steps.  It's annoying
-        # that we need this much internal info on the resource.
-        @resource.send(:properties).each do |property|
-            if property.is_a? ZoneConfigProperty and ! property.insync?(properties[property.name])
-                str += property.configtext + "\n"
-            end
-        end
-
-        str += "commit\n"
-        setconfig(str)
+  end
+
+  # Perform all of our configuration steps.
+  def configure
+    # If the thing is entirely absent, then we need to create the config.
+    # Is there someway to get this on one line?
+    str = "create -b #{@resource[:create_args]}\nset zonepath=#{@resource[:path]}\n"
+
+    # Then perform all of our configuration steps.  It's annoying
+    # that we need this much internal info on the resource.
+    @resource.send(:properties).each do |property|
+      str += property.configtext + "\n" if property.is_a? ZoneConfigProperty and ! property.insync?(properties[property.name])
     end
 
-    def destroy
-        zonecfg :delete, "-F"
+    str += "commit\n"
+    setconfig(str)
+  end
+
+  def destroy
+    zonecfg :delete, "-F"
+  end
+
+  def exists?
+    properties[:ensure] != :absent
+  end
+
+  # Clear out the cached values.
+  def flush
+    @property_hash.clear
+  end
+
+  def install(dummy_argument=:work_arround_for_ruby_GC_bug)
+    if @resource[:clone] # TODO: add support for "-s snapshot"
+      zoneadm :clone, @resource[:clone]
+    elsif @resource[:install_args]
+      zoneadm :install, @resource[:install_args].split(" ")
+    else
+      zoneadm :install
     end
+  end
+
+  # Look up the current status.
+  def properties
+    if @property_hash.empty?
+      @property_hash = status || {}
+      if @property_hash.empty?
+        @property_hash[:ensure] = :absent
+      else
+        @resource.class.validproperties.each do |name|
+          @property_hash[name] ||= :absent
+        end
+      end
 
-    def exists?
-        properties[:ensure] != :absent
     end
-
-    # Clear out the cached values.
-    def flush
-        @property_hash.clear
+    @property_hash.dup
+  end
+
+  # We need a way to test whether a zone is in process.  Our 'ensure'
+  # property models the static states, but we need to handle the temporary ones.
+  def processing?
+    if hash = status
+      case hash[:ensure]
+      when "incomplete", "ready", "shutting_down"
+        true
+      else
+        false
+      end
+    else
+      false
     end
-
-    def install(dummy_argument=:work_arround_for_ruby_GC_bug)
-        if @resource[:install_args]
-            zoneadm :install, @resource[:install_args].split(" ")
+  end
+
+  # Collect the configuration of the zone.
+  def getconfig
+    output = zonecfg :info
+
+    name = nil
+    current = nil
+    hash = {}
+    output.split("\n").each do |line|
+      case line
+      when /^(\S+):\s*$/
+        name = $1
+        current = nil # reset it
+      when /^(\S+):\s*(.+)$/
+        hash[$1.intern] = $2
+      when /^\s+(\S+):\s*(.+)$/
+        if name
+          hash[name] = [] unless hash.include? name
+
+          unless current
+            current = {}
+            hash[name] << current
+          end
+          current[$1.intern] = $2
         else
-            zoneadm :install
+          err "Ignoring '#{line}'"
         end
+      else
+        debug "Ignoring zone output '#{line}'"
+      end
     end
 
-    # Look up the current status.
-    def properties
-        if @property_hash.empty?
-            @property_hash = status || {}
-            if @property_hash.empty?
-                @property_hash[:ensure] = :absent
-            else
-                @resource.class.validproperties.each do |name|
-                    @property_hash[name] ||= :absent
-                end
-            end
+    hash
+  end
 
-        end
-        @property_hash.dup
+  # Execute a configuration string.  Can't be private because it's called
+  # by the properties.
+  def setconfig(str)
+    command = "#{command(:cfg)} -z #{@resource[:name]} -f -"
+    debug "Executing '#{command}' in zone #{@resource[:name]} with '#{str}'"
+    IO.popen(command, "w") do |pipe|
+      pipe.puts str
     end
 
-    # We need a way to test whether a zone is in process.  Our 'ensure'
-    # property models the static states, but we need to handle the temporary ones.
-    def processing?
-        if hash = status()
-            case hash[:ensure]
-            when "incomplete", "ready", "shutting_down"
-                true
-            else
-                false
-            end
-        else
-            false
-        end
+    unless $CHILD_STATUS == 0
+      raise ArgumentError, "Failed to apply configuration"
     end
+  end
 
-    # Collect the configuration of the zone.
-    def getconfig
-        output = zonecfg :info
-
-        name = nil
-        current = nil
-        hash = {}
-        output.split("\n").each do |line|
-            case line
-            when /^(\S+):\s*$/
-                name = $1
-                current = nil # reset it
-            when /^(\S+):\s*(.+)$/
-                hash[$1.intern] = $2
-            when /^\s+(\S+):\s*(.+)$/
-                if name
-                    unless hash.include? name
-                        hash[name] = []
-                    end
-
-                    unless current
-                        current = {}
-                        hash[name] << current
-                    end
-                    current[$1.intern] = $2
-                else
-                    err "Ignoring '%s'" % line
-                end
-            else
-                debug "Ignoring zone output '%s'" % line
-            end
-        end
+  def start
+    # Check the sysidcfg stuff
+    if cfg = @resource[:sysidcfg]
+      zoneetc = File.join(@resource[:path], "root", "etc")
+      sysidcfg = File.join(zoneetc, "sysidcfg")
 
-        return hash
-    end
+      # if the zone root isn't present "ready" the zone
+      # which makes zoneadmd mount the zone root
+      zoneadm :ready unless File.directory?(zoneetc)
 
-    # Execute a configuration string.  Can't be private because it's called
-    # by the properties.
-    def setconfig(str)
-        command = "#{command(:cfg)} -z %s -f -" % @resource[:name]
-        debug "Executing '%s' in zone %s with '%s'" % [command, @resource[:name], str]
-        IO.popen(command, "w") do |pipe|
-            pipe.puts str
-        end
-
-        unless $? == 0
-            raise ArgumentError, "Failed to apply configuration"
+      unless File.exists?(sysidcfg)
+        begin
+          File.open(sysidcfg, "w", 0600) do |f|
+            f.puts cfg
+          end
+        rescue => detail
+          puts detail.stacktrace if Puppet[:debug]
+          raise Puppet::Error, "Could not create sysidcfg: #{detail}"
         end
+      end
     end
 
-    def start
-        # Check the sysidcfg stuff
-        if cfg = @resource[:sysidcfg]
-            zoneetc = File.join(@resource[:path], "root", "etc")
-            sysidcfg = File.join(zoneetc, "sysidcfg")
-
-            # if the zone root isn't present "ready" the zone
-            # which makes zoneadmd mount the zone root
-            zoneadm :ready unless File.directory?(zoneetc)
-
-            unless File.exists?(sysidcfg)
-                begin
-                    File.open(sysidcfg, "w", 0600) do |f|
-                        f.puts cfg
-                    end
-                rescue => detail
-                    if Puppet[:debug]
-                        puts detail.stacktrace
-                    end
-                    raise Puppet::Error, "Could not create sysidcfg: %s" % detail
-                end
-            end
-        end
+    zoneadm :boot
+  end
 
-        zoneadm :boot
+  # Return a hash of the current status of this zone.
+  def status
+    begin
+      output = adm "-z", @resource[:name], :list, "-p"
+    rescue Puppet::ExecutionFailure
+      return nil
     end
 
-    # Return a hash of the current status of this zone.
-    def status
-        begin
-            output = adm "-z", @resource[:name], :list, "-p"
-        rescue Puppet::ExecutionFailure
-            return nil
-        end
-
-        main = self.class.line2hash(output.chomp)
-
-        # Now add in the configuration information
-        config_status.each do |name, value|
-            main[name] = value
-        end
+    main = self.class.line2hash(output.chomp)
 
-        main
+    # Now add in the configuration information
+    config_status.each do |name, value|
+      main[name] = value
     end
 
-    def ready
-        zoneadm :ready
-    end
+    main
+  end
 
-    def stop
-        zoneadm :halt
-    end
+  def ready
+    zoneadm :ready
+  end
 
-    def unconfigure
-        zonecfg :delete, "-F"
-    end
+  def stop
+    zoneadm :halt
+  end
 
-    def uninstall
-        zoneadm :uninstall, "-F"
-    end
+  def unconfigure
+    zonecfg :delete, "-F"
+  end
 
-    private
+  def uninstall
+    zoneadm :uninstall, "-F"
+  end
 
-    # Turn the results of getconfig into status information.
-    def config_status
-        config = getconfig()
-        result = {}
+  private
 
-        result[:autoboot] = config[:autoboot] ? config[:autoboot].intern : :absent
-        result[:pool] = config[:pool]
-        result[:shares] = config[:shares]
-        if dir = config["inherit-pkg-dir"]
-            result[:inherit] = dir.collect { |dirs| dirs[:dir] }
-        end
-        if net = config["net"]
-            result[:ip] = net.collect { |params| "%s:%s" % [params[:physical], params[:address]] }
-        end
+  # Turn the results of getconfig into status information.
+  def config_status
+    config = getconfig
+    result = {}
 
-        result
+    result[:autoboot] = config[:autoboot] ? config[:autoboot].intern : :absent
+    result[:pool] = config[:pool]
+    result[:shares] = config[:shares]
+    if dir = config["inherit-pkg-dir"]
+      result[:inherit] = dir.collect { |dirs| dirs[:dir] }
     end
-
-    def zoneadm(*cmd)
-        begin
-            adm("-z", @resource[:name], *cmd)
-        rescue Puppet::ExecutionFailure => detail
-            self.fail "Could not %s zone: %s" % [cmd[0], detail]
+    result[:iptype] = config[:"ip-type"]
+    if net = config["net"]
+      result[:ip] = net.collect do |params|
+        if params[:defrouter]
+          "#{params[:physical]}:#{params[:address]}:#{params[:defrouter]}"
+        elsif params[:address]
+          "#{params[:physical]}:#{params[:address]}"
+        else
+          params[:physical]
         end
+      end
     end
 
-    def zonecfg(*cmd)
-        # You apparently can't get the configuration of the global zone
-        return "" if self.name == "global"
+    result
+  end
 
-        begin
-            cfg("-z", self.name, *cmd)
-        rescue Puppet::ExecutionFailure => detail
-            self.fail "Could not %s zone: %s" % [cmd[0], detail]
-        end
+  def zoneadm(*cmd)
+      adm("-z", @resource[:name], *cmd)
+  rescue Puppet::ExecutionFailure => detail
+      self.fail "Could not #{cmd[0]} zone: #{detail}"
+  end
+
+  def zonecfg(*cmd)
+    # You apparently can't get the configuration of the global zone
+    return "" if self.name == "global"
+
+    begin
+      cfg("-z", self.name, *cmd)
+    rescue Puppet::ExecutionFailure => detail
+      self.fail "Could not #{cmd[0]} zone: #{detail}"
     end
+  end
 end