puppet 3.0.0.rc5 → 3.0.0.rc7

data/lib/puppet/type/augeas.rb

@@ -20,7 +20,7 @@ Puppet::Type.newtype(:augeas) do
   feature :need_to_run?, "If the command should run"
   feature :execute_changes, "Actually make the changes"
 
-  @doc = <<-EOT
+  @doc = <<-'EOT'
     Apply a change or an array of changes to the filesystem
     using the augeas tool.
 

data/lib/puppet/type/cron.rb

@@ -3,7 +3,7 @@ require 'facter'
 require 'puppet/util/filetype'
 
 Puppet::Type.newtype(:cron) do
-  @doc = <<-EOT
+  @doc = <<-'EOT'
     Installs and manages cron jobs.  Every cron resource requires a command
     and user attribute, as well as at least one periodic attribute (hour,
     minute, month, monthday, weekday, or special).  While the name of the cron

data/lib/puppet/type/exec.rb

@@ -180,10 +180,9 @@ module Puppet
     end
 
     newparam(:logoutput) do
-      desc "Whether to log output.  Defaults to logging output at the
-        loglevel for the `exec` resource. Use *on_failure* to only
-        log the output when the command reports an error.  Values are
-        **true**, *false*, *on_failure*, and any legal log level."
+      desc "Whether to log output.  Defaults to `on_failure`, which only logs
+        the output when the command has a non-zero exit code.  In addition to
+        the values below, you may set this attribute to any legal log level."
 
       defaultto :on_failure
 
@@ -276,7 +275,7 @@ module Puppet
 
 
     newcheck(:refreshonly) do
-      desc <<-EOT
+      desc <<-'EOT'
         The command should only be run as a
         refresh mechanism for when a dependent object is changed.  It only
         makes sense to use this option when this command depends on some
@@ -313,7 +312,7 @@ module Puppet
     end
 
     newcheck(:creates, :parent => Puppet::Parameter::Path) do
-      desc <<-EOT
+      desc <<-'EOT'
         A file that this command creates.  If this
         parameter is provided, then the command will only be run
         if the specified file does not exist.
@@ -338,7 +337,7 @@ module Puppet
     end
 
     newcheck(:unless) do
-      desc <<-EOT
+      desc <<-'EOT'
         If this parameter is set, then this `exec` will run unless
         the command returns 0.  For example:
 
@@ -380,7 +379,7 @@ module Puppet
     end
 
     newcheck(:onlyif) do
-      desc <<-EOT
+      desc <<-'EOT'
         If this parameter is set, then this `exec` will only run if
         the command returns 0.  For example:
 

data/lib/puppet/type/file.rb

@@ -38,7 +38,7 @@ Puppet::Type.newtype(:file) do
   end
 
   newparam(:path) do
-    desc <<-EOT
+    desc <<-'EOT'
       The path to the file to manage.  Must be fully qualified.
 
       On Windows, the path should include the drive letter and should use `/` as

data/lib/puppet/type/file/content.rb

@@ -15,7 +15,7 @@ module Puppet
 
     attr_reader :actual_content
 
-    desc <<-EOT
+    desc <<-'EOT'
       The desired contents of a file, as a string. This attribute is mutually
       exclusive with `source` and `target`.
 
@@ -177,7 +177,7 @@ module Puppet
         yield read_file_from_filebucket
       elsif source_or_content.nil?
         yield ''
-      elsif Puppet[:default_file_terminus] == "file_server"
+      elsif Puppet[:default_file_terminus] == :file_server
         yield source_or_content.content
       elsif source_or_content.local?
         chunk_file_from_disk(source_or_content) { |chunk| yield chunk }

data/lib/puppet/type/file/ensure.rb

@@ -5,7 +5,7 @@ module Puppet
     require 'puppet/util/symbolic_file_mode'
     include Puppet::Util::SymbolicFileMode
 
-    desc <<-EOT
+    desc <<-'EOT'
       Whether to create files that don't currently exist.
       Possible values are *absent*, *present*, *file*, and *directory*.
       Specifying `present` will match any form of file existence, and

data/lib/puppet/type/file/mode.rb

@@ -6,7 +6,7 @@ module Puppet
     require 'puppet/util/symbolic_file_mode'
     include Puppet::Util::SymbolicFileMode
 
-    desc <<-EOT
+    desc <<-'EOT'
       The desired permissions mode for the file, in symbolic or numeric
       notation. Puppet uses traditional Unix permission schemes and translates
       them to equivalent permissions for systems which represent permissions

data/lib/puppet/type/file/selcontext.rb

@@ -48,9 +48,13 @@ module Puppet
     def insync?(value)
       if not selinux_support?
         debug("SELinux bindings not found. Ignoring parameter.")
-        return true
+        true
+      elsif not selinux_label_support?(@resource[:path])
+        debug("SELinux not available for this filesystem. Ignoring parameter.")
+        true
+      else
+        super
       end
-      super
     end
 
     def sync

data/lib/puppet/type/file/source.rb

@@ -12,7 +12,7 @@ module Puppet
     include Puppet::Util::Diff
 
     attr_accessor :source, :local
-    desc <<-EOT
+    desc <<-'EOT'
       A source file, which will be copied into place on the local system.
       Values can be URIs pointing to remote files, or fully qualified paths to
       files available on the local system (including files on NFS shares or

data/lib/puppet/type/schedule.rb

@@ -1,6 +1,6 @@
 module Puppet
   newtype(:schedule) do
-    @doc = <<-EOT
+    @doc = <<-'EOT'
       Define schedules for Puppet. Resources can be limited to a schedule by using the
       [`schedule`](http://docs.puppetlabs.com/references/latest/metaparameter.html#schedule)
       metaparameter.

data/lib/puppet/type/scheduled_task.rb

@@ -80,7 +80,7 @@ Puppet::Type.newtype(:scheduled_task) do
   end
 
   newproperty(:trigger, :array_matching => :all) do
-    desc <<-EOT
+    desc <<-'EOT'
       One or more triggers defining when the task should run. A single trigger is
       represented as a hash, and multiple triggers can be specified with an array of
       hashes.

data/lib/puppet/type/tidy.rb

@@ -43,7 +43,7 @@ Puppet::Type.newtype(:tidy) do
   end
 
   newparam(:matches) do
-    desc <<-EOT
+    desc <<-'EOT'
       One or more (shell type) file glob patterns, which restrict
       the list of files to be tidied to those whose basenames match
       at least one of the patterns specified. Multiple patterns can

data/lib/puppet/type/zone.rb

@@ -1,3 +1,4 @@
+require 'puppet/property/list'
 Puppet::Type.newtype(:zone) do
   @doc = "Manages Solaris zones.
 
@@ -5,69 +6,45 @@ Puppet::Type.newtype(:zone) do
 the zone's filesystem (with the `path` attribute), the zone resource will
 autorequire that directory."
 
-  # These properties modify the zone configuration, and they need to provide
-  # the text separately from syncing it, so all config statements can be rolled
-  # into a single creation statement.
-  class ZoneConfigProperty < Puppet::Property
-    # Perform the config operation.
-    def sync
-      provider.setconfig self.configtext
+  class StateMachine
+    # A silly little state machine.
+    def initialize
+      @state = {}
+      @sequence = []
+      @state_aliases = {}
+      @default = nil
     end
-  end
-
-  # Those properties that can have multiple instances.
-  class ZoneMultiConfigProperty < ZoneConfigProperty
-    def configtext
-      list = @should
-
-      current_value = self.retrieve
-
-      unless current_value.is_a? Symbol
-        if current_value.is_a? Array
-          list += current_value
-        else
-          list << current_value if current_value
-        end
-      end
 
-      # Some hackery so we can test whether current_value is an array or a symbol
-      if current_value.is_a? Array
-        tmpis = current_value
-      else
-        if current_value
-          tmpis = [current_value]
-        else
-          tmpis = []
-        end
-      end
-
-      rms = []
-      adds = []
+    # The order of calling insert_state is important
+    def insert_state(name, transitions)
+      @sequence << name
+      @state[name] = transitions
+    end
 
-      # Collect the modifications to make
-      list.sort.uniq.collect do |obj|
-        # Skip objectories that are configured and should be
-        next if tmpis.include?(obj) and @should.include?(obj)
+    def alias_state(state, salias)
+      @state_aliases[state] = salias
+    end
 
-        if tmpis.include?(obj)
-          rms << obj
-        else
-          adds << obj
-        end
-      end
+    def name(n)
+      @state_aliases[n.to_sym] || n.to_sym
+    end
 
+    def index(state)
+      @sequence.index(name(state))
+    end
 
-      # And then perform all of the removals before any of the adds.
-      (rms.collect { |o| rm(o) } + adds.collect { |o| add(o) }).join("\n")
+    # return all states between fs and ss excluding fs
+    def sequence(fs, ss)
+      fi = index(fs)
+      si= index(ss)
+      (if fi > si
+        then @sequence[si .. fi].map{|i| @state[i]}.reverse
+        else @sequence[fi .. si].map{|i| @state[i]}
+      end)[1..-1]
     end
 
-    # We want all specified directories to be included.
-    def insync?(current_value)
-      if current_value.is_a? Array and @should.is_a? Array
-        current_value.sort == @should.sort
-      else
-        current_value == @should
-      end
+    def cmp?(a,b)
+      index(a) < index(b)
     end
   end
 
@@ -78,98 +55,66 @@ autorequire that directory."
       only then can be `running`.  Note also that `halt` is currently
       used to stop zones."
 
-    @states = {}
-    @parametervalues = []
+    def self.fsm
+      return @fsm if @fsm
+      @fsm = StateMachine.new
+    end
 
     def self.alias_state(values)
-      @state_aliases ||= {}
-      values.each do |nick, name|
-        @state_aliases[nick] = name
+      values.each do |k,v|
+        fsm.alias_state(k,v)
       end
     end
 
-    def self.newvalue(name, hash)
-      @parametervalues = [] if @parametervalues.is_a? Hash
-
-      @parametervalues << name
-
-      @states[name] = hash
-      hash[:name] = name
-    end
-
-    def self.state_name(name)
-      @state_aliases[name.to_sym] || name.to_sym
+    def self.seqvalue(name, hash)
+      fsm.insert_state(name, hash)
+      self.newvalue name
     end
 
-    newvalue :absent, :down => :destroy
-    newvalue :configured, :up => :configure, :down => :uninstall
-    newvalue :installed, :up => :install, :down => :stop
-    newvalue :running, :up => :start
+    # This is seq value because the order of declaration is important.
+    # i.e we go linearly from :absent -> :configured -> :installed -> :running
+    seqvalue :absent, :down => :destroy
+    seqvalue :configured, :up => :configure, :down => :uninstall
+    seqvalue :installed, :up => :install, :down => :stop
+    seqvalue :running, :up => :start
 
     alias_state :incomplete => :installed, :ready => :installed, :shutting_down => :running
 
     defaultto :running
 
-    def self.state_index(value)
-      @parametervalues.index(state_name(value))
-    end
-
-    # Return all of the states between two listed values, exclusive
-    # of the first item.
     def self.state_sequence(first, second)
-      findex = sindex = nil
-      unless findex = @parametervalues.index(state_name(first))
-        raise ArgumentError, "'#{first}' is not a valid zone state"
-      end
-      unless sindex = @parametervalues.index(state_name(second))
-        raise ArgumentError, "'#{first}' is not a valid zone state"
-      end
-      list = nil
-
-      # Apparently ranges are unidirectional, so we have to reverse
-      # the range op twice.
-      if findex > sindex
-        list = @parametervalues[sindex..findex].collect do |name|
-          @states[name]
-        end.reverse
-      else
-        list = @parametervalues[findex..sindex].collect do |name|
-          @states[name]
-        end
-      end
-
-      # The first result is the current state, so don't return it.
-      list[1..-1]
+      fsm.sequence(first, second)
     end
 
+    # Why override it? because property/ensure.rb has a default retrieve method
+    # that knows only about :present and :absent. That method just calls
+    # provider.exists? and returns :present if a result was returned.
     def retrieve
       provider.properties[:ensure]
     end
 
+    def provider_sync_send(method)
+      warned = false
+      while provider.processing?
+        next if warned
+        info "Waiting for zone to finish processing"
+        warned = true
+        sleep 1
+      end
+      provider.send(method)
+      provider.flush()
+    end
+
     def sync
       method = nil
-      if up?
-        direction = :up
-      else
-        direction = :down
-      end
+      direction = up? ? :up : :down
 
       # We need to get the state we're currently in and just call
       # everything between it and us.
       self.class.state_sequence(self.retrieve, self.should).each do |state|
-        if method = state[direction]
-          warned = false
-          while provider.processing?
-            unless warned
-              info "Waiting for zone to finish processing"
-              warned = true
-            end
-            sleep 1
-          end
-          provider.send(method)
-        else
-          raise Puppet::DevError, "Cannot move #{direction} from #{st[:name]}"
-        end
+        method = state[direction]
+        raise Puppet::DevError, "Cannot move #{direction} from #{st[:name]}" unless method
+        provider_sync_send(method)
       end
 
       ("zone_#{self.should}").intern
@@ -177,18 +122,9 @@ autorequire that directory."
 
     # Are we moving up the property tree?
     def up?
-      current_value = self.retrieve
-      self.class.state_index(current_value) < self.class.state_index(self.should)
+      self.class.fsm.cmp?(self.retrieve, self.should)
     end
 
-    # We override the newvalue in the parent class. Thus the values that we get from the
-    # manifest are stored as they are and later compared to the current state of the instance,
-    # which is in symbol form. Hence we have to convert this to symbol here for now.
-    # TODO: fix this so that munging is no longer necessary. see also #15886
-
-    munge do |value|
-      value.intern
-    end
   end
 
   newparam(:name) do
@@ -209,82 +145,47 @@ autorequire that directory."
       zone will be used. The zone from which you clone must not be running."
   end
 
-  newproperty(:ip, :parent => ZoneMultiConfigProperty) do
+  newproperty(:ip, :parent => Puppet::Property::List) do
     require 'ipaddr'
 
     desc "The IP address of the zone.  IP addresses must be specified
       with the interface, separated by a colon, e.g.: bge0:192.168.0.1.
       For multiple interfaces, specify them in an array."
 
-    # Add an interface.
-    def add(str)
-      interface, ip, defrouter = ipsplit(str)
-      cmd = "add net\n"
-      cmd += "set physical=#{interface}\n" if interface
-      cmd += "set address=#{ip}\n" if ip
-      cmd += "set defrouter=#{defrouter}\n" if defrouter
-      #if @resource[:iptype] == :shared
-      cmd += "end\n"
+    # The default action of list should is to lst.join(' '). By specifying
+    # @should, we ensure the should remains an array. If we override should, we
+    # should also override insync?() -- property/list.rb
+    def should
+      @should
     end
 
-    # Convert a string into the component interface, address and defrouter
-    def ipsplit(str)
-      interface, address, defrouter = str.split(':')
-      return interface, address, defrouter
-    end
-
-    # Remove an interface.
-    def rm(str)
-      interface, ip, defrouter = ipsplit(str)
-      # Reality seems to disagree with the documentation here; the docs
-      # specify that braces are required, but they're apparently only
-      # required if you're specifying multiple values.
-      if ip
-        "remove net address=#{ip}"
-      elsif interface
-        "remove net interface=#{interface}"
-      else
-        raise ArgumentError, "can not remove network based on default router"
-      end
+    # overridden so that we match with self.should
+    def insync?(is)
+      return true unless is
+      is = [] if is == :absent
+      is.sort == self.should.sort
     end
   end
 
-  newproperty(:iptype, :parent => ZoneConfigProperty) do
+  newproperty(:iptype) do
     desc "The IP stack type of the zone."
-
     defaultto :shared
-
     newvalue :shared
     newvalue :exclusive
-
-    def configtext
-      "set ip-type=#{self.should}"
-    end
   end
 
-  newproperty(:autoboot, :parent => ZoneConfigProperty) do
+  newproperty(:autoboot, :boolean => true) do
     desc "Whether the zone should automatically boot."
-
     defaultto true
-
-    newvalue(:true) {}
-    newvalue(:false) {}
-
-    def configtext
-      "set autoboot=#{self.should}"
-    end
+    newvalues(:true, :false)
   end
 
-  newproperty(:path, :parent => ZoneConfigProperty) do
+  newproperty(:path) do
     desc "The root of the zone's filesystem.  Must be a fully qualified
       file name.  If you include `%s` in the path, then it will be
       replaced with the zone's name.  Currently, you cannot use
       Puppet to move a zone. Consequently this is a readonly property."
 
-    def configtext
-      "set zonepath=#{self.should}"
-    end
-
     validate do |value|
       raise ArgumentError, "The zone base must be fully qualified" unless value =~ /^\//
     end
@@ -298,74 +199,57 @@ autorequire that directory."
     end
   end
 
-  newproperty(:pool, :parent => ZoneConfigProperty) do
+  newproperty(:pool) do
     desc "The resource pool for this zone."
-
-    def configtext
-      "set pool=#{self.should}"
-    end
   end
 
-  newproperty(:shares, :parent => ZoneConfigProperty) do
+  newproperty(:shares) do
     desc "Number of FSS CPU shares allocated to the zone."
-
-    def configtext
-      "add rctl\nset name=zone.cpu-shares\nadd value (priv=privileged,limit=#{self.should},action=none)\nend"
-    end
   end
 
-  newproperty(:dataset, :parent => ZoneMultiConfigProperty) do
+  newproperty(:dataset, :parent => Puppet::Property::List ) do
     desc "The list of datasets delegated to the non-global zone from the
       global zone.  All datasets must be zfs filesystem names which are
       different from the mountpoint."
 
+    def should
+      @should
+    end
+
+    # overridden so that we match with self.should
+    def insync?(is)
+      return true unless is
+      is = [] if is == :absent
+      is.sort == self.should.sort
+    end
+
     validate do |value|
       unless value !~ /^\//
         raise ArgumentError, "Datasets must be the name of a zfs filesystem"
       end
     end
+  end
 
-    # Add a zfs filesystem to our list of datasets.
-    def add(dataset)
-      "add dataset\nset name=#{dataset}\nend"
-    end
-
-    # Remove a zfs filesystem from our list of datasets.
-    def rm(dataset)
-      "remove dataset name=#{dataset}"
-    end
+  newproperty(:inherit, :parent => Puppet::Property::List) do
+    desc "The list of directories that the zone inherits from the global
+      zone.  All directories must be fully qualified."
 
     def should
       @should
     end
-  end
-
 
-  newproperty(:inherit, :parent => ZoneMultiConfigProperty) do
-    desc "The list of directories that the zone inherits from the global
-      zone.  All directories must be fully qualified."
+    # overridden so that we match with self.should
+    def insync?(is)
+      return true unless is
+      is = [] if is == :absent
+      is.sort == self.should.sort
+    end
 
     validate do |value|
       unless value =~ /^\//
         raise ArgumentError, "Inherited filesystems must be fully qualified"
       end
     end
-
-    # Add a directory to our list of inherited directories.
-    def add(dir)
-      "add inherit-pkg-dir\nset dir=#{dir}\nend"
-    end
-
-    def rm(dir)
-      # Reality seems to disagree with the documentation here; the docs
-      # specify that braces are required, but they're apparently only
-      # required if you're specifying multiple values.
-      "remove inherit-pkg-dir dir=#{dir}"
-    end
-
-    def should
-      @should
-    end
   end
 
   # Specify the sysidcfg file.  This is pretty hackish, because it's
@@ -429,22 +313,14 @@ autorequire that directory."
   # type.  We just need to autorequire the dataset zfs itself as the zfs type
   # will autorequire all of the zfs parents and zpool.
   autorequire(:zfs) do
-
-  # Check if we have datasets in our zone configuration
-    if @parameters.include? :dataset
-      reqs = []
-      # Autorequire each dataset
-      self[:dataset].each { |value|
-        reqs << value
-      }
-      reqs
-    end
+    # Check if we have datasets in our zone configuration and autorequire each dataset
+    self[:dataset] if @parameters.include? :dataset
   end
 
   def validate_ip(ip, name)
-      IPAddr.new(ip) if ip
+    IPAddr.new(ip) if ip
   rescue ArgumentError
-      self.fail "'#{ip}' is an invalid #{name}"
+    self.fail "'#{ip}' is an invalid #{name}"
   end
 
   def validate_exclusive(interface, address, router)
@@ -460,26 +336,24 @@ autorequire that directory."
 
   validate do
     return unless self[:ip]
-    interface, address, router = self[:ip].split(':')
-    if self[:iptype] == :shared
-      validate_shared(interface, address, router)
-    else
-      validate_exclusive(interface, address, router)
+    # self[:ip] reflects the type passed from proeprty:ip.should. If we
+    # override it and pass @should, then we get an array here back.
+    self[:ip].each do |ip|
+      interface, address, router = ip.split(':')
+      if self[:iptype] == :shared
+        validate_shared(interface, address, router)
+      else
+        validate_exclusive(interface, address, router)
+      end
     end
   end
 
   def retrieve
     provider.flush
-    if hash = provider.properties and hash[:ensure] != :absent
-      result = setstatus(hash)
-      result
-    else
-      # Return all properties as absent.
-      return properties.inject({}) do | prophash, property|
-        prophash[property] = :absent
-        prophash
-      end
-    end
+    hash = provider.properties
+    return setstatus(hash) unless hash.nil? or hash[:ensure] == :absent
+    # Return all properties as absent.
+    return Hash[properties.map{|p| [p, :absent]} ]
   end
 
   # Take the results of a listing and set everything appropriately.
@@ -490,9 +364,8 @@ autorequire that directory."
       case self.class.attrtype(param)
       when :property
         # Only try to provide values for the properties we're managing
-        if prop = self.property(param)
-          prophash[prop] = value
-        end
+        prop = self.property(param)
+        prophash[prop] = value if prop
       else
         self[param] = value
       end