puppet 0.9.2 → 0.13.0

data/lib/puppet/type/state.rb

@@ -4,29 +4,130 @@
 require 'puppet'
 require 'puppet/element'
 require 'puppet/statechange'
+require 'puppet/parameter'
 
 module Puppet
-class State < Puppet::Element
-    attr_accessor :is, :parent
+class State < Puppet::Parameter
+    attr_accessor :is
 
     # Because 'should' uses an array, we have a special method for handling
     # it.  We also want to keep copies of the original values, so that
     # they can be retrieved and compared later when merging.
     attr_reader :shouldorig
 
-    @virtual = true
-
     class << self
         attr_accessor :unmanaged
         attr_reader :name
+
+        #def inspect
+        #    "State(%s)" % self.name
+        #end
+
+        #def to_s
+        #    self.inspect
+        #end
+    end
+
+    # Parameters just use 'newvalues', since there's no work associated with them.
+    def self.newvalue(name, &block)
+        @parametervalues ||= {}
+
+        if @parametervalues.include?(name)
+            Puppet.warning "%s already has a value for %s" % [name, name]
+        end
+        @parametervalues[name] = block
+
+        define_method("set_" + name.to_s, &block)
     end
+#
+#    def self.aliasvalue(name, other)
+#        @statevalues ||= {}
+#        unless @statevalues.include?(other)
+#            raise Puppet::DevError, "Cannot alias nonexistent value %s" % other
+#        end
+#
+#        @aliasvalues ||= {}
+#        @aliasvalues[name] = other
+#    end
+#
+#    def self.alias(name)
+#        @aliasvalues[name]
+#    end
+#
+    def self.defaultvalues
+        newvalue(:present) do
+            @parent.create
+        end
+
+        newvalue(:absent) do
+            @parent.destroy
+        end
+
+        # This doc will probably get overridden
+        @doc ||= "The basic state that the object should be in."
+    end
+#
+#    # Return the list of valid values.
+#    def self.values
+#        @statevalues ||= {}
+#        @aliasvalues ||= {}
+#
+#        #[@aliasvalues.keys, @statevalues.keys].flatten
+#        @statevalues.keys
+#    end
+
+    # Call the method associated with a given value.
+    def set
+        if self.insync?
+            self.log "already in sync"
+            return nil
+        end
+
+        value = self.should
+        method = "set_" + value.to_s
+        unless self.respond_to?(method)
+            self.fail "%s is not a valid value for %s" %
+                [value, self.class.name]
+        end
+        self.debug "setting %s (currently %s)" % [value, self.is]
 
+        begin
+            event = self.send(method)
+        rescue Puppet::Error
+            raise
+        rescue => detail
+            if Puppet[:debug]
+                puts detail.backtrace
+            end
+            self.fail "Could not set %s on %s: %s" %
+                [value, self.class.name, detail]
+        end
+
+        if event and event.is_a?(Symbol)
+            return event
+        else
+            # Return the appropriate event.
+            event = case self.should
+            when :present: (@parent.class.name.to_s + "_created").intern
+            when :absent: (@parent.class.name.to_s + "_removed").intern
+            else
+                (@parent.class.name.to_s + "_changed").intern
+            end
+
+            #self.log "made event %s because 'should' is %s, 'is' is %s" %
+            #    [event, self.should.inspect, self.is.inspect]
+
+            return event
+        end
+    end
+    
     # initialize our state
     def initialize(hash)
+        super()
         @is = nil
 
         unless hash.include?(:parent)
-            raise Puppet::DevError, "State %s was not passed a parent" % self
+            self.devfail "State %s was not passed a parent" % self
         end
         @parent = hash[:parent]
 
@@ -39,6 +140,21 @@ class State < Puppet::Element
         end
     end
 
+    def inspect
+        str = "State('%s', " % self.name
+        if defined? @is and @is
+            str += "@is = '%s', " % @is
+        else
+            str += "@is = nil, "
+        end
+
+        if defined? @should and @should
+            str += "@should = '%s')" % @should.join(", ")
+        else
+            str += "@should = nil)"
+        end
+    end
+
     # Determine whether the state is in-sync or not.  If @should is
     # not defined or is set to a non-true value, then we do not have
     # a valid value for it and thus consider the state to be in-sync
@@ -53,7 +169,7 @@ class State < Puppet::Element
         end
 
         unless @should.is_a?(Array)
-            raise Puppet::DevError, "%s's should is not array" % self.class.name
+            self.devfail "%s's should is not array" % self.class.name
         end
 
         # an empty array is analogous to no should values
@@ -74,8 +190,9 @@ class State < Puppet::Element
 
     def log(msg)
         unless @parent[:loglevel]
-            raise Puppet::DevError, "Parent %s has no loglevel" %
-                @parent.to_s
+            p @parent
+            self.devfail "Parent %s has no loglevel" %
+                @parent.name
         end
         Puppet::Log.create(
             :level => @parent[:loglevel],
@@ -112,8 +229,7 @@ class State < Puppet::Element
     def should
         if defined? @should
             unless @should.is_a?(Array)
-                self.warning @should.inspect
-                raise Puppet::DevError, "should for %s on %s is not an array" %
+                self.devfail "should for %s on %s is not an array" %
                     [self.class.name, @parent.name]
             end
             return @should[0]
@@ -130,23 +246,78 @@ class State < Puppet::Element
 
         @shouldorig = values
 
-        if self.respond_to?(:shouldprocess)
+        if self.respond_to?(:validate)
+            values.each { |val|
+                validate(val)
+            }
+        end
+        if self.respond_to?(:munge)
             @should = values.collect { |val|
-                self.shouldprocess(val)
+                self.munge(val)
             }
         else
             @should = values
         end
     end
 
+    # The default 'sync' method only selects among a list of registered
+    # values.
+    def sync
+        if self.insync?
+            self.info "already in sync"
+            return nil
+        #else
+            #self.info "%s vs %s" % [self.is.inspect, self.should.inspect]
+        end
+        unless self.class.values
+            self.devfail "No values defined for %s" %
+                self.class.name
+        end
+
+        # Set ourselves to whatever our should value is.
+        self.set
+    end
+
+#    munge do |value|
+#        if self.class.values.empty?
+#            # This state isn't using defined values to do its work.
+#            return value
+#        end
+#        intern = value.to_s.intern
+#        # If it's a valid value, always return it as a symbol.
+#        if self.class.values.include?(intern)
+#            retval = intern
+#        elsif other = self.class.alias(intern)
+#            self.info "returning alias %s for %s" % [other, intern]
+#            retval = other
+#        else
+#            retval = value
+#        end
+#        retval
+#    end
+#
+#    # Verify that the passed value is valid.
+#    validate do |value|
+#        if self.class.values.empty?
+#            # This state isn't using defined values to do its work.
+#            return 
+#        end
+#        unless value.is_a?(Symbol)
+#            value = value.to_s.intern
+#        end
+#        unless self.class.values.include?(value) or self.class.alias(value)
+#            self.fail "Invalid '%s' value '%s'.  Valid values are '%s'" %
+#                    [self.class.name, value, self.class.values.join(", ")]
+#        end
+#    end
 
     # How should a state change be printed as a string?
     def change_to_s
         begin
-            if @is == :notfound
+            if @is == :absent
                 return "defined '%s' as '%s'" %
                     [self.name, self.should_to_s]
-            elsif self.should == :notfound
+            elsif self.should == :absent
                 return "undefined %s from '%s'" %
                     [self.name, self.is_to_s]
             else
@@ -170,13 +341,55 @@ class State < Puppet::Element
     end
 
     def should_to_s
-        @should
+        @should.join(" ")
     end
 
     def to_s
         return "%s(%s)" % [@parent.name,self.name]
     end
+
+    # This state will get automatically added to any type that responds
+    # to the methods 'exists?', 'create', and 'remove'.
+    class Ensure < Puppet::State
+        @name = :ensure
+
+        def self.inherited(sub)
+            # Add in the two states that everyone will have.
+            sub.class_eval do
+            end
+        end
+
+        def change_to_s
+            begin
+                if @is == :absent
+                    return "created"
+                elsif self.should == :absent
+                    return "removed"
+                else
+                    return "%s changed '%s' to '%s'" %
+                        [self.name, self.is_to_s, self.should_to_s]
+                end
+            rescue Puppet::Error, Puppet::DevError
+                raise
+            rescue => detail
+                raise Puppet::DevError, "Could not convert change %s to string: %s" %
+                    [self.name, detail]
+            end
+        end
+
+        def retrieve
+            if @parent.exists?
+                @is = :present
+            else
+                @is = :absent
+            end
+        end
+
+        # If they're talking about the thing at all, they generally want to
+        # say it should exist.
+        defaultto :present
+    end
 end
 end
 
-# $Id: state.rb 749 2005-11-22 05:33:42Z luke $
+# $Id: state.rb 883 2006-02-08 16:53:34Z luke $

data/lib/puppet/type/symlink.rb

@@ -1,16 +1,11 @@
-#!/usr/local/bin/ruby -w
-
-# $Id: symlink.rb 731 2005-10-26 04:44:25Z luke $
-
 require 'etc'
 require 'puppet/type/state'
 require 'puppet/type/pfile'
 
 module Puppet
-    # okay, how do we deal with parameters that don't have operations
-    # associated with them?
-    class State
-        class SymlinkTarget < Puppet::State
+    newtype(:symlink) do
+        @doc = "Create symbolic links to existing files."
+        newstate(:target) do
             require 'etc'
             attr_accessor :file
 
@@ -22,15 +17,15 @@ module Puppet
 
             def create
                 begin
-                    debug("Creating symlink '%s' to '%s'" %
+                    @parent.debug("Creating symlink '%s' to '%s'" %
                         [self.parent[:path],self.should])
                     unless File.symlink(self.should,self.parent[:path])
-                        raise TypeError.new("Could not create symlink '%s'" %
-                            self.parent[:path])
+                        self.fail "Could not create symlink '%s'" %
+                            self.parent[:path]
                     end
                 rescue => detail
-                    raise TypeError.new("Cannot create symlink '%s': %s" %
-                        [self.parent[:path],detail])
+                    self.fail "Cannot create symlink '%s': %s" %
+                        [self.parent[:path],detail]
                 end
             end
 
@@ -40,14 +35,14 @@ module Puppet
                     begin
                         File.unlink(self.parent[:path])
                     rescue
-                        raise TypeError.new("Failed to remove symlink '%s'" %
-                            self.parent[:path])
+                        self.fail "Failed to remove symlink '%s'" %
+                            self.parent[:path]
                     end
                 elsif FileTest.exists?(self.parent[:path])
-                    raise TypeError.new("Cannot remove normal file '%s'" %
-                        self.parent[:path])
+                    self.fail "Cannot remove normal file '%s'" %
+                        self.parent[:path]
                 else
-                    debug("Symlink '%s' does not exist" %
+                    @parent.debug("Symlink '%s' does not exist" %
                         self.parent[:path])
                 end
             end
@@ -78,8 +73,8 @@ module Puppet
                             self.create()
                         end
                     elsif FileTest.exists?(self.parent[:path])
-                        raise TypeError.new("Cannot replace normal file '%s'" %
-                            self.parent[:path])
+                        self.fail "Cannot replace normal file '%s'" %
+                            self.parent[:path]
                     else
                         self.create()
                     end
@@ -88,46 +83,37 @@ module Puppet
                 #self.parent.newevent(:event => :inode_changed)
             end
         end
-    end
-
-    class Type
-        class Symlink < Type
-            attr_reader :stat, :path, :params
-            # class instance variable
-            @states = [
-                Puppet::State::SymlinkTarget
-            ]
-
-            @parameters = [
-                :path,
-                :recurse
-            ]
-
-            @paramdoc[:path] = "Path of link to create."
-            @paramdoc[:recurse] = "If target is a directory, recursively create
+
+        attr_reader :stat, :path, :params
+
+        copyparam(Puppet.type(:file), :path)
+
+        newparam(:recurse) do
+            desc "If target is a directory, recursively create
                 directories (using `file`'s `source` parameter) and link all
-                contained files."
-            @doc = "Create symbolic links to existing files."
-            @name = :symlink
-            @namevar = :path
+                contained files.  For instance::
 
-            def initialize(hash)
-                @arghash = self.argclean(hash.dup)
-                @arghash.delete(self.class.namevar)
+                    # The Solaris Blastwave repository installs everything
+                    # in /opt/csw; link it into /usr/local
+                    symlink { \"/usr/local\":
+                        target => \"/opt/csw\",
+                        recurse => 1
+                    }
 
-                super
-            end
 
-            def paramrecurse=(value)
+                Note that this does not link directories -- any directories
+                are created in the destination, and any files are linked over."
+
+            munge do |value|
                 @stat = nil
-                @target = self.state(:target).should
+                @target = @parent.state(:target).should
 
                 # we want to remove our state, because we're creating children
                 # to do the links
                 if FileTest.exist?(@target)
                     @stat = File.stat(@target)
                 else
-                    self.info "Target %s must exist for recursive links" %
+                    @parent.info "Target %s must exist for recursive links" %
                         @target
                     return
                 end
@@ -138,7 +124,7 @@ module Puppet
                     return
                 end
 
-                self.delete(:target)
+                @parent.delete(:target)
 
                 recurse = value
                 # we might have a string, rather than a number
@@ -161,23 +147,25 @@ module Puppet
                 # working in pfile
 
                 args = {
-                    :name => self.name,
+                    :name => @parent.name,
                     :linkmaker => true,
                     :recurse => recurse,
                     :source => @target
                 }
 
-                dir = Puppet::Type::PFile.implicitcreate(args)
-                dir.parent = self
-                self.debug "Got dir %s" % dir.name
-                self.push dir
-                #Dir.foreach(@target) { |file|
-                #    next if file =~ /^\.\.?$/ # skip . and ..
-                #    newtarget = File.join(@target,file)
-                #    #stat = File.stat(File.join(@target,file))
-                #    self.newchild(file, :target => newtarget)
-                #}
+                dir = Puppet.type(:file).implicitcreate(args)
+                dir.parent = @parent
+                @parent.debug "Got dir %s" % dir.name
+                @parent.push dir
             end
-        end # Puppet::Type::Symlink
-    end # Puppet::Type
+        end
+
+        def initialize(hash)
+            @arghash = self.argclean(hash.dup)
+            @arghash.delete(self.class.namevar)
+            super
+        end
+    end # Puppet.type(:symlink)
 end
+
+# $Id: symlink.rb 841 2006-01-18 17:24:15Z luke $