puppet 0.24.5 → 0.24.6

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

@@ -0,0 +1,154 @@
+# Daemontools service management
+#
+# author Brice Figureau <brice-puppet@daysofwonder.com>
+Puppet::Type.type(:service).provide :daemontools, :parent => :base do
+    desc "Daemontools service management.
+    This provider manages daemons running supervised by D.J.Bernstein daemontools.
+    It tries to detect the service directory, with by order of preference:
+     * /service
+     * /etc/service
+     * /var/lib/svscan
+    The daemon directory should be placed in a directory that can be 
+    by default in:
+     * /var/lib/service
+     * /etc
+    or this can be overriden in the service resource parameters:
+    service {
+     \"myservice\":
+       provider => \"daemontools\", path => \"/path/to/daemons\";
+    }
+
+    This provider supports out of the box:
+     * start/stop (mapped to enable/disable)
+     * enable/disable
+     * restart
+     * status"
+
+    commands :svc  => "/usr/bin/svc"
+    commands :svstat => "/usr/bin/svstat"
+
+    class << self
+        attr_writer :defpath
+        
+        # this is necessary to autodetect a valid resource
+        # default path, since there is no standard for such directory.
+        def defpath
+            unless defined?(@defpath) and @defpath
+                ["/var/lib/service", "/etc"].each do |path|
+                    if FileTest.exist?(path)
+                        @defpath = path
+                        break
+                    end
+                end
+                raise "Could not find the daemon directory (tested [/var/lib/service,/etc])" unless @defpath
+            end
+            @defpath
+        end
+    end
+
+    attr_writer :servicedir
+
+    # returns all providers for all existing services in @defpath
+    # ie enabled or not
+    def self.instances
+        path = self.defpath
+        unless FileTest.directory?(path)
+            Puppet.notice "Service path %s does not exist" % path
+            next
+        end
+
+        # reject entries that aren't either a directory
+        # or don't contain a run file
+        Dir.entries(path).reject { |e|
+            fullpath = File.join(path, e)
+            e =~ /^\./ or ! FileTest.directory?(fullpath) or ! FileTest.exist?(File.join(fullpath,"run"))
+        }.collect do |name|
+            new(:name => name, :path => path)
+        end
+    end
+
+    # returns the daemon dir on this node
+    def self.daemondir
+        self.defpath
+    end
+
+    # find the service dir on this node
+    def servicedir
+      unless defined?(@servicedir) and @servicedir
+        ["/service", "/etc/service","/var/lib/svscan"].each do |path|
+            if FileTest.exist?(path)
+                @servicedir = path
+                break
+            end
+        end
+        raise "Could not find service directory" unless @servicedir
+      end
+      @servicedir
+    end
+
+    # returns the full path of this service when enabled
+    # (ie in the service directory)
+    def service
+        File.join(self.servicedir, resource[:name])
+    end
+
+    # returns the full path to the current daemon directory
+    # note that this path can be overriden in the resource
+    # definition
+    def daemon
+        File.join(resource[:path], resource[:name])
+    end
+    
+    def restartcmd
+        [ command(:svc), "-t", self.service]
+    end
+
+    # The start command does nothing, service are automatically started
+    # when enabled by svscan. But, forces an enable if necessary
+    def start
+        # to start make sure the sevice is enabled
+        self.enable
+        # start is then automatic
+    end
+
+    def status
+        begin
+            output = svstat self.service
+            return :running if output =~ /\bup\b/
+        rescue Puppet::ExecutionFailure => detail
+            raise Puppet::Error.new( "Could not get status for service %s: %s" % [ resource.ref, detail] )
+        end
+        return :stopped
+    end
+
+    # unfortunately it is not possible
+    # to stop without disabling the service
+    def stop
+        self.disable
+    end
+
+    # disable by stopping the service
+    # and removing the symlink so that svscan
+    # doesn't restart our service behind our back
+    def disable
+        # should stop the service
+        # stop the log subservice if any
+        log = File.join(self.service, "log")
+        texecute("stop log", [ command(:svc) , '-dx', log] ) if FileTest.directory?(log)
+        
+        # stop the main resource
+        texecute("stop", [command(:svc), '-dx', self.service] )
+
+        # unlink the daemon symlink to disable it
+        File.unlink(self.service) if FileTest.symlink?(self.service)
+    end
+
+    def enabled?
+        FileTest.symlink?(self.service)
+    end
+
+    def enable
+        File.symlink(self.daemon, self.service) if ! FileTest.symlink?(self.service)
+    end
+end
+

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

@@ -5,7 +5,7 @@ Puppet::Type.type(:service).provide :debian, :parent => :init do
         is that this supports service enabling and disabling via ``update-rc.d``."
 
     commands :update => "/usr/sbin/update-rc.d"
-    defaultfor :operatingsystem => :debian
+    defaultfor :operatingsystem => [:debian, :ubuntu]
 
     def self.defpath
         superclass.defpath

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

@@ -2,6 +2,8 @@
 Puppet::Type.type(:service).provide :freebsd, :parent => :init do
     desc "FreeBSD's (and probably NetBSD?) form of ``init``-style service
         management; uses ``rc.conf.d`` for service enabling and disabling."
+ 
+    confine :operatingsystem => [:freebsd, :netbsd, :openbsd]
 
     defaultfor :operatingsystem => :freebsd
 

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

@@ -6,6 +6,8 @@ Puppet::Type.type(:service).provide :gentoo, :parent => :init do
 
     commands :update => "/sbin/rc-update"
 
+    confine :operatingsystem => :gentoo
+
     defaultfor :operatingsystem => :gentoo
 
     def self.defpath

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

@@ -6,7 +6,7 @@ Puppet::Type.type(:service).provide :redhat, :parent => :init do
 
     commands :chkconfig => "/sbin/chkconfig", :service => "/sbin/service"
  
-    defaultfor :operatingsystem => [:redhat, :fedora, :suse, :centos]
+    defaultfor :operatingsystem => [:redhat, :fedora, :suse, :centos, :sles]
 
     def self.defpath
         superclass.defpath

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

@@ -0,0 +1,93 @@
+# Daemontools service management
+#
+# 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"
+
+    commands :sv => "/usr/bin/sv"
+
+    class << self
+        # this is necessary to autodetect a valid resource
+        # default path, since there is no standard for such directory.
+        def defpath
+            unless defined?(@defpath) and @defpath
+                ["/etc/sv", "/var/lib/service"].each do |path|
+                    if FileTest.exist?(path)
+                        @defpath = path
+                        break
+                    end
+                end
+                raise "Could not find the daemon directory (tested [/var/lib/service,/etc])" unless @defpath
+            end
+            @defpath
+        end
+    end
+
+    # find the service dir on this node
+    def servicedir
+      unless defined?(@servicedir) and @servicedir
+        ["/service", "/etc/service","/var/service"].each do |path|
+            if FileTest.exist?(path)
+                @servicedir = path
+                break
+            end
+        end
+        raise "Could not find service directory" unless @servicedir
+      end
+      @servicedir
+    end
+
+    def restartcmd
+        [ command(:sv), "restart", self.service]
+    end
+
+    def status
+        begin
+            output = sv "status", self.daemon
+            return :running if output =~ /^run: /
+        rescue Puppet::ExecutionFailure => detail
+            unless detail.message =~ /(warning: |runsv not running$)/
+                raise Puppet::Error.new( "Could not get status for service %s: %s" % [ resource.ref, detail] )
+            end
+        end
+        return :stopped
+    end
+
+    # relay to the stopcmd
+    def stop
+        ucommand( :stop )
+    end
+
+    def stopcmd
+        [ command(:sv), "stop", self.service]
+    end
+
+    # disable by removing the symlink so that runit
+    # doesn't restart our service behind our back
+    # note that runit doesn't need to perform a stop
+    # before a disable
+    def disable
+        # unlink the daemon symlink to disable it
+        File.unlink(self.service) if FileTest.symlink?(self.service)
+    end
+end
+

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

@@ -7,6 +7,8 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
 
     defaultfor :operatingsystem => :solaris
 
+    confine :operatingsystem => :solaris
+
     commands :adm => "/usr/sbin/svcadm", :svcs => "/usr/bin/svcs"
 
     def enable

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

@@ -14,7 +14,7 @@ Puppet::Type.type(:ssh_authorized_key).provide(:parsed,
         :fields   => %w{options type key name},
         :optional => %w{options},
         :rts => /^\s+/,
-        :match    => /^(?:([^ ]+) )?(ssh-dss|ssh-rsa) ([^ ]+)(?: (.+))?$/,
+        :match    => /^(?:(.+) )?(ssh-dss|ssh-rsa) ([^ ]+)(?: (.+))?$/,
         :post_parse => proc { |record|
             if record[:options].nil?
                 record[:options] = [:absent]
@@ -30,6 +30,12 @@ Puppet::Type.type(:ssh_authorized_key).provide(:parsed,
             end
         }
 
+    record_line :key_v1,
+        :fields   => %w{options bits exponent modulus name},
+        :optional => %w{options},
+        :rts      => /^\s+/,
+        :match    => /^(?:(.+) )?(\d+) (\d+) (\d+)(?: (.+))?$/
+
     def prefetch
         # This was done in the type class but path expansion was failing for
         # not yet existing users, the only workaround I found was to move that

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

@@ -0,0 +1,30 @@
+Puppet::Type.type(:user).provide :hpuxuseradd, :parent => :useradd do
+    desc "User management for hp-ux! Undocumented switch to special usermod because HP-UX regular usermod is TOO STUPID to change stuff while the user is logged in."
+
+    defaultfor :operatingsystem => "hp-ux"
+    confine :operatingsystem => "hp-ux"
+    
+    commands :modify => "/usr/sam/lbin/usermod.sam", :delete => "/usr/sam/lbin/userdel.sam", :add => "/usr/sbin/useradd"
+    options :comment, :method => :gecos
+    options :groups, :flag => "-G"
+    options :home, :flag => "-d", :method => :dir
+
+    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
+
+    has_features :manages_homedir, :allows_duplicates
+
+    def deletecmd
+	super.insert(1,"-F")
+    end
+
+    def modifycmd(param,value)
+	super.insert(1,"-F")
+    end
+
+end

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

@@ -0,0 +1,156 @@
+require 'puppet/util/user_attr'
+
+Puppet::Type.type(:user).provide :user_role_add, :parent => :useradd do
+
+    desc "User management inherits ``useradd`` and adds logic to manage roles on Solaris using roleadd."
+
+    defaultfor :operatingsystem => :solaris
+
+    commands :add => "useradd", :delete => "userdel", :modify => "usermod", :role_add => "roleadd", :role_delete => "roledel", :role_modify => "rolemod"
+    options :home, :flag => "-d", :method => :dir
+    options :comment, :method => :gecos
+    options :groups, :flag => "-G"
+    options :roles, :flag => "-R"
+    options :auths, :flag => "-A"
+    options :profiles, :flag => "-P"
+
+    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
+
+    has_features :manages_homedir, :allows_duplicates, :manages_solaris_rbac
+
+    if Puppet.features.libshadow?
+        has_feature :manages_passwords
+    end
+
+    #must override this to hand the keyvalue pairs
+    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 != ""
+                if property == :keys
+                    cmd += build_keys_cmd(value)
+                else
+                    cmd << flag(property) << value
+                end
+            end
+        end
+        cmd
+    end
+
+    def user_attributes
+        @user_attributes ||= UserAttr.get_attributes_by_name(@resource[:name])
+    end
+
+    def flush
+        @user_attributes = nil
+    end
+
+    def command(cmd)
+        if is_role? or (!exists? and @resource[:ensure] == :role)
+            cmd = ("role_" + cmd.to_s).intern
+        end
+        super(cmd)
+    end
+
+    def is_role?
+        user_attributes and user_attributes[:type] == "role"
+    end
+
+    def run(cmd, msg)
+        begin
+            execute(cmd)
+        rescue Puppet::ExecutionFailure => detail
+            raise Puppet::Error, "Could not %s %s %s: %s" %
+                [msg, @resource.class.name, @resource.name, detail]
+        end
+    end
+
+    def transition(type)
+        cmd = [command(:modify)]
+        cmd << "-K" << "type=#{type}"
+        cmd += add_properties
+        cmd << @resource[:name]
+    end
+
+    def create
+        if is_role?
+            run(transition("normal"), "transition role to")
+        else
+            run(addcmd, "create")
+        end
+    end
+
+    def destroy
+        run(deletecmd, "delete "+ (is_role? ? "role" : "user"))
+    end
+
+    def create_role
+        if exists? and !is_role?
+            run(transition("role"), "transition user to")
+        else
+            run(addcmd, "create role")
+        end
+    end
+
+    def roles
+        if user_attributes
+            user_attributes[:roles]
+        end
+    end
+
+    def auths
+        if user_attributes
+            user_attributes[:auths]
+        end
+    end
+
+    def profiles
+        if user_attributes
+            user_attributes[:profiles]
+        end
+    end
+
+    def project
+        if user_attributes
+            user_attributes[:project]
+        end
+    end
+
+    def managed_attributes
+        [:name, :type, :roles, :auths, :profiles, :project]
+    end
+
+    def remove_managed_attributes
+        managed = managed_attributes
+        user_attributes.select { |k,v| !managed.include?(k) }.inject({}) { |hash, array| hash[array[0]] = array[1]; hash }
+    end
+
+    def keys
+        if user_attributes
+            #we have to get rid of all the keys we are managing another way
+            remove_managed_attributes
+        end
+    end
+
+    def build_keys_cmd(keys_hash)
+        cmd = []
+        keys_hash.each do |k,v|
+            cmd << "-K" << "#{k}=#{v}"
+        end
+        cmd
+    end
+
+    def keys=(keys_hash)
+        run([command(:modify)] + build_keys_cmd(keys_hash) << @resource[:name], "modify attribute key pairs")
+    end
+end
+