puppet 0.24.6 → 0.24.7

data/lib/puppet/provider/service/redhat.rb

@@ -1,8 +1,11 @@
 # Manage Red Hat services.  Start/stop uses /sbin/service and enable/disable uses chkconfig
 
 Puppet::Type.type(:service).provide :redhat, :parent => :init do
-    desc "Red Hat's (and probably many others) form of ``init``-style service
-        management; uses ``chkconfig`` for service enabling and disabling."
+    desc "Red Hat's (and probably many others) form of ``init``-style service management:
+
+    Uses ``chkconfig`` for service enabling and disabling.
+
+  "
 
     commands :chkconfig => "/sbin/chkconfig", :service => "/sbin/service"
  

data/lib/puppet/provider/service/runit.rb

@@ -2,26 +2,36 @@
 #
 # author Brice Figureau <brice-puppet@daysofwonder.com>
 Puppet::Type.type(:service).provide :runit, :parent => :daemontools do
-    desc "Runit service management.
-    This provider manages daemons running supervised by Runit.
-    It tries to detect the service directory, with by order of preference:
-     * /service
-     * /var/service
-     * /etc/service
-    The daemon directory should be placed in a directory that can be 
-    by default in:
-     * /etc/sv
-    or this can be overriden in the service resource parameters:
-    service {
-     \"myservice\":
-       provider => \"runit\", path => \"/path/to/daemons\";
-    }
-
-    This provider supports out of the box:
-     * start/stop
-     * enable/disable
-     * restart
-     * status"
+    desc """Runit service management.
+
+  This provider manages daemons running supervised by Runit.
+  It tries to detect the service directory, with by order of preference:
+
+   * /service
+   * /var/service
+   * /etc/service
+
+  The daemon directory should be placed in a directory that can be 
+  by default in:
+
+   * /etc/sv
+
+  or this can be overriden in the service resource parameters::
+
+      service {
+       \"myservice\":
+         provider => \"runit\", path => \"/path/to/daemons\";
+      }
+
+  This provider supports out of the box:
+
+   * start/stop
+   * enable/disable
+   * restart
+   * status
+
+
+"""
 
     commands :sv => "/usr/bin/sv"
 

data/lib/puppet/provider/service/smf.rb

@@ -1,9 +1,12 @@
 # Solaris 10 SMF-style services.
 Puppet::Type.type(:service).provide :smf, :parent => :base do
-    desc "Support for Sun's new Service Management Framework.  Starting a service
-        is effectively equivalent to enabling it, so there is only support
-        for starting and stopping services, which also enables and disables them,
-        respectively."
+    desc "Support for Sun's new Service Management Framework.
+
+    Starting a service is effectively equivalent to enabling it, so there is
+    only support for starting and stopping services, which also enables and
+    disables them, respectively.
+
+  "
 
     defaultfor :operatingsystem => :solaris
 

data/lib/puppet/provider/ssh_authorized_key/parsed.rb

@@ -19,7 +19,7 @@ Puppet::Type.type(:ssh_authorized_key).provide(:parsed,
             if record[:options].nil?
                 record[:options] = [:absent]
             else
-                record[:options] = record[:options].split(',')
+                record[:options] = Puppet::Type::Ssh_authorized_key::ProviderParsed.parse_options(record[:options])
             end
         },
         :pre_gen => proc { |record|
@@ -71,5 +71,25 @@ Puppet::Type.type(:ssh_authorized_key).provide(:parsed,
             File.chown(Puppet::Util.uid(user), nil, @property_hash[:target])
         end
     end
+
+    # parse sshv2 option strings, wich is a comma separated list of
+    # either key="values" elements or bare-word elements
+    def self.parse_options(options)
+        result = []
+        scanner = StringScanner.new(options)
+        while !scanner.eos?
+            scanner.skip(/[ \t]*/)
+            # scan a long option
+            if out = scanner.scan(/[-a-z0-9A-Z_]+=\".*?\"/) or out = scanner.scan(/[-a-z0-9A-Z_]+/)
+                result << out
+            else
+                # found an unscannable token, let's abort
+                break
+            end
+            # eat a comma
+            scanner.skip(/[ \t]*,[ \t]*/)
+        end
+        result
+    end
 end
 

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

@@ -19,6 +19,7 @@ Puppet::Type.type(:user).provide :directoryservice, :parent => Puppet::Provider:
 
     commands :dscl => "/usr/bin/dscl"
     confine :operatingsystem => :darwin
+    defaultfor :operatingsystem => :darwin
     
     # JJM: DirectoryService can manage passwords.
     #      This needs to be a special option to dscl though (-passwd)

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

@@ -1,5 +1,8 @@
-# Manage NetInfo POSIX objects.  Probably only used on OS X, but I suppose
-# it could be used elsewhere.
+# Manage NetInfo POSIX objects.
+#
+# This provider has been deprecated. You should be using the directoryservice
+# nameservice provider instead.
+
 require 'puppet/provider/nameservice/netinfo'
 
 Puppet::Type.type(:user).provide :netinfo, :parent => Puppet::Provider::NameService::NetInfo do
@@ -15,7 +18,6 @@ Puppet::Type.type(:user).provide :netinfo, :parent => Puppet::Provider::NameServ
     options :comment, :key => "realname"
     options :password, :key => "passwd"
 
-    defaultfor :operatingsystem => :darwin
 
     autogen_defaults :home => "/var/empty", :shell => "/usr/bin/false", :password => '********'
 
@@ -36,6 +38,8 @@ Puppet::Type.type(:user).provide :netinfo, :parent => Puppet::Provider::NameServ
     # The list of all groups the user is a member of.  Different
     # user mgmt systems will need to override this method.
     def groups
+        warnonce "The NetInfo provider is deprecated; use directoryservice instead"
+        
         groups = []
 
         user = @resource[:name]
@@ -59,6 +63,8 @@ Puppet::Type.type(:user).provide :netinfo, :parent => Puppet::Provider::NameServ
     # This is really lame.  We have to iterate over each
     # of the groups and add us to them.
     def groups=(groups)
+        warnonce "The NetInfo provider is deprecated; use directoryservice instead"
+        
         case groups
         when Fixnum:
             groups = [groups.to_s]

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

@@ -22,17 +22,15 @@ Puppet::Type.type(:user).provide :user_role_add, :parent => :useradd do
         value !~ /\s/
     end
 
-    has_features :manages_homedir, :allows_duplicates, :manages_solaris_rbac
-
-    if Puppet.features.libshadow?
-        has_feature :manages_passwords
-    end
+    has_features :manages_homedir, :allows_duplicates, :manages_solaris_rbac, :manages_passwords
 
     #must override this to hand the keyvalue pairs
     def add_properties
         cmd = []
         Puppet::Type.type(:user).validproperties.each do |property|
-            next if property == :ensure
+            #skip the password because we can't create it with the solaris useradd
+            next if [:ensure, :password].include?(property)
+            # 1680 Now you can set the hashed passwords on solaris:lib/puppet/provider/user/user_role_add.rb
             # the value needs to be quoted, mostly because -c might
             # have spaces in it
             if value = @resource.should(property) and value != ""
@@ -87,6 +85,10 @@ Puppet::Type.type(:user).provide :user_role_add, :parent => :useradd do
         else
             run(addcmd, "create")
         end
+        # added to handle case when password is specified
+        if @resource[:password]
+            self.password = @resource[:password]
+        end
     end
 
     def destroy
@@ -152,5 +154,40 @@ Puppet::Type.type(:user).provide :user_role_add, :parent => :useradd do
     def keys=(keys_hash)
         run([command(:modify)] + build_keys_cmd(keys_hash) << @resource[:name], "modify attribute key pairs")
     end
+
+    #Read in /etc/shadow, find the line for this user (skipping comments, because who knows) and return the hashed pw (the second entry)
+    #No abstraction, all esoteric knowledge of file formats, yay
+    def password
+        #got perl?
+        if ary = File.readlines("/etc/shadow").reject { |r| r =~ /^[^\w]/}.collect { |l| l.split(':')[0..1] }.find { |user, passwd| user == @resource[:name] }
+            pass = ary[1]
+        end
+        pass
+    end
+
+    #Read in /etc/shadow, find the line for our used and rewrite it with the new pw
+    #Smooth like 80 grit
+    def password=(cryptopw)
+        begin
+            File.open("/etc/shadow", "r") do |shadow|
+                File.open("/etc/shadow_tmp", "w", 0600) do |shadow_tmp|
+                    while line = shadow.gets do
+                        line_arr = line.split(':')
+                        if line_arr[0] == @resource[:name]
+                            line_arr[1] = cryptopw
+                            line = line_arr.join(':')
+                        end
+                        shadow_tmp.print line
+                    end
+                end
+            end
+            File.rename("/etc/shadow_tmp", "/etc/shadow")
+        rescue => detail
+            fail "Could not write temporary shadow file: %s" % detail
+        ensure
+            # Make sure this *always* gets deleted
+            File.unlink("/etc/shadow_tmp") if File.exist?("/etc/shadow_tmp")
+        end
+    end
 end
 

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

@@ -0,0 +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
+    end
+
+    def create
+        zfs *([:create] + add_properties + [@resource[:name]])
+    end
+
+    def delete
+        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
+
+    [: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
+    end
+
+end
+

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

@@ -12,6 +12,7 @@ Puppet::Type.type(:zone).provide(:solaris) do
 
         properties = {}
         line.split(":").each_with_index { |value, index|
+            next unless fields[index]
             properties[fields[index]] = value
         }
 
@@ -35,9 +36,8 @@ Puppet::Type.type(:zone).provide(:solaris) do
     # Perform all of our configuration steps.
     def configure
         # If the thing is entirely absent, then we need to create the config.
-        str = %{create -b
-set zonepath=%s
-} % @resource[:path]
+        # 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.
@@ -65,7 +65,11 @@ set zonepath=%s
     end
 
     def install
-        zoneadm :install
+        if @resource[:install_args]
+            zoneadm :install, @resource[:install_args].split(" ")
+        else
+            zoneadm :install
+        end
     end
 
     # Look up the current status.

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

@@ -0,0 +1,116 @@
+Puppet::Type.type(:zpool).provide(:solaris) do
+    desc "Provider for Solaris zpool."
+
+    commands :zpool => "/usr/sbin/zpool"
+    defaultfor :operatingsystem => :solaris
+
+    def process_zpool_data(pool_array)
+        if pool_array == []
+            return Hash.new(:absent)
+        end
+        #get the name and get rid of it
+        pool = Hash.new
+        pool[:pool] = pool_array[0]
+        pool_array.shift
+
+        tmp = []
+
+        #order matters here :(
+        pool_array.reverse.each do |value|
+            sym = nil
+            case value
+            when "spares": sym = :spare
+            when "logs": sym = :log
+            when "mirror", "raidz1", "raidz2":
+                sym = value == "mirror" ? :mirror : :raidz
+                pool[:raid_parity] = "raidz2" if value == "raidz2"
+            else
+                tmp << value
+                sym = :disk if value == pool_array.first
+            end
+
+            if sym
+                pool[sym] = pool[sym] ? pool[sym].unshift(tmp.reverse.join(' ')) : [tmp.reverse.join(' ')]
+                tmp.clear
+            end
+        end
+
+        pool
+    end
+
+    def get_pool_data
+        #this is all voodoo dependent on the output from zpool
+        zpool_data = %x{ zpool status #{@resource[:pool]}}.split("\n").select { |line| line.index("\t") == 0 }.collect { |l| l.strip.split("\s")[0] }
+        zpool_data.shift
+        zpool_data
+    end
+
+    def current_pool
+        unless (defined?(@current_pool) and @current_pool)
+            @current_pool = process_zpool_data(get_pool_data)
+        end
+        @current_pool
+    end
+
+    def flush
+        @current_pool= nil
+    end
+
+    #Adds log and spare
+    def build_named(name)
+        if prop = @resource[name.intern]
+            [name] + prop.collect { |p| p.split(' ') }.flatten
+        else
+            []
+        end
+    end
+
+    #query for parity and set the right string
+    def raidzarity
+        @resource[:raid_parity] ? @resource[:raid_parity] : "raidz1"
+    end
+
+    #handle mirror or raid
+    def handle_multi_arrays(prefix, array)
+        array.collect{ |a| [prefix] +  a.split(' ') }.flatten
+    end
+
+    #builds up the vdevs for create command
+    def build_vdevs
+        if disk = @resource[:disk]
+            disk.collect { |d| d.split(' ') }.flatten
+        elsif mirror = @resource[:mirror]
+            handle_multi_arrays("mirror", mirror)
+        elsif raidz = @resource[:raidz]
+            handle_multi_arrays(raidzarity, raidz)
+        end
+    end
+
+    def create
+        zpool(*([:create, @resource[:pool]] + build_vdevs + build_named("spare") + build_named("log")))
+    end
+
+    def delete
+        zpool :destroy, @resource[:pool]
+    end
+
+    def exists?
+        if current_pool[:pool] == :absent
+            false
+        else
+            true
+        end
+    end
+
+    [:disk, :mirror, :raidz, :log, :spare].each do |field|
+        define_method(field) do
+            current_pool[field]
+        end
+
+        define_method(field.to_s + "=") do |should|
+            Puppet.warning "NO CHANGES BEING MADE: zpool %s does not match, should be '%s' currently is '%s'" % [field, should, current_pool[field]]
+        end
+    end
+
+end
+

data/lib/puppet/rails/database/003_add_environment_to_host.rb

@@ -0,0 +1,9 @@
+class AddEnvironmentToHost < ActiveRecord::Migration
+    def self.up
+        add_column :hosts, :environment, :string
+    end
+    
+    def self.down
+        remove_column :hosts, :environment
+    end
+end