puppet 0.18.4 → 0.22.4

data/lib/puppet/provider/package/sunfreeware.rb

@@ -0,0 +1,9 @@
+# At this point, it's an exact copy of the Blastwave stuff.
+Puppet::Type.type(:package).provide :sunfreeware, :parent => :blastwave do
+    desc "Package management using sunfreeware.com's ``pkg-get`` command on Solaris.
+        At this point, support is exactly the same as ``blastwave`` support and
+        has not actually been tested."
+    commands :pkgget => "pkg-get"
+end
+
+# $Id: sunfreeware.rb 1571 2006-09-06 04:49:45Z luke $

data/lib/puppet/provider/package/up2date.rb

@@ -0,0 +1,45 @@
+Puppet.type(:package).provide :up2date, :parent => :rpm do
+    desc "Support for Red Hat's proprietary ``up2date`` package update
+        mechanism."
+
+    commands :up2date => "/usr/sbin/up2date-nox"
+    defaultfor :operatingsystem => :redhat, 
+               :lsbdistrelease => ["2.1", "3", "4"]
+    confine    :operatingsystem => :redhat
+
+    # Install a package using 'up2date'.
+    def install
+        up2date "-u", @model[:name]
+
+        unless self.query
+            raise Puppet::ExecutionFailure.new(
+                "Could not find package %s" % self.name
+            )
+        end
+    end
+
+    # What's the latest package version available?
+    def latest
+        #up2date can only get a list of *all* available packages?
+        output = up2date "--show-available"
+
+        if output =~ /#{@model[:name]}-(\d+.*)\.\w+/
+            return $1
+        else
+            # up2date didn't find updates, pretend the current
+            # version is the latest
+            return @model.is(:ensure)
+        end
+    end
+
+    def update
+        # Install in up2date can be used for update, too
+        self.install
+    end
+
+    def versionable?
+        false
+    end
+end
+
+# $Id: up2date.rb 2233 2007-02-27 23:16:54Z lutter $

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

@@ -0,0 +1,54 @@
+Puppet::Type.type(:package).provide :yum, :parent => :rpm do
+    desc "Support via ``yum``."
+    commands :yum => "yum", :rpm => "rpm"
+
+    defaultfor :operatingsystem => [:fedora, :centos, :redhat]
+
+    def install
+
+        should = @model.should(:ensure)
+	self.debug "Ensuring => #{should}"
+	wanted = @model[:name]
+
+	# XXX: We don't actually deal with epochs here.
+        case should
+        when true, false, Symbol
+            # pass
+        else
+            # Add the package version
+            wanted += "-%s" % should
+        end
+
+        output = yum "-d", "0", "-e", "0", "-y", :install, wanted
+
+        unless self.query
+            raise Puppet::Error.new(
+                "Could not find package %s" % self.name
+            )
+        end
+    end
+
+    # What's the latest package version available?
+    def latest
+        output = yum "-d", "0", "-e", "0", :list, :available, @model[:name]
+
+        if output =~ /^#{@model[:name]}\S+\s+(\S+)\s/
+            return $1
+        else
+            # Yum didn't find updates, pretend the current
+            # version is the latest
+            return @model[:ensure]
+        end
+    end
+
+    def update
+        # Install in yum can be used for update, too
+        self.install
+    end
+
+    def versionable?
+	true
+    end
+end
+
+# $Id: yum.rb 2235 2007-02-27 23:18:52Z luke $

data/lib/puppet/provider/parsedfile.rb

@@ -0,0 +1,342 @@
+require 'puppet'
+require 'puppet/util/filetype'
+require 'puppet/util/fileparsing'
+
+# This provider can be used as the parent class for a provider that
+# parses and generates files.  Its content must be loaded via the
+# 'prefetch' method, and the file will be written when 'flush' is called
+# on the provider instance.  At this point, the file is written once
+# for every provider instance.
+#
+# Once the provider prefetches the data, it's the model's job to copy
+# that data over to the @is variables.
+class Puppet::Provider::ParsedFile < Puppet::Provider
+    extend Puppet::Util::FileParsing
+
+    class << self
+        attr_accessor :default_target, :target
+    end
+
+    attr_accessor :property_hash
+
+    def self.clean(hash)
+        newhash = hash.dup
+        [:record_type, :on_disk].each do |p|
+            if newhash.include?(p)
+                newhash.delete(p)
+            end
+        end
+
+        return newhash
+    end
+
+    def self.clear
+        @target_objects.clear
+        @records.clear
+    end
+
+    def self.filetype
+        unless defined? @filetype
+            @filetype = Puppet::Util::FileType.filetype(:flat)
+        end
+        return @filetype
+    end
+
+    def self.filetype=(type)
+        if type.is_a?(Class)
+            @filetype = type
+        elsif klass = Puppet::Util::FileType.filetype(type)
+            @filetype = klass
+        else
+            raise ArgumentError, "Invalid filetype %s" % type
+        end
+    end
+
+    # Flush all of the targets for which there are modified records.  The only
+    # reason we pass a record here is so that we can add it to the stack if
+    # necessary -- it's passed from the instance calling 'flush'.
+    def self.flush(record)
+        # Make sure this record is on the list to be flushed.
+        unless record[:on_disk]
+            record[:on_disk] = true
+            @records << record
+
+            # If we've just added the record, then make sure our
+            # target will get flushed.
+            modified(record[:target] || default_target)
+        end
+
+        return unless defined?(@modified) and ! @modified.empty?
+
+        flushed = []
+        @modified.sort { |a,b| a.to_s <=> b.to_s }.uniq.each do |target|
+            Puppet.debug "Flushing %s provider target %s" % [@model.name, target]
+            flush_target(target)
+            flushed << target
+        end
+
+        @modified.reject! { |t| flushed.include?(t) }
+    end
+
+    # Flush all of the records relating to a specific target.
+    def self.flush_target(target)
+        records = target_records(target).reject { |r|
+            r[:ensure] == :absent
+        }
+        target_object(target).write(to_file(records))
+    end
+
+    # Return the header placed at the top of each generated file, warning
+    # users that modifying this file manually is probably a bad idea.
+    def self.header
+%{# HEADER: This file was autogenerated at #{Time.now}
+# HEADER: by puppet.  While it can still be managed manually, it
+# HEADER: is definitely not recommended.\n}
+    end
+
+    # Add another type var.
+    def self.initvars
+        @records = []
+        @target_objects = {}
+
+        @target = nil
+
+        # Default to flat files
+        @filetype ||= Puppet::Util::FileType.filetype(:flat)
+        super
+    end
+
+    # Return a list of all of the records we can find.
+    def self.list
+        prefetch()
+        @records.find_all { |r| r[:record_type] == self.name }.collect { |r|
+            clean(r)
+        }
+    end
+
+    def self.list_by_name
+        list.collect { |r| r[:name] }
+    end
+
+    # Override the default method with a lot more functionality.
+    def self.mkmodelmethods
+        [model.validproperties, model.parameters].flatten.each do |attr|
+            attr = symbolize(attr)
+            define_method(attr) do
+                # If it's not a valid field for this record type (which can happen
+                # when different platforms support different fields), then just
+                # return the should value, so the model shuts up.
+                if @property_hash[attr] or self.class.valid_attr?(self.class.name, attr)
+                    @property_hash[attr] || :absent
+                else
+                    @model.should(attr)
+                end
+            end
+
+            define_method(attr.to_s + "=") do |val|
+                # Mark that this target was modified.
+                modeltarget = @model.should(:target) || self.class.default_target
+
+                # If they're the same, then just mark that one as modified
+                if @property_hash[:target] and @property_hash[:target] == modeltarget
+                    self.class.modified(modeltarget)
+                else
+                    # Always mark the modeltarget as modified, and if there's
+                    # and old property_hash target, mark it as modified and replace
+                    # it.
+                    self.class.modified(modeltarget)
+                    if @property_hash[:target]
+                        self.class.modified(@property_hash[:target])
+                    end
+                    @property_hash[:target] = modeltarget
+                end
+                @property_hash[attr] = val
+            end
+        end
+    end
+
+    # Always make the model methods.
+    def self.model=(model)
+        super
+        mkmodelmethods()
+    end
+
+    # Mark a target as modified so we know to flush it.  This only gets
+    # used within the attr= methods.
+    def self.modified(target)
+        @modified ||= []
+        @modified << target unless @modified.include?(target)
+    end
+
+    # Retrieve all of the data from disk.  There are three ways to know
+    # while files to retrieve:  We might have a list of file objects already
+    # set up, there might be instances of our associated model and they
+    # will have a path parameter set, and we will have a default path
+    # set.  We need to turn those three locations into a list of files,
+    # prefetch each one, and make sure they're associated with each appropriate
+    # model instance.
+    def self.prefetch
+        # Reset the record list.
+        @records = []
+        targets().each do |target|
+            prefetch_target(target)
+        end
+    end
+
+    # Prefetch an individual target.
+    def self.prefetch_target(target)
+        target_records = retrieve(target).each do |r|
+            r[:on_disk] = true
+            r[:target] = target
+            r[:ensure] = :present
+        end
+
+        if respond_to?(:prefetch_hook)
+            target_records = prefetch_hook(target_records)
+        end
+
+        unless target_records
+            raise Puppet::DevError, "Prefetch hook for provider %s returned nil" %
+                self.name
+        end
+
+        @records += target_records
+
+        # Set current property on any existing resource instances.
+        target_records(target).find_all { |i| i.is_a?(Hash) }.each do |record|
+            # Find any model instances whose names match our instances.
+            if instance = self.model[record[:name]]
+                next unless instance.provider.is_a?(self)
+                instance.provider.property_hash = record
+            elsif respond_to?(:match)
+                if instance = match(record)
+                    record[:name] = instance[:name]
+                    instance.provider.property_hash = record
+                end
+            end
+        end
+    end
+
+    # Is there an existing record with this name?
+    def self.record?(name)
+        @records.find { |r| r[:name] == name }
+    end
+
+    # Retrieve the text for the file. Returns nil in the unlikely
+    # event that it doesn't exist.
+    def self.retrieve(path)
+        # XXX We need to be doing something special here in case of failure.
+        text = target_object(path).read
+        if text.nil? or text == ""
+            # there is no file
+            return []
+        else
+            # Set the target, for logging.
+            old = @target
+            begin
+                @target = path
+                self.parse(text)
+            ensure
+                @target = old
+            end
+        end
+    end
+
+    # Initialize the object if necessary.
+    def self.target_object(target)
+        @target_objects[target] ||= @filetype.new(target)
+
+        @target_objects[target]
+    end
+
+    # Find all of the records for a given target
+    def self.target_records(target)
+        @records.find_all { |r| r[:target] == target }
+    end
+
+    # Find a list of all of the targets that we should be reading.  This is
+    # used to figure out what targets we need to prefetch.
+    def self.targets
+        targets = []
+        # First get the default target
+        unless self.default_target
+            raise Puppet::DevError, "Parsed Providers must define a default target"
+        end
+        targets << self.default_target
+
+        # Then get each of the file objects
+        targets += @target_objects.keys
+
+        # Lastly, check the file from any model instances
+        self.model.each do |model|
+            targets << model.value(:target)
+
+            # This is only the case for properties, and targets should always
+            # be properties.
+            if model.respond_to?(:is)
+                targets << model.is(:target)
+            end
+        end
+
+        targets.uniq.reject { |t| t.nil? }
+    end
+
+    def self.to_file(records)
+        text = super
+        header + text
+    end
+
+
+    def create
+        @model.class.validproperties.each do |property|
+            if value = @model.should(property)
+                @property_hash[property] = value
+            end
+        end
+        self.class.modified(@property_hash[:target] || self.class.default_target)
+        return (@model.class.name.to_s + "_created").intern
+    end
+
+    def destroy
+        # We use the method here so it marks the target as modified.
+        self.ensure = :absent
+        return (@model.class.name.to_s + "_deleted").intern
+    end
+
+    def exists?
+        if @property_hash[:ensure] == :absent or @property_hash[:ensure].nil?
+            return false
+        else
+            return true
+        end
+    end
+
+    # Write our data to disk.
+    def flush
+        # Make sure we've got a target and name set.
+
+        # If the target isn't set, then this is our first modification, so
+        # mark it for flushing.
+        unless @property_hash[:target]
+            @property_hash[:target] = @model[:target] || self.class.default_target
+            self.class.modified(@property_hash[:target])
+        end
+        @property_hash[:name] ||= @model.name
+
+        self.class.flush(@property_hash)
+    end
+
+    def initialize(model)
+        super
+
+        # See if there's already a matching property_hash in the records list;
+        # else, use a default value.
+        # We provide a default for 'ensure' here, because the provider will
+        # override it if the thing exists, but it won't touch it if it doesn't
+        # exist.
+        @property_hash = self.class.record?(model[:name]) ||
+            {:record_type => self.class.name, :ensure => :absent}
+    end
+end
+
+# $Id: parsedfile.rb 2296 2007-03-18 22:48:57Z luke $