puppet 3.0.0.rc5 → 3.0.0.rc7

data/lib/puppet/provider/zone/solaris.rb

@@ -9,19 +9,15 @@ Puppet::Type.type(:zone).provide(:solaris) do
   # Convert the output of a list into a hash
   def self.line2hash(line)
     fields = [:id, :name, :ensure, :path, :uuid, :brand, :iptype]
+    properties = Hash[fields.zip(line.split(':'))]
 
-    properties = {}
-    line.split(":").each_with_index { |value, index|
-      next unless fields[index]
-      properties[fields[index]] = value
-    }
-
+    del_id = [:brand, :uuid]
     # Configured but not installed zones do not have IDs
-    properties.delete(:id) if properties[:id] == "-"
+    del_id << :id if properties[:id] == "-"
+    del_id.each { |p| properties.delete(p) }
 
     properties[:ensure] = properties[:ensure].intern
-    properties.delete(:brand)
-    properties.delete(:uuid)
+    properties[:iptype] = 'exclusive' if properties[:iptype] == 'excl'
 
     properties
   end
@@ -33,34 +29,135 @@ Puppet::Type.type(:zone).provide(:solaris) do
     end
   end
 
+  def multi_conf(name, should, &action)
+    has = properties[name]
+    has = [] if has == :absent
+    rms = has - should
+    adds = should - has
+    (rms.map{|o| action.call(:rm,o)} + adds.map{|o| action.call(:add,o)}).join("\n")
+  end
+
+  def self.def_prop(var, str)
+    define_method('%s_conf' % var.to_s) do |v|
+      str % v
+    end
+    define_method('%s=' % var.to_s) do |v|
+      setconfig self.send( ('%s_conf'% var).intern, v)
+    end
+  end
+
+  def self.def_multiprop(var, &conf)
+    define_method(var.to_s) do |v|
+      o = properties[var]
+      return '' if o.nil? or o == :absent
+      o.join(' ')
+    end
+    define_method('%s=' % var.to_s) do |v|
+      setconfig self.send( ('%s_conf'% var).intern, v)
+    end
+    define_method('%s_conf' % var.to_s) do |v|
+      multi_conf(var, v, &conf)
+    end
+  end
+
+  def_prop :iptype, "set ip-type=%s"
+  def_prop :autoboot, "set autoboot=%s"
+  def_prop :path, "set zonepath=%s"
+  def_prop :pool, "set pool=%s"
+  def_prop :shares, "add rctl\nset name=zone.cpu-shares\nadd value (priv=privileged,limit=%s,action=none)\nend"
+
+  def_multiprop :ip do |action, str|
+    interface, ip, defrouter = str.split(':')
+    case action
+    when :add
+      cmd = ["add net"]
+      cmd << "set physical=#{interface}" if interface
+      cmd << "set address=#{ip}" if ip
+      cmd << "set defrouter=#{defrouter}" if defrouter
+      cmd << "end"
+      cmd.join("\n")
+    when :rm
+      if ip
+        "remove net address=#{ip}"
+      elsif interface
+        "remove net physical=#{interface}"
+      else
+        raise ArgumentError, "can not remove network based on default router"
+      end
+    else self.fail action
+    end
+  end
+
+  def_multiprop :dataset do |action, str|
+    case action
+    when :add; ['add dataset',"set name=#{str}",'end'].join("\n")
+    when :rm; "remove dataset name=#{str}"
+    else self.fail action
+    end
+  end
+
+  def_multiprop :inherit do |action, str|
+    case action
+    when :add; ['add inherit-pkg-dir', "set dir=#{str}",'end'].join("\n")
+    when :rm; "remove inherit-pkg-dir dir=#{str}"
+    else self.fail action
+    end
+  end
+
+  def my_properties
+    [:path, :iptype, :autoboot, :pool, :shares, :ip, :dataset, :inherit]
+  end
+
   # Perform all of our configuration steps.
   def configure
     self.fail "Path is required" unless @resource[:path]
-    # If the thing is entirely absent, then we need to create the config.
-    # Is there someway to get this on one line?
-    str = "create -b #{@resource[:create_args]}\nset zonepath=#{@resource[:path]}\n"
+    arr = ["create -b #{@resource[:create_args]}"]
 
     # Then perform all of our configuration steps.  It's annoying
     # that we need this much internal info on the resource.
-    @resource.send(:properties).each do |property|
-      str += property.configtext + "\n" if property.is_a? ZoneConfigProperty and ! property.safe_insync?(properties[property.name])
+    self.resource.properties.each do |property|
+      next unless my_properties.include? property.name
+      method = (property.name.to_s + '_conf').intern
+      arr << self.send(method ,@resource[property.name]) unless property.safe_insync?(properties[property.name])
     end
-
-    str += "commit\n"
-    setconfig(str)
+    setconfig(arr.join("\n"))
   end
 
   def destroy
     zonecfg :delete, "-F"
   end
 
+  def add_cmd(cmd)
+    @cmds = [] if @cmds.nil?
+    @cmds << cmd
+  end
+
   def exists?
     properties[:ensure] != :absent
   end
 
+  # We cannot use the execpipe in util because the pipe is not opened in
+  # read/write mode.
+  def exec_cmd(var)
+    # In bash, the exit value of the last command is the exit value of the
+    # entire pipeline
+    out = execute("echo \"#{var[:input]}\" | #{var[:cmd]}", :failonfail => false, :combine => true)
+    st = $?.exitstatus
+    {:out => out, :exit => st}
+  end
+
   # Clear out the cached values.
   def flush
+    return if @cmds.nil? || @cmds.empty?
+    str = (@cmds << "commit" << "exit").join("\n")
+    @cmds = []
     @property_hash.clear
+
+    command = "#{command(:cfg)} -z #{@resource[:name]} -f -"
+    r = exec_cmd(:cmd => command, :input => str)
+    if r[:exit] != 0 or r[:out] =~ /not allowed/
+      raise ArgumentError, "Failed to apply configuration"
+    end
   end
 
   def install(dummy_argument=:work_arround_for_ruby_GC_bug)
@@ -84,7 +181,6 @@ Puppet::Type.type(:zone).provide(:solaris) do
           @property_hash[name] ||= :absent
         end
       end
-
     end
     @property_hash.dup
   end
@@ -92,19 +188,31 @@ Puppet::Type.type(:zone).provide(:solaris) do
   # We need a way to test whether a zone is in process.  Our 'ensure'
   # property models the static states, but we need to handle the temporary ones.
   def processing?
-    if hash = status
-      case hash[:ensure]
-      when "incomplete", "ready", "shutting_down"
-        true
-      else
-        false
-      end
-    else
-      false
-    end
+    hash = status
+    return false unless hash
+    ["incomplete", "ready", "shutting_down"].include? hash[:ensure]
   end
 
-  # Collect the configuration of the zone.
+  # Collect the configuration of the zone. The output looks like:
+  # zonename: z1
+  # zonepath: /export/z1
+  # brand: native
+  # autoboot: true
+  # bootargs:
+  # pool:
+  # limitpriv:
+  # scheduling-class:
+  # ip-type: shared
+  # hostid:
+  # net:
+  #         address: 192.168.1.1
+  #         physical: eg0001
+  #         defrouter not specified
+  # net:
+  #         address: 192.168.1.3
+  #         physical: eg0002
+  #         defrouter not specified
+  #
   def getconfig
     output = zonecfg :info
 
@@ -116,12 +224,11 @@ Puppet::Type.type(:zone).provide(:solaris) do
       when /^(\S+):\s*$/
         name = $1
         current = nil # reset it
-      when /^(\S+):\s*(.+)$/
+      when /^(\S+):\s*(\S+)$/
         hash[$1.intern] = $2
       when /^\s+(\S+):\s*(.+)$/
         if name
-          hash[name] = [] unless hash.include? name
-
+          hash[name] ||= []
           unless current
             current = {}
             hash[name] << current
@@ -141,16 +248,13 @@ Puppet::Type.type(:zone).provide(:solaris) do
   # Execute a configuration string.  Can't be private because it's called
   # by the properties.
   def setconfig(str)
-    output = cfg '-z', @resource[:name], str
-    if output =~ /not allowed/ or $CHILD_STATUS != 0
-      raise ArgumentError, "Failed to apply configuration"
-    end
+    add_cmd str
   end
 
   def start
-    self.fail "Path is required" unless @resource[:path]
     # Check the sysidcfg stuff
     if cfg = @resource[:sysidcfg]
+      self.fail "Path is required" unless @resource[:path]
       zoneetc = File.join(@resource[:path], "root", "etc")
       sysidcfg = File.join(zoneetc, "sysidcfg")
 
@@ -223,6 +327,7 @@ Puppet::Type.type(:zone).provide(:solaris) do
     if datasets = config["dataset"]
       result[:dataset] = datasets.collect { |dataset| dataset[:name] }
     end
+    result[:iptype] = config[:'ip-type'] if config[:'ip-type']
     if net = config["net"]
       result[:ip] = net.collect do |params|
         if params[:defrouter]
@@ -239,9 +344,9 @@ Puppet::Type.type(:zone).provide(:solaris) do
   end
 
   def zoneadm(*cmd)
-      adm("-z", @resource[:name], *cmd)
+    adm("-z", @resource[:name], *cmd)
   rescue Puppet::ExecutionFailure => detail
-      self.fail "Could not #{cmd[0]} zone: #{detail}"
+    self.fail "Could not #{cmd[0]} zone: #{detail}"
   end
 
   def zonecfg(*cmd)

data/lib/puppet/provider/zpool/zpool.rb

@@ -48,8 +48,10 @@ Puppet::Type.type(:zpool).provide(:zpool) do
   end
 
   def get_pool_data
-    #this is all voodoo dependent on the output from zpool
-    zpool_data = %x{ zpool status #{@resource[:pool]}}.split("\n").select { |line| line.index("\t") == 0 }.collect { |l| l.strip.split("\s")[0] }
+    # http://docs.oracle.com/cd/E19082-01/817-2271/gbcve/index.html
+    # we could also use zpool iostat -v mypool for a (little bit) cleaner output
+    out = execute("zpool status #{@resource[:pool]}", :failonfail => false)
+    zpool_data = out.lines.select { |line| line.index("\t") == 0 }.collect { |l| l.strip.split("\s")[0] }
     zpool_data.shift
     zpool_data
   end
@@ -77,19 +79,14 @@ Puppet::Type.type(:zpool).provide(:zpool) do
     @resource[:raid_parity] ? @resource[:raid_parity] : "raidz1"
   end
 
-  #handle mirror or raid
-  def handle_multi_arrays(prefix, array)
-    array.collect{ |a| [prefix] +  a.split(' ') }.flatten
-  end
-
   #builds up the vdevs for create command
   def build_vdevs
     if disk = @resource[:disk]
       disk.collect { |d| d.split(' ') }.flatten
     elsif mirror = @resource[:mirror]
-      handle_multi_arrays("mirror", mirror)
+      ["mirror"] +  mirror
     elsif raidz = @resource[:raidz]
-      handle_multi_arrays(raidzarity, raidz)
+      [raidzarity] + raidz
     end
   end
 
@@ -115,7 +112,7 @@ Puppet::Type.type(:zpool).provide(:zpool) do
     end
 
     define_method(field.to_s + "=") do |should|
-      Puppet.warning "NO CHANGES BEING MADE: zpool #{field} does not match, should be '#{should}' currently is '#{current_pool[field]}'"
+      self.fail "zpool #{field} can't be changed. should be #{should}, currently is #{current_pool[field]}"
     end
   end
 

data/lib/puppet/settings.rb

@@ -9,6 +9,8 @@ require 'puppet/settings/file_setting'
 require 'puppet/settings/directory_setting'
 require 'puppet/settings/path_setting'
 require 'puppet/settings/boolean_setting'
+require 'puppet/settings/terminus_setting'
+require 'puppet/settings/duration_setting'
 
 # The class for handling configuration files.
 class Puppet::Settings
@@ -20,13 +22,11 @@ class Puppet::Settings
   attr_accessor :files
   attr_reader :timer
 
-  READ_ONLY_SETTINGS = [:run_mode]
-
   # These are the settings that every app is required to specify; there are reasonable defaults defined in application.rb.
-  REQUIRED_APP_SETTINGS = [:run_mode, :logdir, :confdir, :vardir]
+  REQUIRED_APP_SETTINGS = [:logdir, :confdir, :vardir]
 
   # This method is intended for puppet internal use only; it is a convenience method that
-  #  returns reasonable application default settings values for a given run_mode.
+  # returns reasonable application default settings values for a given run_mode.
   def self.app_defaults_for_run_mode(run_mode)
     {
         :name     => run_mode.to_s,
@@ -139,22 +139,11 @@ class Puppet::Settings
     raise Puppet::DevError, "Attempting to initialize global default settings more than once!" if global_defaults_initialized?
 
     # The first two phases of the lifecycle of a puppet application are:
-    #  1) To parse the command line options and handle any of them that are registered, defined "global" puppet
-    #     settings (mostly from defaults.rb).)
-    #  2) To parse the puppet config file(s).
-    #
-    # These 2 steps are being handled explicitly here.  If there ever arises a situation where they need to be
-    # triggered from outside of this class, without triggering the rest of the lifecycle--we might want to move them
-    # out into a separate method that we call from here.  However, this seems to be sufficient for now.
-    #  --cprice 2012-03-16
+    # 1) Parse the command line options and handle any of them that are
+    #    registered, defined "global" puppet settings (mostly from defaults.rb).
+    # 2) Parse the puppet config file(s).
 
-    # Here's step 1.
     parse_global_options(args)
-
-    # Here's step 2.  NOTE: this is a change in behavior where we are now parsing the config file on every run;
-    # before, there were several apps that specifically registered themselves as not requiring anything from
-    # the config file.  The fact that we're always parsing it now might be a small performance hit, but it was
-    # necessary in order to make sure that we can resolve the libdir before we look for the available applications.
     parse_config_files
 
     @global_defaults_initialized = true
@@ -179,26 +168,22 @@ class Puppet::Settings
       end
     end
 
-    option_parser.parse(args)
+    option_parser.on('--run_mode',
+                     "The effective 'run mode' of the application: master, agent, or user.",
+                     :REQUIRED) do |arg|
+      Puppet.settings.preferred_run_mode = arg
+
+      # remove this option from the arguments so that later parses don't think
+      # it is an unknown option
+      option_index = args.index '--run_mode'
+      args.delete_at option_index
+      args.delete_at option_index
+    end
 
+    option_parser.parse(args)
   end
   private :parse_global_options
 
-
-  ## Private utility method; this is the callback that the OptionParser will use when it finds
-  ## an option that was defined in Puppet.settings.  All that this method does is a little bit
-  ## of clanup to get the option into the exact format that Puppet.settings expects it to be in,
-  ## and then passes it along to Puppet.settings.
-  ##
-  ## @param [String] opt the command-line option that was matched
-  ## @param [String, TrueClass, FalseClass] the value for the setting (as determined by the OptionParser)
-  #def handlearg(opt, val)
-  #  opt, val = self.class.clean_opt(opt, val)
-  #  Puppet.settings.handlearg(opt, val)
-  #end
-  #private :handlearg
-
-
   # A utility method (public, is used by application.rb and perhaps elsewhere) that munges a command-line
   # option string into the format that Puppet.settings expects.  (This mostly has to deal with handling the
   # "no-" prefix on flag/boolean options).
@@ -227,7 +212,11 @@ class Puppet::Settings
     end
 
     app_defaults.each do |key, value|
-      set_value(key, value, :application_defaults)
+      if key == :run_mode
+        self.preferred_run_mode = value
+      else
+        set_value(key, value, :application_defaults)
+      end
     end
     call_hooks_deferred_to_application_initialization
 
@@ -255,6 +244,8 @@ class Puppet::Settings
       varname = $2 || $1
       if varname == "environment" and environment
         environment
+      elsif varname == "run_mode"
+        preferred_run_mode
       elsif pval = self.value(varname, environment)
         pval
       else
@@ -439,18 +430,22 @@ class Puppet::Settings
     end
   end
 
-  # Figure out the section name for the run_mode.
-  def run_mode
-    @run_mode || :user
+  # The currently configured run mode that is preferred for constructing the application configuration.
+  def preferred_run_mode
+    @preferred_run_mode_name || :user
   end
 
   # PRIVATE!  This only exists because we need a hook to validate the run mode when it's being set, and
   #  it should never, ever, ever, ever be called from outside of this file.
-  def run_mode=(mode)
+  # This method is also called when --run_mode MODE is used on the command line to set the default
+  #
+  # @param mode [String|Symbol] the name of the mode to have in effect
+  # @api private
+  def preferred_run_mode=(mode)
+    mode = mode.to_s.downcase.intern
     raise ValidationError, "Invalid run mode '#{mode}'" unless [:master, :agent, :user].include?(mode)
-    @run_mode = mode
+    @preferred_run_mode_name = mode
   end
-  private :run_mode=
 
   # Return all of the parameters associated with a given section.
   def params(section = nil)
@@ -475,7 +470,7 @@ class Puppet::Settings
     # configuration model to the end user.  It should also be noted we decided
     # to merge in the user puppet.conf with the system puppet.conf for a time
     # (e.g. load two configuration files) as a small part of #7749 but then
-    # decided to reverse this decision in 15337 to return to a disjoint
+    # decided to reverse this decision in #15337 to return to a disjoint
     # configuration file model.
     config_files = [which_configuration_file]
 
@@ -483,22 +478,11 @@ class Puppet::Settings
       unsafe_parse(config_files)
     end
 
-    # talking with cprice, Settings.parse will not be the final location for this. He's working on ticket
-    # that, as a side effect, will create a more appropriate place for this. At that time, this will be
-    # moved to the new location. --jeffweiss 24 apr 2012
     call_hooks_deferred_to_application_initialization :ignore_interpolation_dependency_errors => true
   end
   private :parse_config_files
 
   def main_config_file
-    # the algorithm here is basically this:
-    #  * use the explicit config file location if one has been specified; this
-    #    can be affected by modifications to either the "confdir" or "config"
-    #    settings (most likely via CLI arguments).
-    #  * if no explicit config location has been specified, we fall back to
-    #    the default.
-    #
-    # return the default value.
     if explicit_config_file?
       return self[:config]
     else
@@ -512,12 +496,14 @@ class Puppet::Settings
   end
   private :user_config_file
 
-  # This method is here to get around some life-cycle issues.  We need to be able to determine the config file name
-  # before the settings / defaults are fully loaded.  However, we also need to respect any overrides of this value
+  # This method is here to get around some life-cycle issues.  We need to be
+  # able to determine the config file name before the settings / defaults are
+  # fully loaded.  However, we also need to respect any overrides of this value
   # that the user may have specified on the command line.
   #
-  # The easiest way to do this is to attempt to read the setting, and if we catch an error (meaning that it hasn't been
-  #  set yet), we'll fall back to the default value.
+  # The easiest way to do this is to attempt to read the setting, and if we
+  # catch an error (meaning that it hasn't been set yet), we'll fall back to
+  # the default value.
   def config_file_name
     begin
       return self[:config_file_name] if self[:config_file_name]
@@ -598,7 +584,7 @@ class Puppet::Settings
     # because multiple sections could set the same value
     # and I'm too lazy to only set the metadata once.
     searchpath.reverse.each do |source|
-      source = run_mode if source == :run_mode
+      source = preferred_run_mode if source == :run_mode
       source = @name if (@name && source == :name)
       if meta = metas[source]
         set_metadata(meta)
@@ -624,6 +610,8 @@ class Puppet::Settings
           :directory  => DirectorySetting,
           :path       => PathSetting,
           :boolean    => BooleanSetting,
+          :terminus   => TerminusSetting,
+          :duration   => DurationSetting,
       } [type]
         raise ArgumentError, "Invalid setting type '#{type}'"
       end
@@ -738,7 +726,7 @@ class Puppet::Settings
   def set_value(param, value, type, options = {})
     param = param.to_sym
 
-    unless setting = @config[param]
+    if !(setting = @config[param])
       if options[:ignore_bad_settings]
         return
       else
@@ -748,10 +736,6 @@ class Puppet::Settings
     end
 
     setting.handle(value) if setting.has_hook? and not options[:dont_trigger_handles]
-    if read_only_settings.include? param and type != :application_defaults
-      raise ArgumentError,
-        "You're attempting to set configuration parameter $#{param}, which is read-only."
-    end
 
     @sync.synchronize do # yay, thread-safe
 
@@ -768,19 +752,6 @@ class Puppet::Settings
       Puppet::Node::Environment.clear if defined?(Puppet::Node) and defined?(Puppet::Node::Environment)
     end
 
-    # This is a hack.  The run_mode should probably not be a "normal" setting, because the places
-    #  it is used tend to create lifecycle issues and cause other weird problems.  In some places
-    #  we need for it to have a default value, in other places it may be preferable to be able to
-    #  determine that it has not yet been set.  There used to be a global variable that some
-    #  code paths would access; as a first step towards cleaning it up, I've gotten rid of the global
-    #  variable and am instead using an instance variable in this class, but that means that if
-    #  someone modifies the value of the setting at a later point during execution, then the
-    #  instance variable needs to be updated as well... so that's what we're doing here.
-    #
-    #  This code should be removed if we get a chance to remove run_mode from the defined settings.
-    #  --cprice 2012-03-19
-    self.run_mode = value if param == :run_mode
-
     value
   end
 
@@ -889,12 +860,10 @@ Generated on #{Time.now}.
 }.gsub(/^/, "# ")
 
 #         Add a section heading that matches our name.
-if @config.include?(:run_mode)
-  str += "[#{self[:run_mode]}]\n"
-    end
+    str += "[#{preferred_run_mode}]\n"
     eachsection do |section|
       persection(section) do |obj|
-        str += obj.to_config + "\n" unless read_only_settings.include? obj.name or obj.name == :genconfig
+        str += obj.to_config + "\n" unless obj.name == :genconfig
       end
     end
 
@@ -1078,11 +1047,6 @@ if @config.include?(:run_mode)
 
   private
 
-  # This is just here to simplify testing.  This method can be stubbed easily.  Constants can't.
-  def read_only_settings()
-    READ_ONLY_SETTINGS
-  end
-
   def get_config_file_default(default)
     obj = nil
     unless obj = @config[default]
@@ -1119,7 +1083,7 @@ if @config.include?(:run_mode)
     searchpath(environment).each do |source|
 
       # Modify the source as necessary.
-      source = self.run_mode if source == :run_mode
+      source = self.preferred_run_mode if source == :run_mode
       yield source
     end
   end