puppet 0.25.5 → 2.6.0

data/lib/puppet/property/ensure.rb

@@ -0,0 +1,92 @@
+require 'puppet/property'
+
+# This property will get automatically added to any type that responds
+# to the methods 'exists?', 'create', and 'destroy'.
+class Puppet::Property::Ensure < Puppet::Property
+  @name = :ensure
+
+  def self.defaultvalues
+    newvalue(:present) do
+      if @resource.provider and @resource.provider.respond_to?(:create)
+        @resource.provider.create
+      else
+        @resource.create
+      end
+      nil # return nil so the event is autogenerated
+    end
+
+    newvalue(:absent) do
+      if @resource.provider and @resource.provider.respond_to?(:destroy)
+        @resource.provider.destroy
+      else
+        @resource.destroy
+      end
+      nil # return nil so the event is autogenerated
+    end
+
+    defaultto do
+      if @resource.managed?
+        :present
+      else
+        nil
+      end
+    end
+
+    # This doc will probably get overridden
+    @doc ||= "The basic property that the resource should be in."
+  end
+
+  def self.inherited(sub)
+    # Add in the two properties that everyone will have.
+    sub.class_eval do
+    end
+  end
+
+  def change_to_s(currentvalue, newvalue)
+    begin
+      if currentvalue == :absent or currentvalue.nil?
+        return "created"
+      elsif newvalue == :absent
+        return "removed"
+      else
+        return "#{self.name} changed '#{self.is_to_s(currentvalue)}' to '#{self.should_to_s(newvalue)}'"
+      end
+    rescue Puppet::Error, Puppet::DevError
+      raise
+    rescue => detail
+      raise Puppet::DevError, "Could not convert change #{self.name} to string: #{detail}"
+    end
+  end
+
+  def retrieve
+    # XXX This is a problem -- whether the object exists or not often
+    # depends on the results of other properties, yet we're the first property
+    # to get checked, which means that those other properties do not have
+    # @is values set.  This seems to be the source of quite a few bugs,
+    # although they're mostly logging bugs, not functional ones.
+    if prov = @resource.provider and prov.respond_to?(:exists?)
+      result = prov.exists?
+    elsif @resource.respond_to?(:exists?)
+      result = @resource.exists?
+    else
+      raise Puppet::DevError, "No ability to determine if #{@resource.class.name} exists"
+    end
+    if result
+      return :present
+    else
+      return :absent
+    end
+  end
+
+  # If they're talking about the thing at all, they generally want to
+  # say it should exist.
+  #defaultto :present
+  defaultto do
+    if @resource.managed?
+      :present
+    else
+      nil
+    end
+  end
+end
+

data/lib/puppet/property/keyvalue.rb

@@ -9,88 +9,80 @@
 require 'puppet/property'
 
 module Puppet
-    class Property
-        class KeyValue < Property
-
-            def hash_to_key_value_s(hash)
-                hash.select { |k,v| true }.map { |pair| pair.join(separator) }.join(delimiter)
-            end
-
-            def should_to_s(should_value)
-                hash_to_key_value_s(should_value)
-            end
-
-            def is_to_s(current_value)
-                hash_to_key_value_s(current_value)
-            end
-
-            def membership
-                :key_value_membership
-            end
-
-            def inclusive?
-                @resource[membership] == :inclusive
-            end
-
-            def hashify(key_value_array)
-                #turns string array into a hash
-                key_value_array.inject({}) do |hash, key_value|
-                    tmp = key_value.split(separator)
-                    hash[tmp[0].intern] = tmp[1]
-                    hash
-                end
-            end
-
-            def process_current_hash(current)
-                return {} if current == :absent
-
-                #inclusive means we are managing everything so if it isn't in should, its gone
-                if inclusive?
-                    current.each_key { |key| current[key] = nil }
-                end
-                current
-            end
-
-            def should
-                unless defined? @should and @should
-                    return nil
-                end
-
-                members = hashify(@should)
-                current = process_current_hash(retrieve)
-
-                #shared keys will get overwritten by members
-                current.merge(members)
-            end
-
-            def separator
-                "="
-            end
-
-            def delimiter
-                ";"
-            end
-
-            def retrieve
-                #ok, some 'convention' if the keyvalue property is named properties, provider should implement a properties method
-                if key_hash = provider.send(name) and key_hash != :absent
-                    return key_hash
-                else
-                    return :absent
-                end
-            end
-
-            def insync?(is)
-                unless defined? @should and @should
-                    return true
-                end
-
-                unless is
-                    return true
-                end
-
-                return (is == self.should)
-            end
+  class Property
+    class KeyValue < Property
+
+      def hash_to_key_value_s(hash)
+        hash.select { |k,v| true }.map { |pair| pair.join(separator) }.join(delimiter)
+      end
+
+      def should_to_s(should_value)
+        hash_to_key_value_s(should_value)
+      end
+
+      def is_to_s(current_value)
+        hash_to_key_value_s(current_value)
+      end
+
+      def membership
+        :key_value_membership
+      end
+
+      def inclusive?
+        @resource[membership] == :inclusive
+      end
+
+      def hashify(key_value_array)
+        #turns string array into a hash
+        key_value_array.inject({}) do |hash, key_value|
+          tmp = key_value.split(separator)
+          hash[tmp[0].intern] = tmp[1]
+          hash
         end
+      end
+
+      def process_current_hash(current)
+        return {} if current == :absent
+
+        #inclusive means we are managing everything so if it isn't in should, its gone
+        current.each_key { |key| current[key] = nil } if inclusive?
+        current
+      end
+
+      def should
+        return nil unless @should
+
+        members = hashify(@should)
+        current = process_current_hash(retrieve)
+
+        #shared keys will get overwritten by members
+        current.merge(members)
+      end
+
+      def separator
+        "="
+      end
+
+      def delimiter
+        ";"
+      end
+
+      def retrieve
+        #ok, some 'convention' if the keyvalue property is named properties, provider should implement a properties method
+        if key_hash = provider.send(name) and key_hash != :absent
+          return key_hash
+        else
+          return :absent
+        end
+      end
+
+      def insync?(is)
+        return true unless @should
+
+        return true unless is
+
+        (is == self.should)
+      end
     end
+  end
 end

data/lib/puppet/property/list.rb

@@ -1,87 +1,77 @@
 require 'puppet/property'
 
 module Puppet
-    class Property
-        class List < Property
-
-            def should_to_s(should_value)
-                #just return the should value
-                should_value
-            end
-
-            def is_to_s(currentvalue)
-                if currentvalue == :absent
-                    return "absent"
-                else
-                    return currentvalue.join(delimiter)
-                end
-            end
-
-            def membership
-                :membership
-            end
-
-            def add_should_with_current(should, current)
-                if current.is_a?(Array)
-                    should += current
-                end
-                should.uniq
-            end
-
-            def inclusive?
-                @resource[membership] == :inclusive
-            end
-
-            #dearrayify was motivated because to simplify the implementation of the OrderedList property
-            def dearrayify(array)
-                array.sort.join(delimiter)
-            end
-
-            def should
-                unless defined? @should and @should
-                    return nil
-                end
-
-                members = @should
-                #inclusive means we are managing everything so if it isn't in should, its gone
-                if ! inclusive?
-                    members = add_should_with_current(members, retrieve)
-                end
-
-                dearrayify(members)
-            end
-
-            def delimiter
-                ","
-            end
-
-            def retrieve
-                #ok, some 'convention' if the list property is named groups, provider should implement a groups method
-                if tmp = provider.send(name) and tmp != :absent
-                    return tmp.split(delimiter)
-                else
-                    return :absent
-                end
-            end
-
-            def prepare_is_for_comparison(is)
-                if is == :absent
-                    is = []
-                end
-                dearrayify(is)
-            end
-
-            def insync?(is)
-                unless defined? @should and @should
-                    return true
-                end
-
-                unless is
-                    return true
-                end
-
-                return (prepare_is_for_comparison(is) == self.should)
-            end
+  class Property
+    class List < Property
+
+      def should_to_s(should_value)
+        #just return the should value
+        should_value
+      end
+
+      def is_to_s(currentvalue)
+        if currentvalue == :absent
+          return "absent"
+        else
+          return currentvalue.join(delimiter)
         end
+      end
+
+      def membership
+        :membership
+      end
+
+      def add_should_with_current(should, current)
+        should += current if current.is_a?(Array)
+        should.uniq
+      end
+
+      def inclusive?
+        @resource[membership] == :inclusive
+      end
+
+      #dearrayify was motivated because to simplify the implementation of the OrderedList property
+      def dearrayify(array)
+        array.sort.join(delimiter)
+      end
+
+      def should
+        return nil unless @should
+
+        members = @should
+        #inclusive means we are managing everything so if it isn't in should, its gone
+        members = add_should_with_current(members, retrieve) if ! inclusive?
+
+        dearrayify(members)
+      end
+
+      def delimiter
+        ","
+      end
+
+      def retrieve
+        #ok, some 'convention' if the list property is named groups, provider should implement a groups method
+        if tmp = provider.send(name) and tmp != :absent
+          return tmp.split(delimiter)
+        else
+          return :absent
+        end
+      end
+
+      def prepare_is_for_comparison(is)
+        if is == :absent
+          is = []
+        end
+        dearrayify(is)
+      end
+
+      def insync?(is)
+        return true unless @should
+
+        return true unless is
+
+        (prepare_is_for_comparison(is) == self.should)
+      end
     end
+  end
 end

data/lib/puppet/property/ordered_list.rb

@@ -1,22 +1,22 @@
 require 'puppet/property/list'
 
 module Puppet
-    class Property
-        class OrderedList < List
+  class Property
+    class OrderedList < List
 
-            def add_should_with_current(should, current)
-                if current.is_a?(Array)
-                    #tricky trick
-                    #Preserve all the current items in the list
-                    #but move them to the back of the line
-                    should = should + (current - should)
-                end
-                should
-            end
-
-            def dearrayify(array)
-                array.join(delimiter)
-            end
+      def add_should_with_current(should, current)
+        if current.is_a?(Array)
+          #tricky trick
+          #Preserve all the current items in the list
+          #but move them to the back of the line
+          should = should + (current - should)
         end
+        should
+      end
+
+      def dearrayify(array)
+        array.join(delimiter)
+      end
     end
+  end
 end