puppet 0.9.2 → 0.13.0

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

@@ -1,116 +1,137 @@
 module Puppet
-    module PackagingType
-        module Sun
-            def query
-                names = {
-                    "PKGINST" => :name,
-                    "NAME" => nil,
-                    "CATEGORY" => :category,
-                    "ARCH" => :platform,
-                    "VERSION" => :install,
-                    "BASEDIR" => :root,
-                    "HOTLINE" => nil,
-                    "EMAIL" => nil,
-                    "VENDOR" => :vendor,
-                    "DESC" => :description,
-                    "PSTAMP" => nil,
-                    "INSTDATE" => nil,
-                    "STATUS" => nil,
-                    "FILES" => nil
-                }
+    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"]
+            cmd += ["-d", self[:source]]
+            cmd += ["-n", self[:name]]
+
+            if self[:answerfile]
+                cmd += ["-a", self[:answerfile]]
+            end
+            cmd << "2>&1"
+            cmd = cmd.join(" ")
 
-                hash = {}
+            self.info "Executing %s" % cmd.inspect
+            output = %x{#{cmd} 2>&1}
+
+            unless $? == 0
+                raise Puppet::PackageError.new(output)
+            end
+        end
 
-                # list out all of the packages
-                open("| pkginfo -l %s 2>/dev/null" % self.name) { |process|
-                    # we're using the long listing, so each line is a separate
-                    # piece of information
-                    process.each { |line|
-                        case line
-                        when /^$/:  # ignore
-                        when /\s*([A-Z]+):\s+(.+)/:
-                            name = $1
-                            value = $2
-                            if names.include?(name)
-                                unless names[name].nil?
-                                    hash[names[name]] = value
-                                end
-                            else
-                                self.err "'pkginfo' returned invalid name %s" %
-                                    name
+        def query
+            names = {
+                "PKGINST" => :name,
+                "NAME" => nil,
+                "CATEGORY" => :category,
+                "ARCH" => :platform,
+                "VERSION" => :ensure,
+                "BASEDIR" => :root,
+                "HOTLINE" => nil,
+                "EMAIL" => nil,
+                "VENDOR" => :vendor,
+                "DESC" => :description,
+                "PSTAMP" => nil,
+                "INSTDATE" => nil,
+                "STATUS" => nil,
+                "FILES" => nil
+            }
+
+            hash = {}
+
+            # list out all of the packages
+            open("| pkginfo -l %s 2>/dev/null" % self.name) { |process|
+                # we're using the long listing, so each line is a separate
+                # piece of information
+                process.each { |line|
+                    case line
+                    when /^$/:  # ignore
+                    when /\s*([A-Z]+):\s+(.+)/:
+                        name = $1
+                        value = $2
+                        if names.include?(name)
+                            unless names[name].nil?
+                                hash[names[name]] = value
                             end
-                        when /\s+\d+.+/:
-                            # nothing; we're ignoring the FILES info
+                        else
+                            self.err "'pkginfo' returned invalid name %s" %
+                                name
                         end
-                    }
+                    when /\s+\d+.+/:
+                        # nothing; we're ignoring the FILES info
+                    end
                 }
+            }
 
-                if hash.empty?
-                    return nil
-                else
-                    return hash
-                end
+            if hash.empty?
+                return nil
+            else
+                return hash
             end
+        end
 
-            def list
-                packages = []
-                hash = {}
-                names = {
-                    "PKGINST" => :name,
-                    "NAME" => nil,
-                    "CATEGORY" => :category,
-                    "ARCH" => :platform,
-                    "VERSION" => :install,
-                    "BASEDIR" => :root,
-                    "HOTLINE" => nil,
-                    "EMAIL" => nil,
-                    "VENDOR" => :vendor,
-                    "DESC" => :description,
-                    "PSTAMP" => nil,
-                    "INSTDATE" => nil,
-                    "STATUS" => nil,
-                    "FILES" => nil
-                }
+        def list
+            packages = []
+            hash = {}
+            names = {
+                "PKGINST" => :name,
+                "NAME" => nil,
+                "CATEGORY" => :category,
+                "ARCH" => :platform,
+                "VERSION" => :ensure,
+                "BASEDIR" => :root,
+                "HOTLINE" => nil,
+                "EMAIL" => nil,
+                "VENDOR" => :vendor,
+                "DESC" => :description,
+                "PSTAMP" => nil,
+                "INSTDATE" => nil,
+                "STATUS" => nil,
+                "FILES" => nil
+            }
 
-                # list out all of the packages
-                open("| pkginfo -l") { |process|
-                    # we're using the long listing, so each line is a separate
-                    # piece of information
-                    process.each { |line|
-                        case line
-                        when /^$/:
-                            packages.push Puppet::Type::Package.installedpkg(hash)
-                            hash.clear
-                        when /\s*(\w+):\s+(.+)/:
-                            name = $1
-                            value = $2
-                            if names.include?(name)
-                                unless names[name].nil?
-                                    hash[names[name]] = value
-                                end
-                            else
-                                raise "Could not find %s" % name
+            # list out all of the packages
+            open("| pkginfo -l 2>&1") { |process|
+                # we're using the long listing, so each line is a separate
+                # piece of information
+                process.each { |line|
+                    case line
+                    when /^$/:
+                        packages.push Puppet.type(:package).installedpkg(hash)
+                        hash.clear
+                    when /\s*(\w+):\s+(.+)/:
+                        name = $1
+                        value = $2
+                        if names.include?(name)
+                            unless names[name].nil?
+                                hash[names[name]] = value
                             end
-                        when /\s+\d+.+/:
-                            # nothing; we're ignoring the FILES info
+                        else
+                            raise "Could not find %s" % name
                         end
-                    }
+                    when /\s+\d+.+/:
+                        # nothing; we're ignoring the FILES info
+                    end
                 }
-                return packages
-            end
+            }
+            return packages
+        end
 
-            # we need package retrieval mechanisms before we can have package
-            # installation mechanisms...
-            #type.install = proc { |pkg|
-            #    raise "installation not implemented yet"
-            #}
+        # we need package retrieval mechanisms before we can have package
+        # installation mechanisms...
+        #type.install = proc { |pkg|
+        #    raise "installation not implemented yet"
+        #}
 
-            def remove
-                cmd = "pkgrm -n %s" % self.name
-                output = %x{#{cmd}}
-                if $? != 0
-                    raise output
-                end
+        def uninstall
+            cmd = "pkgrm -n %s 2>&1" % self.name
+            output = %x{#{cmd}}
+            if $? != 0
+                raise Puppet::Error, "Removal of %s failed: %s" % [self.name, output]
             end
         end
     end

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

@@ -1,58 +1,62 @@
 module Puppet
-    module PackagingType
+    Puppet.type(:package).newpkgtype(:yum, :rpm) do
         # A derivative of DPKG; this is how most people actually manage
         # Debian boxes, and the only thing that differs is that it can
         # install packages from remote sites.
-        module Yum
-            include RPM
 
-            # Install a package using 'apt-get'.
-            def install
-                cmd = "yum -y install %s" % self.name
+        # Install a package using 'apt-get'.
+        def install
+            cmd = "yum -y install %s" % self.name
 
-                self.info "Executing %s" % cmd.inspect
-                output = %x{#{cmd} 2>&1}
+            self.info "Executing %s" % cmd.inspect
+            output = %x{#{cmd} 2>&1}
 
-                unless $? == 0
-                    raise Puppet::PackageError.new(output)
-                end
+            unless $? == 0
+                raise Puppet::PackageError.new(output)
             end
+        end
 
-            # What's the latest package version available?
-            def latest
-                cmd = "yum list %s" % self.name 
-                output = %x{#{cmd} 2>&1}
-
-                unless $? == 0
-                    raise Puppet::PackageError.new(output)
-                end
+        # What's the latest package version available?
+        def latest
+            cmd = "yum list %s" % self.name 
+            self.info "Executing %s" % cmd.inspect
+            output = %x{#{cmd} 2>&1}
 
-                if output =~ /#{self.name}\S+\s+(\S+)\s/
-                    return $1
-                else
-                    self.debug "No version"
-                    if Puppet[:debug]
-                        print output
-                    end
+            unless $? == 0
+                raise Puppet::PackageError.new(output)
+            end
 
-                    return nil
+            if output =~ /#{self.name}\S+\s+(\S+)\s/
+                return $1
+            else
+                self.debug "No version"
+                if Puppet[:debug]
+                    print output
                 end
+
+                return nil
             end
+        end
 
-            def update
-                cmd = "yum -y update %s" % self.name
+        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}
+            self.info "Executing %s" % cmd.inspect
+            output = %x{#{cmd} 2>&1}
 
-                unless $? == 0
-                    raise Puppet::PackageError.new(output)
-                end
+            unless $? == 0
+                raise Puppet::PackageError.new(output)
             end
+        end
 
-            def versionable?
-                false
-            end
+        def versionable?
+            false
         end
     end
 end

data/lib/puppet/type/parsedtype.rb

@@ -0,0 +1,295 @@
+require 'etc'
+require 'facter'
+require 'puppet/filetype'
+require 'puppet/type/state'
+
+module Puppet
+    class State
+        # The base parameter for all of these types.  Its only job is to copy
+        # the 'should' value to the 'is' value and to do support the right logging
+        # and such.
+        class ParsedParam < Puppet::State
+            # Fix things so that the fields have to match exactly, instead
+            # of only kinda
+            def insync?
+                self.is == self.should
+            end
+
+            # Normally this would retrieve the current value, but our state is not
+            # actually capable of doing so.
+            def retrieve
+                # If we've synced, then just copy the values over and return.
+                # This allows this state to behave like any other state.
+                if defined? @synced and @synced
+                    # by default, we only copy over the first value.
+                    @is = @synced
+                    @synced = false
+                    return
+                end
+
+                unless defined? @is and ! @is.nil?
+                    @is = :absent
+                end
+            end
+
+            # Determine whether the host entry should be destroyed, and figure
+            # out which event to return.  Finally, call @parent.sync to write the
+            # host tab.
+            def sync(nostore = false)
+                ebase = @parent.class.name.to_s
+                if @is == :absent
+                    #@is = self.should
+                    tail = "created"
+
+                    # If we're creating it, then sync all of the other states
+                    # but tell them not to store (we'll store just once,
+                    # at the end).
+                    unless nostore
+                        @parent.eachstate { |state|
+                            next if state == self or state.name == :ensure
+                            state.sync(true)
+                        }
+                    end
+                elsif self.should == :absent
+                    @parent.remove(true)
+                    tail = "deleted"
+                #elsif @is == @should
+                elsif self.insync?
+                    self.info "already in sync"
+                    return nil
+                else
+                    #@is = self.should
+                    # Mark that we've synced it, but don't copy the value, because
+                    # that will make the 'change' log inscrutable.
+                    tail = "changed"
+                end
+                @synced = self.should
+
+                if nostore
+                    self.retrieve
+                else
+                    @parent.store
+                end
+                
+                return (ebase + "_" + tail).intern
+            end
+        end
+    end
+
+    class Type
+        # The collection of classes that are just simple records aggregated
+        # into a file. See 'host.rb' for an example.
+        class ParsedType < Puppet::Type
+            @name = :parsedtype
+            class << self
+                attr_accessor :filetype, :hostfile, :fileobj, :fields, :path
+            end
+
+            # Override 'newstate' so that all states default to having the
+            # correct parent type
+            def self.newstate(name, parent = nil, &block)
+                parent ||= Puppet::State::ParsedParam
+                super(name, parent, &block)
+            end
+
+            # Add another type var.
+            def self.initvars
+                @instances = []
+                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, Cron has to remove
+            # per-user host tab information.
+            def self.clear
+                @instances = []
+                @fileobj = nil
+                super
+            end
+
+            # Override the default Puppet::Type method, because instances
+            # also need to be deleted from the @instances hash
+            def self.delete(child)
+                if @instances.include?(child)
+                    @instances.delete(child)
+                end
+                super
+            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} by puppet.  While it
+# HEADER: can still be managed manually, it 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.
+            def self.parse(text)
+                raise Puppet::DevError, "Parse was not overridden in %s" %
+                    self.name
+            end
+
+            # Convert the hash to an object.
+            def self.hash2obj(hash)
+                obj = nil
+
+                unless hash.include?(:name) and hash[:name]
+                    raise Puppet::DevError, "Hash was not passed with name"
+                end
+
+                # if the obj already exists with that name...
+                if obj = self[hash[:name]]
+                    # 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.
+
+                    # Mark found objects as present
+                    Puppet.debug "Found %s %s" % [self.name, obj.name]
+                    obj.is = [:ensure, :present]
+                else
+                    # create a new obj, since no existing one seems to
+                    # match
+                    obj = self.create(
+                        :name => hash[:name]
+                    ) or return false
+                    hash.delete(:name)
+                end
+
+                hash.each { |param, value|
+                    obj.is = [param, value]
+                }
+            end
+
+            # Retrieve the text for the file. Returns nil in the unlikely
+            # event that it doesn't exist.
+            def self.retrieve
+                @fileobj ||= @filetype.new(@path)
+                text = @fileobj.read
+                if text.nil? or text == ""
+                    # there is no host file
+                    return nil
+                else
+                    # 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
+                        }
+                    }
+                    self.parse(text)
+                end
+            end
+
+            # Write out the file.
+            def self.store
+                @fileobj ||= @filetype.new(@path)
+
+                if @instances.empty?
+                    Puppet.notice "No %s instances for %s" % [self.name, @path]
+                else
+                    @fileobj.write(self.to_file())
+                end
+
+                #self.each { |obj|
+                #    obj.each { |state|
+                #        obj.notice "Changing from %s to %s" %
+                #            [state.is.inspect, state.should.inspect]
+                #        state.is = state.should
+                #    }
+                #}
+            end
+
+            # Collect all Host instances convert them into literal text.
+            def self.to_file
+                str = self.header()
+                unless @instances.empty?
+                    str += @instances.reject { |obj|
+                        # Don't write out objects that should be absent
+                        if obj.is_a?(self)
+                            if obj.should(:ensure) == :absent
+                                #obj.warning "removing; is = %s, should = %s" %
+                                #    [obj.is(:ensure).inspect, obj.should(:ensure).inspect]
+                                #obj.is = [:ensure, :absent]
+                                true
+                            end
+                        end
+                    }.collect { |obj|
+                        if obj.is_a?(self)
+                            obj.to_record
+                        else
+                            obj.to_s
+                        end
+                    }.join("\n") + "\n"
+
+                    return str
+                else
+                    Puppet.notice "No host instances"
+                    return ""
+                end
+            end
+
+            # Return the last time the hosts file was loaded.  Could
+            # be used for reducing writes, but currently is not.
+            def self.loaded?(user)
+                @fileobj ||= @filetype.new(@path)
+                @fileobj.loaded
+            end
+
+            def create
+                self[:ensure] = :present
+                self.store
+            end
+
+            # We just find any state and check whether it's marked absent
+            def exists?
+                name, state = @states.find { |name, state|
+                    state.is_a?(Puppet::State::ParsedParam)
+                }
+
+                if state.is == :absent
+                    return false
+                else
+                    return true
+                end
+            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
+                self.class.retrieve()
+
+                self.eachstate { |st| st.retrieve }
+            end
+
+            # Write the entire host file out.
+            def store
+                self.class.store()
+            end
+        end
+    end
+end
+
+require 'puppet/type/parsedtype/host'
+require 'puppet/type/parsedtype/port'
+
+# $Id: parsedtype.rb 847 2006-01-23 22:38:39Z luke $