puppet 0.18.4 → 0.22.4

data/lib/puppet/type/parsedtype.rb

@@ -1,344 +1,219 @@
 require 'etc'
 require 'facter'
-require 'puppet/filetype'
-require 'puppet/type/state'
+require 'puppet/util/filetype'
+require 'puppet/type/property'
 
 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
-            def self.isoptional
-                @isoptional = true
-            end
-
-            def self.isoptional?
-                if defined? @isoptional
-                    return @isoptional
-                else
-                    return false
-                end
-            end
+    # 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 Property::ParsedParam < Puppet::Property
+        # This is the info retrieved from disk.
+        attr_accessor :found
+
+        def self.isoptional
+            @isoptional = true
+        end
 
-            # By default, support ':absent' as a value for optional
-            # parameters.  Any parameters that define their own validation
-            # need to do this manuallly.
-            validate do |value|
-                if self.class.isoptional? and (
-                    value == "absent" or value == :absent
-                )
-                    return :absent
-                else
-                    return value
-                end
+        def self.isoptional?
+            if defined? @isoptional
+                return @isoptional
+            else
+                return false
             end
+        end
 
-            # Fix things so that the fields have to match exactly, instead
-            # of only kinda
-            def insync?
-                self.is == self.should
+        # By default, support ':absent' as a value for optional
+        # parameters.  Any parameters that define their own validation
+        # need to do this manuallly.
+        validate do |value|
+            if self.class.isoptional? and (
+                value == "absent" or value == :absent
+            )
+                return :absent
+            else
+                return value
             end
+        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
+        def clear
+            super
+            @found = nil
+        end
 
-                unless defined? @is and ! @is.nil?
-                    @is = :absent
-                end
-            end
+        # Fix things so that the fields have to match exactly, instead
+        # of only kinda
+        def insync?
+            self.is == self.should
+        end
 
-            # If the ensure state is out of sync, it will always be called
-            # first, so I don't need to worry about that.
-            def sync(nostore = false)
-                ebase = @parent.class.name.to_s
+        # Normally this would retrieve the current value, but our property is not
+        # actually capable of doing so.  So, we retrieve the whole object and
+        # just collect our current state.  Note that this method is not called
+        # during a transaction, since transactions call the parent object method.
+        def retrieve
+            @parent.retrieve
+        end
 
-                tail = nil
+        # All this does is return an event; all of the work gets done
+        # in the flush method on the model.
+        def sync
+            if e = self.class.event(self.should)
+                return e
+            else
                 if self.class.name == :ensure
-                    # We're either creating or destroying the object
-                    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"
+                    if self.should == :absent
+                        return (@parent.class.name.to_s + "_removed").intern
+                    else
+                        return (@parent.class.name.to_s + "_created").intern
                     end
                 else
-                    # We don't do the work here, it gets done in 'store'
-                    tail = "changed"
-                end
-                @synced = self.should
-
-                # This should really only be done once per run, rather than
-                # every time.  I guess we need some kind of 'flush' mechanism.
-                if nostore
-                    self.retrieve
-                else
-                    @parent.store
+                    return (@parent.class.name.to_s + "_changed").intern
                 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
-
-            # In addition to removing the instances in @objects, we have to remove
-            # per-user host tab information.
-            def self.clear
-                @instances = []
-                @fileobj = nil
-                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)
-                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}
-# HEADER: by puppet.  While it can still be managed manually, it
-# HEADER: is definitely not recommended.\n}
-            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
-
-                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[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.
-
-                    # Mark found objects as present
-                    obj.is = [:ensure, :present]
-                    hash.each { |param, value|
-                        if state = obj.state(param)
-                            state.is = value
-                        elsif val = obj[param]
-                            obj[param] = val
-                        else
-                            # There is a value on disk, but it should go away
-                            obj.is = [param, value]
-                            obj[param] = :absent
-                        end
-                    }
-                else
-                    # create a new obj, since no existing one seems to
-                    # match
-                    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(namevar)
-                    hash.each { |param, value|
+    # The collection of classes that are just simple records aggregated
+    # into a file. See 'host.rb' for an example.
+    class Type::ParsedType < Puppet::Type
+        @name = :parsedtype
+
+        # Convert the hash to an object.
+        def self.hash2obj(hash)
+            obj = nil
+
+            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[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.
+
+                # Mark found objects as present
+                obj.is = [:ensure, :present]
+                obj.property(:ensure).found = :present
+                hash.each { |param, value|
+                    if property = obj.property(param)
+                        property.is = value
+                    elsif val = obj[param]
+                        obj[param] = val
+                    else
+                        # There is a value on disk, but it should go away
                         obj.is = [param, value]
-                    }
-                end
-
-                # And then add it to our list of instances.  This maintains the order
-                # in the file.
-                @instances << obj
+                        obj[param] = :absent
+                    end
+                }
+            else
+                # create a new obj, since no existing one seems to
+                # match
+                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(namevar)
+                hash.each { |param, value|
+                    obj.is = [param, value]
+                }
             end
 
-            def self.list
-                retrieve
+            return obj
+        end
 
-                self.collect do |obj|
-                    obj
-                end
-            end
+        # Override 'newproperty' so that all properties default to having the
+        # correct parent type
+        def self.newproperty(name, options = {}, &block)
+            options[:parent] ||= Puppet::Property::ParsedParam
+            super(name, options, &block)
+        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 file
-                    return nil
-                else
-                    # First we mark all of our objects absent; any objects
-                    # subsequently found will be marked present
-                    self.each { |obj|
-                        obj.is = [:ensure, :absent]
-                    }
-                    
-                    # We clear this, so that non-objects don't get duplicated
-                    @instances.clear
-                    self.parse(text)
-                end
-            end
+        def self.list
+            ret = suitableprovider.collect do |provider|
+                provider.retrieve.find_all { |i| i.is_a? Hash }.collect { |i| hash2obj(i) }
+            end.flatten
+        end
 
-            # Write out the file.
-            def self.store
-                @fileobj ||= @filetype.new(@path)
+        def self.listbyname
+            suitableprovider.collect do |provider|
+                provider.retrieve.find_all { |i| i.is_a? Hash }.collect { |i| i[:name] }
+            end.flatten
+        end
 
-                # Make sure all of our instances are in the to-be-written array
-                self.each do |inst|
-                    @instances << inst unless @instances.include? inst
-                end
+        # Make sure they've got an explicit :ensure class.
+        def self.postinit
+            unless validproperty? :ensure
+                newproperty(:ensure) do
+                    newvalue(:present) do
+                        # The value will get flushed appropriately
+                        return nil
+                    end
 
-                if @instances.empty?
-                    Puppet.notice "No %s instances for %s" % [self.name, @path]
-                else
-                    @fileobj.write(self.to_file())
-                end
-            end
+                    newvalue(:absent) do
+                        # The value will get flushed appropriately
+                        return nil
+                    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
-                                true
-                            end
-                        end
-                    }.collect { |obj|
-                        if obj.is_a?(self)
-                            obj.to_record
+                    defaultto do
+                        if @parent.managed?
+                            :present
                         else
-                            obj.to_s
+                            nil
                         end
-                    }.join("\n") + "\n"
-
-                    return str
-                else
-                    Puppet.notice "No %s instances" % self.name
-                    return ""
+                    end
                 end
             end
+        end
 
-            # Return the last time the file was loaded.  Could
-            # be used for reducing writes, but currently is not.
-            def self.loaded?(user)
-                @fileobj ||= @filetype.new(@path)
-                @fileobj.loaded
-            end
-
-            # The 'store' method knows how to handle absence vs. presence
-            def create
-                self.store
-            end
-
-            # The 'store' method knows how to handle absence vs. presence
-            def destroy
-                self.store
-            end
+        def exists?
+            h = self.retrieve
 
-            # hash2obj marks the 'ensure' state as present
-            def exists?
-                @states.include?(:ensure) and @states[:ensure].is == :present
-            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
-                }
+            if h.nil? or h[:ensure] == :absent
+                return false
+            else
+                return true
             end
+        end
 
-            # Write the entire file out.
-            def store
-                self.class.store()
-            end
+        # Flush our content to disk.
+        def flush
+            provider.store(self.to_hash)
+        end
 
-            def value(name)
-                unless name.is_a? Symbol
-                    name = name.intern
+        # Retrieve our current state from our provider
+        def retrieve
+            if h = provider.hash and ! h.empty?
+                h[:ensure] ||= :present
+
+                # If they passed back info we don't have, then mark it to
+                # be deleted.
+                h.each do |name, value|
+                    next unless self.class.validproperty?(name)
+                    unless @parameters[name]
+                        self.newproperty(name, :should => :absent)
+                    end
                 end
-                if @states.include? name
-                    val = @states[name].value
-                    if val == :absent
-                        return nil
+
+                properties().each do |property|
+                    if h.has_key? property.name
+                        property.is = h[property.name]
                     else
-                        return val
+                        property.is = :absent
                     end
-                elsif @parameters.include? name
-                    return @parameters[name].value
-                else
-                    return nil
                 end
+
+                return h
+            else
+                properties().each do |property|
+                    property.is = :absent
+                end
+                return nil
             end
         end
     end
 end
 
-require 'puppet/type/parsedtype/host'
-require 'puppet/type/parsedtype/port'
-require 'puppet/type/parsedtype/mount'
-require 'puppet/type/parsedtype/sshkey'
-
-# $Id: parsedtype.rb 1223 2006-05-25 06:08:11Z luke $
+# $Id: parsedtype.rb 2178 2007-02-07 23:56:59Z luke $