puppet 0.13.6 → 0.16.0

data/lib/puppet/type/package/sun.rb

@@ -1,34 +1,7 @@
 module Puppet
-    Puppet.type(:package).newpkgtype(:sunpkg) do
-        def install
-            unless self[:source]
-                raise Puppet::Error, "Sun packages must specify a package source"
-            end
-            #cmd = "pkgadd -d %s -n %s 2>&1" % [self[:source], self[:name]]
-            cmd = ["pkgadd"]
-
-            if self[:adminfile]
-                cmd += ["-a", self[:adminfile]]
-            end
-
-            if self[:responsefile]
-                cmd += ["-r", self[:responsefile]]
-            end
-
-            cmd += ["-d", self[:source]]
-            cmd += ["-n", self[:name]]
-            cmd << "2>&1"
-            cmd = cmd.join(" ")
-
-            self.info "Executing %s" % cmd.inspect
-            output = %x{#{cmd} 2>&1}
-
-            unless $? == 0
-                raise Puppet::PackageError.new(output)
-            end
-        end
-
-        def query
+    Puppet.type(:package).newpkgtype(:sun) do
+        # Get info on a package, optionally specifying a device.
+        def info2hash(device = nil)
             names = {
                 "PKGINST" => :name,
                 "NAME" => nil,
@@ -48,9 +21,14 @@ module Puppet
             }
 
             hash = {}
+            cmd = "pkginfo -l"
+            if device
+                cmd += " -d #{device}"
+            end
+            cmd += " #{self[:name]} 2>/dev/null"
 
             # list out all of the packages
-            open("| pkginfo -l %s 2>/dev/null" % self[:name]) { |process|
+            open("| #{cmd}") { |process|
                 # we're using the long listing, so each line is a separate
                 # piece of information
                 process.each { |line|
@@ -79,6 +57,39 @@ module Puppet
             end
         end
 
+        def install
+            unless self[:source]
+                raise Puppet::Error, "Sun packages must specify a package source"
+            end
+            cmd = ["pkgadd"]
+
+            if self[:adminfile]
+                cmd += ["-a", self[:adminfile]]
+            end
+
+            if self[:responsefile]
+                cmd += ["-r", self[:responsefile]]
+            end
+
+            cmd += ["-d", self[:source]]
+            cmd += ["-n", self[:name]]
+            cmd << "2>&1"
+            cmd = cmd.join(" ")
+
+            self.info "Executing %s" % cmd.inspect
+            output = %x{#{cmd} 2>&1}
+
+            unless $? == 0
+                raise Puppet::PackageError.new(output)
+            end
+        end
+
+        # Retrieve the version from the current package file.
+        def latest
+            hash = info2hash(self[:source])
+            hash[:ensure]
+        end
+
         def list
             packages = []
             hash = {}
@@ -126,11 +137,9 @@ module Puppet
             return packages
         end
 
-        # we need package retrieval mechanisms before we can have package
-        # installation mechanisms...
-        #type.install = proc { |pkg|
-        #    raise "installation not implemented yet"
-        #}
+        def query
+            info2hash()
+        end
 
         def uninstall
             cmd = "pkgrm -n %s 2>&1" % self[:name]
@@ -139,5 +148,13 @@ module Puppet
                 raise Puppet::Error, "Removal of %s failed: %s" % [self.name, output]
             end
         end
+
+        # Remove the old package, and install the new one
+        def update
+            if @states[:ensure].is != :absent
+                self.uninstall
+            end
+            self.install
+        end
     end
 end

data/lib/puppet/type/package/yum.rb

@@ -1,6 +1,5 @@
 module Puppet
     Puppet.type(:package).newpkgtype(:yum, :rpm) do
-
         # Install a package using 'yum'.
         def install
             cmd = "yum -y install %s" % self[:name]
@@ -15,7 +14,7 @@ module Puppet
 
         # What's the latest package version available?
         def latest
-            cmd = "yum list updates %s" % self[:name] 
+            cmd = "yum list available %s" % self[:name] 
             self.info "Executing %s" % cmd.inspect
             output = %x{#{cmd} 2>&1}
 
@@ -33,20 +32,8 @@ module Puppet
         end
 
         def update
-            # Yum can't update packages that aren't there; we have to install
-            # them first
-            if self.is(:ensure) == :absent
-                self.info "performing initial install"
-                return self.install
-            end
-            cmd = "yum -y update %s" % self[:name]
-
-            self.info "Executing %s" % cmd.inspect
-            output = %x{#{cmd} 2>&1}
-
-            unless $? == 0
-                raise Puppet::PackageError.new(output)
-            end
+            # Install in yum can be used for update, too
+            self.install
         end
 
         def versionable?
@@ -54,3 +41,5 @@ module Puppet
         end
     end
 end
+
+# $Id: yum.rb 1128 2006-04-21 03:06:54Z luke $

data/lib/puppet/type/parsedtype.rb

@@ -123,13 +123,6 @@ module Puppet
                 super
             end
 
-            # Override the Puppet::Type#[]= method so that we can store the
-            # instances in per-user arrays.  Then just call +super+.
-            def self.[]=(name, object)
-                self.instance(object)
-                super
-            end
-
             # In addition to removing the instances in @objects, we have to remove
             # per-user host tab information.
             def self.clear
@@ -138,6 +131,11 @@ module Puppet
                 super
             end
 
+            # Add a non-object comment or whatever to our list of instances
+            def self.comment(line)
+                @instances << line
+            end
+
             # Override the default Puppet::Type method, because instances
             # also need to be deleted from the @instances hash
             def self.delete(child)
@@ -155,13 +153,6 @@ module Puppet
 # HEADER: is definitely not recommended.\n}
             end
 
-            # Store a new instance of a host.  Called from Host#initialize.
-            def self.instance(obj)
-                unless @instances.include?(obj)
-                    @instances << obj
-                end
-            end
-
             # Parse a file
             #
             # Subclasses must override this method.
@@ -174,12 +165,13 @@ module Puppet
             def self.hash2obj(hash)
                 obj = nil
 
-                unless hash.include?(:name) and hash[:name]
-                    raise Puppet::DevError, "Hash was not passed with name"
+                namevar = self.namevar
+                unless hash.include?(namevar) and hash[namevar]
+                    raise Puppet::DevError, "Hash was not passed with namevar"
                 end
 
                 # if the obj already exists with that name...
-                if obj = self[hash[:name]]
+                if obj = self[hash[namevar]]
                     # We're assuming here that objects with the same name
                     # are the same object, which *should* be the case, assuming
                     # we've set up our naming stuff correctly everywhere.
@@ -200,15 +192,27 @@ module Puppet
                 else
                     # create a new obj, since no existing one seems to
                     # match
-                    obj = self.create(:name => hash[:name])
+                    obj = self.create(namevar => hash[namevar])
 
                     # We can't just pass the hash in at object creation time,
                     # because it sets the should value, not the is value.
-                    hash.delete(:name)
+                    hash.delete(namevar)
                     hash.each { |param, value|
                         obj.is = [param, value]
                     }
                 end
+
+                # And then add it to our list of instances.  This maintains the order
+                # in the file.
+                @instances << obj
+            end
+
+            def self.list
+                retrieve
+
+                self.collect do |obj|
+                    obj
+                end
             end
 
             # Retrieve the text for the file. Returns nil in the unlikely
@@ -223,10 +227,11 @@ module Puppet
                     # First we mark all of our objects absent; any objects
                     # subsequently found will be marked present
                     self.each { |obj|
-                        obj.each { |state|
-                            state.is = :absent
-                        }
+                        obj.is = [:ensure, :absent]
                     }
+                    
+                    # We clear this, so that non-objects don't get duplicated
+                    @instances.clear
                     self.parse(text)
                 end
             end
@@ -235,6 +240,11 @@ module Puppet
             def self.store
                 @fileobj ||= @filetype.new(@path)
 
+                # Make sure all of our instances are in the to-be-written array
+                self.each do |inst|
+                    @instances << inst unless @instances.include? inst
+                end
+
                 if @instances.empty?
                     Puppet.notice "No %s instances for %s" % [self.name, @path]
                 else
@@ -275,8 +285,13 @@ module Puppet
                 @fileobj.loaded
             end
 
+            # The 'store' method knows how to handle absence vs. presence
             def create
-                self[:ensure] = :present
+                self.store
+            end
+
+            # The 'store' method knows how to handle absence vs. presence
+            def destroy
                 self.store
             end
 
@@ -285,11 +300,6 @@ module Puppet
                 @states.include?(:ensure) and @states[:ensure].is == :present
             end
 
-            def destroy
-                self[:ensure] = :absent
-                self.store
-            end
-
             # Override the default Puppet::Type method because we need to call
             # the +@filetype+ retrieve method.
             def retrieve
@@ -326,5 +336,7 @@ end
 
 require 'puppet/type/parsedtype/host'
 require 'puppet/type/parsedtype/port'
+require 'puppet/type/parsedtype/mount'
+require 'puppet/type/parsedtype/sshkey'
 
-# $Id: parsedtype.rb 915 2006-02-15 21:56:54Z luke $
+# $Id: parsedtype.rb 1125 2006-04-20 19:38:48Z luke $

data/lib/puppet/type/parsedtype/host.rb

@@ -35,7 +35,11 @@ module Puppet
             # value.
             def should
                 if defined? @should
-                    return @should
+                    if @should == [:absent]
+                        return :absent
+                    else
+                        return @should
+                    end
                 else
                     return []
                 end
@@ -52,9 +56,13 @@ module Puppet
             end
 
             munge do |value|
-                # Add the :alias metaparam in addition to the state
-                @parent.newmetaparam(@parent.class.metaparamclass(:alias), value)
-                value
+                if value == :absent or value == "absent"
+                    :absent
+                else
+                    # Add the :alias metaparam in addition to the state
+                    @parent.newmetaparam(@parent.class.metaparamclass(:alias), value)
+                    value
+                end
             end
         end
 
@@ -133,4 +141,4 @@ module Puppet
     end
 end
 
-# $Id: host.rb 910 2006-02-15 07:20:36Z luke $
+# $Id: host.rb 1124 2006-04-20 07:00:10Z luke $

data/lib/puppet/type/parsedtype/mount.rb

@@ -0,0 +1,250 @@
+require 'etc'
+require 'facter'
+require 'puppet/type/parsedtype'
+require 'puppet/type/state'
+
+module Puppet
+    newtype(:mount, Puppet::Type::ParsedType) do
+        ensurable do
+            desc "Create, remove, or mount a filesystem mount."
+
+            newvalue(:present) do
+                @parent.create()
+            end
+
+            newvalue(:absent) do
+                @parent.destroy()
+
+                if @parent.mounted?
+                    @parent.unmount
+                end
+
+                :mount_removed
+            end
+
+            newvalue(:mounted) do
+                if @is == :absent
+                    set_present
+                end
+
+                @parent.mount
+
+                :mount_mounted
+            end
+
+            def retrieve
+                if @parent.mounted?
+                    @is = :mounted
+                else
+                    val = super()
+                    @is = val
+                end
+            end
+        end
+
+        newstate(:device) do
+            desc "The device providing the mount.  This can be whatever
+                device is supporting by the mount, including network
+                devices or devices specified by UUID rather than device
+                path, depending on the operating system."
+        end
+
+        # Solaris specifies two devices, not just one.
+        newstate(:blockdevice) do
+            desc "The the device to fsck.  This is state is only valid
+                on Solaris, and in most cases will default to the correct
+                value."
+
+            # Default to the device but with "dsk" replaced with "rdsk".
+            defaultto do
+                if Facter["operatingsystem"].value == "Solaris"
+                    device = @parent.value(:device)
+                    if device =~ %r{/dsk/}
+                        device.sub(%r{/dsk/}, "/rdsk/")
+                    else
+                        nil
+                    end
+                else
+                    nil
+                end
+            end
+        end
+
+        newstate(:fstype) do
+            desc "The mount type.  Valid values depend on the
+                operating system."
+        end
+
+        newstate(:options) do
+            desc "Mount options for the mounts, as they would
+                appear in the fstab."
+        end
+
+        newstate(:pass) do
+            desc "The pass in which the mount is checked."
+        end
+
+        newstate(:atboot) do
+            desc "Whether to mount the mount at boot.  Not all platforms
+                support this."
+        end
+
+        newstate(:dump) do
+            desc "Whether to dump the mount.  Not all platforms
+                support this."
+        end
+
+        newparam(:path) do
+            desc "The mount path for the mount."
+
+            isnamevar
+        end
+
+        @doc = "Manages mounted mounts, including putting mount
+            information into the mount table."
+
+        @instances = []
+
+        @platform = Facter["operatingsystem"].value
+        case @platform
+        when "Solaris":
+            @path = "/etc/vfstab"
+            @fields = [:device, :blockdevice, :path, :fstype, :pass, :atboot,
+                :options]
+        when "Darwin":
+            @filetype = Puppet::FileType.filetype(:netinfo)
+            @filetype.format = "fstab"
+            @path = "mounts"
+            @fields = [:device, :path, :fstype, :options, :dump, :pass]
+
+            # How to map the dumped table to what we want
+            @fieldnames = {
+                "name" => :device,
+                "dir" => :path,
+                "dump_freq" => :dump,
+                "passno" => :pass,
+                "vfstype" => :fstype,
+                "opts" => :options
+            }
+        else
+            @path = "/etc/fstab"
+            @fields = [:device, :path, :fstype, :options, :dump, :pass]
+        end
+
+        # Allow Darwin to override the default filetype
+        unless defined? @filetype
+            @filetype = Puppet::FileType.filetype(:flat)
+        end
+
+        # Parse a mount tab.
+        #
+        # This method also stores existing comments, and it stores all
+        # mounts in order, mostly so that comments are retained in the
+        # order they were written and in proximity to the same fses.
+        def self.parse(text)
+            # provide a single exception for darwin & netinfo
+            if @filetype == Puppet::FileType.filetype(:netinfo)
+                parseninfo(text)
+                return 
+            end
+            count = 0
+            hash = {}
+            text.chomp.split("\n").each { |line|
+                case line
+                when /^#/, /^\s*$/:
+                    # add comments and blank lines to the list as they are
+                    comment(line)
+                else
+                    values = line.split(/\s+/)
+                    unless @fields.length == values.length
+                        raise Puppet::Error, "Could not parse line %s" % line
+                    end
+
+                    @fields.zip(values).each do |field, value|
+                        hash[field] = value
+                    end
+
+                    hash2obj(hash)
+
+                    hash.clear
+                    count += 1
+                end
+            }
+        end
+
+        # Parse a netinfo table.
+        def self.parseninfo(text)
+            array = @fileobj.to_array(text)
+
+            hash = {}
+            array.each do |record|
+                @fieldnames.each do |name, field|
+                    if value = record[name]
+                        if field == :options
+                            hash[field] = value.join(",")
+                        else
+                            hash[field] = value[0]
+                        end
+                    else
+                        raise ArgumentError, "Field %s was not provided" % [name]
+                    end
+                end
+
+
+                hash2obj(hash)
+                hash.clear
+            end
+        end
+
+        # This only works when the mount point is synced to the fstab.
+        def mount
+            output = %x{mount #{self[:path]} 2>&1}
+
+            unless $? == 0
+                raise Puppet::Error, "Could not mount %s: %s" % [self[:path], output]
+            end
+        end
+
+        # This only works when the mount point is synced to the fstab.
+        def unmount
+            output = %x{umount #{self[:path]}}
+
+            unless $? == 0
+                raise Puppet::Error, "Could not mount %s" % self[:path]
+            end
+        end
+
+        # Is the mount currently mounted?
+        def mounted?
+            platform = Facter["operatingsystem"].value
+            df = "df"
+            case Facter["operatingsystem"].value
+            # Solaris's df prints in a very weird format
+            when "Solaris": df = "df -k"
+            end
+            %x{#{df}}.split("\n").find do |line|
+                fs = line.split(/\s+/)[-1]
+                if platform == "Darwin"
+                    fs == "/private/var/automount" + self[:path] or
+                        fs == self[:path]
+                else
+                    fs == self[:path]
+                end
+            end
+        end
+
+        # Convert the current object into an fstab-style string.
+        def to_record
+            self.class.fields.collect do |field|
+                if value = self.value(field)
+                    value
+                else
+                    raise Puppet::Error,
+                        "Could not retrieve value for %s" % field
+                end
+            end.join("\t")
+        end
+    end
+end
+
+# $Id: mount.rb 1113 2006-04-17 16:15:33Z luke $