puppet-parse 0.0.1 → 0.0.2

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

@@ -0,0 +1,260 @@
+Puppet::Type.type(:zone).provide(:solaris) do
+  desc "Provider for Solaris Zones."
+
+  commands :adm => "/usr/sbin/zoneadm", :cfg => "/usr/sbin/zonecfg"
+  defaultfor :operatingsystem => :solaris
+
+  mk_resource_methods
+
+  # Convert the output of a list into a hash
+  def self.line2hash(line)
+    fields = [:id, :name, :ensure, :path]
+
+    properties = {}
+    line.split(":").each_with_index { |value, index|
+      next unless fields[index]
+      properties[fields[index]] = value
+    }
+
+    # Configured but not installed zones do not have IDs
+    properties.delete(:id) if properties[:id] == "-"
+
+    properties[:ensure] = properties[:ensure].intern
+
+    properties
+  end
+
+  def self.instances
+    # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
+    x = adm(:list, "-cp").split("\n").collect do |line|
+      new(line2hash(line))
+    end
+  end
+
+  # Perform all of our configuration steps.
+  def configure
+    # 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"
+
+    # 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])
+    end
+
+    str += "commit\n"
+    setconfig(str)
+  end
+
+  def destroy
+    zonecfg :delete, "-F"
+  end
+
+  def exists?
+    properties[:ensure] != :absent
+  end
+
+  # Clear out the cached values.
+  def flush
+    @property_hash.clear
+  end
+
+  def install(dummy_argument=:work_arround_for_ruby_GC_bug)
+    if @resource[:clone] # TODO: add support for "-s snapshot"
+      zoneadm :clone, @resource[:clone]
+    elsif @resource[:install_args]
+      zoneadm :install, @resource[:install_args].split(" ")
+    else
+      zoneadm :install
+    end
+  end
+
+  # Look up the current status.
+  def properties
+    if @property_hash.empty?
+      @property_hash = status || {}
+      if @property_hash.empty?
+        @property_hash[:ensure] = :absent
+      else
+        @resource.class.validproperties.each do |name|
+          @property_hash[name] ||= :absent
+        end
+      end
+
+    end
+    @property_hash.dup
+  end
+
+  # 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
+  end
+
+  # Collect the configuration of the zone.
+  def getconfig
+    output = zonecfg :info
+
+    name = nil
+    current = nil
+    hash = {}
+    output.split("\n").each do |line|
+      case line
+      when /^(\S+):\s*$/
+        name = $1
+        current = nil # reset it
+      when /^(\S+):\s*(.+)$/
+        hash[$1.intern] = $2
+      when /^\s+(\S+):\s*(.+)$/
+        if name
+          hash[name] = [] unless hash.include? name
+
+          unless current
+            current = {}
+            hash[name] << current
+          end
+          current[$1.intern] = $2
+        else
+          err "Ignoring '#{line}'"
+        end
+      else
+        debug "Ignoring zone output '#{line}'"
+      end
+    end
+
+    hash
+  end
+
+  # Execute a configuration string.  Can't be private because it's called
+  # by the properties.
+  def setconfig(str)
+    command = "#{command(:cfg)} -z #{@resource[:name]} -f -"
+    debug "Executing '#{command}' in zone #{@resource[:name]} with '#{str}'"
+    IO.popen(command, "w") do |pipe|
+      pipe.puts str
+    end
+
+    unless $CHILD_STATUS == 0
+      raise ArgumentError, "Failed to apply configuration"
+    end
+  end
+
+  def start
+    # Check the sysidcfg stuff
+    if cfg = @resource[:sysidcfg]
+      zoneetc = File.join(@resource[:path], "root", "etc")
+      sysidcfg = File.join(zoneetc, "sysidcfg")
+
+      # if the zone root isn't present "ready" the zone
+      # which makes zoneadmd mount the zone root
+      zoneadm :ready unless File.directory?(zoneetc)
+
+      unless File.exists?(sysidcfg)
+        begin
+          File.open(sysidcfg, "w", 0600) do |f|
+            f.puts cfg
+          end
+        rescue => detail
+          puts detail.stacktrace if Puppet[:debug]
+          raise Puppet::Error, "Could not create sysidcfg: #{detail}"
+        end
+      end
+    end
+
+    zoneadm :boot
+  end
+
+  # Return a hash of the current status of this zone.
+  def status
+    begin
+      output = adm "-z", @resource[:name], :list, "-p"
+    rescue Puppet::ExecutionFailure
+      return nil
+    end
+
+    main = self.class.line2hash(output.chomp)
+
+    # Now add in the configuration information
+    config_status.each do |name, value|
+      main[name] = value
+    end
+
+    main
+  end
+
+  def ready
+    zoneadm :ready
+  end
+
+  def stop
+    zoneadm :halt
+  end
+
+  def unconfigure
+    zonecfg :delete, "-F"
+  end
+
+  def uninstall
+    zoneadm :uninstall, "-F"
+  end
+
+  private
+
+  # Turn the results of getconfig into status information.
+  def config_status
+    config = getconfig
+    result = {}
+
+    result[:autoboot] = config[:autoboot] ? config[:autoboot].intern : :absent
+    result[:pool] = config[:pool]
+    result[:shares] = config[:shares]
+    if dir = config["inherit-pkg-dir"]
+      result[:inherit] = dir.collect { |dirs| dirs[:dir] }
+    end
+    if datasets = config["dataset"]
+      result[:dataset] = datasets.collect { |dataset| dataset[:name] }
+    end
+    result[:iptype] = config[:"ip-type"]
+    if net = config["net"]
+      result[:ip] = net.collect do |params|
+        if params[:defrouter]
+          "#{params[:physical]}:#{params[:address]}:#{params[:defrouter]}"
+        elsif params[:address]
+          "#{params[:physical]}:#{params[:address]}"
+        else
+          params[:physical]
+        end
+      end
+    end
+
+    result
+  end
+
+  def zoneadm(*cmd)
+      adm("-z", @resource[:name], *cmd)
+  rescue Puppet::ExecutionFailure => detail
+      self.fail "Could not #{cmd[0]} zone: #{detail}"
+  end
+
+  def zonecfg(*cmd)
+    # You apparently can't get the configuration of the global zone
+    return "" if self.name == "global"
+
+    begin
+      cfg("-z", self.name, *cmd)
+    rescue Puppet::ExecutionFailure => detail
+      self.fail "Could not #{cmd[0]} zone: #{detail}"
+    end
+  end
+end
+

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

@@ -0,0 +1,116 @@
+Puppet::Type.type(:zpool).provide(:solaris) do
+  desc "Provider for Solaris zpool."
+
+  commands :zpool => "/usr/sbin/zpool"
+  defaultfor :operatingsystem => :solaris
+
+  def process_zpool_data(pool_array)
+    if pool_array == []
+      return Hash.new(:absent)
+    end
+    #get the name and get rid of it
+    pool = Hash.new
+    pool[:pool] = pool_array[0]
+    pool_array.shift
+
+    tmp = []
+
+    #order matters here :(
+    pool_array.reverse.each do |value|
+      sym = nil
+      case value
+      when "spares";
+        sym = :spare
+      when "logs";
+        sym = :log
+      when /^mirror|^raidz1|^raidz2/;
+        sym = value =~ /^mirror/ ? :mirror : :raidz
+        pool[:raid_parity] = "raidz2" if value =~ /^raidz2/
+      else
+        tmp << value
+        sym = :disk if value == pool_array.first
+      end
+
+      if sym
+        pool[sym] = pool[sym] ? pool[sym].unshift(tmp.reverse.join(' ')) : [tmp.reverse.join(' ')]
+        tmp.clear
+      end
+    end
+
+    pool
+  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] }
+    zpool_data.shift
+    zpool_data
+  end
+
+  def current_pool
+    @current_pool = process_zpool_data(get_pool_data) unless (defined?(@current_pool) and @current_pool)
+    @current_pool
+  end
+
+  def flush
+    @current_pool= nil
+  end
+
+  #Adds log and spare
+  def build_named(name)
+    if prop = @resource[name.intern]
+      [name] + prop.collect { |p| p.split(' ') }.flatten
+    else
+      []
+    end
+  end
+
+  #query for parity and set the right string
+  def raidzarity
+    @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)
+    elsif raidz = @resource[:raidz]
+      handle_multi_arrays(raidzarity, raidz)
+    end
+  end
+
+  def create
+    zpool(*([:create, @resource[:pool]] + build_vdevs + build_named("spare") + build_named("log")))
+  end
+
+  def delete
+    zpool :destroy, @resource[:pool]
+  end
+
+  def exists?
+    if current_pool[:pool] == :absent
+      false
+    else
+      true
+    end
+  end
+
+  [:disk, :mirror, :raidz, :log, :spare].each do |field|
+    define_method(field) do
+      current_pool[field]
+    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]}'"
+    end
+  end
+
+end
+

data/lib/vendor/puppet/provider.rb

@@ -0,0 +1,290 @@
+# The container class for implementations.
+class Puppet::Provider
+  include Puppet::Util
+  include Puppet::Util::Errors
+  include Puppet::Util::Warnings
+  extend Puppet::Util::Warnings
+
+  require 'puppet/provider/confiner'
+
+  extend Puppet::Provider::Confiner
+
+  Puppet::Util.logmethods(self, true)
+
+  class << self
+    # Include the util module so we have access to things like 'which'
+    include Puppet::Util, Puppet::Util::Docs
+    include Puppet::Util::Logging
+    attr_accessor :name
+
+    # The source parameter exists so that providers using the same
+    # source can specify this, so reading doesn't attempt to read the
+    # same package multiple times.
+    attr_writer :source
+
+    # LAK 2007-05-09: Keep the model stuff around for backward compatibility
+    attr_reader :model
+    attr_accessor :resource_type
+    attr_writer :doc
+  end
+
+  # LAK 2007-05-09: Keep the model stuff around for backward compatibility
+  attr_reader :model
+  attr_accessor :resource
+
+  def self.command(name)
+    name = name.intern
+
+    if defined?(@commands) and command = @commands[name]
+      # nothing
+    elsif superclass.respond_to? :command and command = superclass.command(name)
+      # nothing
+    else
+      raise Puppet::DevError, "No command #{name} defined for provider #{self.name}"
+    end
+
+    which(command)
+  end
+
+  # Define commands that are not optional.
+  def self.commands(hash)
+    optional_commands(hash) do |name, path|
+      confine :exists => path, :for_binary => true
+    end
+  end
+
+  # Is the provided feature a declared feature?
+  def self.declared_feature?(name)
+    defined?(@declared_features) and @declared_features.include?(name)
+  end
+
+  # Does this implementation match all of the default requirements?  If
+  # defaults are empty, we return false.
+  def self.default?
+    return false if @defaults.empty?
+    if @defaults.find do |fact, values|
+        values = [values] unless values.is_a? Array
+        if fval = Facter.value(fact).to_s and fval != ""
+          fval = fval.to_s.downcase.intern
+        else
+          return false
+        end
+
+        # If any of the values match, we're a default.
+        if values.find do |value| fval == value.to_s.downcase.intern end
+          false
+        else
+          true
+        end
+      end
+      return false
+    else
+      return true
+    end
+  end
+
+  # Store how to determine defaults.
+  def self.defaultfor(hash)
+    hash.each do |d,v|
+      @defaults[d] = v
+    end
+  end
+
+  def self.specificity
+    (@defaults.length * 100) + ancestors.select { |a| a.is_a? Class }.length
+  end
+
+  def self.initvars
+    @defaults = {}
+    @commands = {}
+  end
+
+  # The method for returning a list of provider instances.  Note that it returns providers, preferably with values already
+  # filled in, not resources.
+  def self.instances
+    raise Puppet::DevError, "Provider #{self.name} has not defined the 'instances' class method"
+  end
+
+  # Create the methods for a given command.
+  def self.make_command_methods(name)
+    # Now define a method for that command
+    unless singleton_class.method_defined?(name)
+      meta_def(name) do |*args|
+        raise Puppet::Error, "Command #{name} is missing" unless command(name)
+        if args.empty?
+          cmd = [command(name)]
+        else
+          cmd = [command(name)] + args
+        end
+        # This might throw an ExecutionFailure, but the system above
+        # will catch it, if so.
+        return execute(cmd)
+      end
+
+      # And then define an instance method that just calls the class method.
+      # We need both, so both instances and classes can easily run the commands.
+      unless method_defined?(name)
+        define_method(name) do |*args|
+          self.class.send(name, *args)
+        end
+      end
+    end
+  end
+
+  # Create getter/setter methods for each property our resource type supports.
+  # They all get stored in @property_hash.  This method is useful
+  # for those providers that use prefetch and flush.
+  def self.mkmodelmethods
+    warnonce "Provider.mkmodelmethods is deprecated; use Provider.mk_resource_methods"
+    mk_resource_methods
+  end
+
+  # Create getter/setter methods for each property our resource type supports.
+  # They all get stored in @property_hash.  This method is useful
+  # for those providers that use prefetch and flush.
+  def self.mk_resource_methods
+    [resource_type.validproperties, resource_type.parameters].flatten.each do |attr|
+      attr = attr.intern
+      next if attr == :name
+      define_method(attr) do
+        @property_hash[attr] || :absent
+      end
+
+      define_method(attr.to_s + "=") do |val|
+        @property_hash[attr] = val
+      end
+    end
+  end
+
+  self.initvars
+
+  # Define one or more binaries we'll be using.  If a block is passed, yield the name
+  # and path to the block (really only used by 'commands').
+  def self.optional_commands(hash)
+    hash.each do |name, path|
+      name = name.intern
+      @commands[name] = path
+
+      yield(name, path) if block_given?
+
+      # Now define the class and instance methods.
+      make_command_methods(name)
+    end
+  end
+
+  # Retrieve the data source.  Defaults to the provider name.
+  def self.source
+    @source ||= self.name
+  end
+
+  # Does this provider support the specified parameter?
+  def self.supports_parameter?(param)
+    if param.is_a?(Class)
+      klass = param
+    else
+      unless klass = resource_type.attrclass(param)
+        raise Puppet::DevError, "'#{param}' is not a valid parameter for #{resource_type.name}"
+      end
+    end
+    return true unless features = klass.required_features
+
+    !!satisfies?(*features)
+  end
+
+#    def self.to_s
+#        unless defined?(@str)
+#            if self.resource_type
+#                @str = "#{resource_type.name} provider #{self.name}"
+#            else
+#                @str = "unattached provider #{self.name}"
+#            end
+#        end
+#        @str
+#    end
+
+  dochook(:defaults) do
+    if @defaults.length > 0
+      return "Default for " + @defaults.collect do |f, v|
+        "`#{f}` == `#{[v].flatten.join(', ')}`"
+      end.join(" and ") + "."
+    end
+  end
+
+  dochook(:commands) do
+    if @commands.length > 0
+      return "Required binaries: " + @commands.collect do |n, c|
+        "`#{c}`"
+      end.join(", ") + "."
+    end
+  end
+
+  dochook(:features) do
+    if features.length > 0
+      return "Supported features: " + features.collect do |f|
+        "`#{f}`"
+      end.join(", ") + "."
+    end
+  end
+
+  # Remove the reference to the resource, so GC can clean up.
+  def clear
+    @resource = nil
+    @model = nil
+  end
+
+  # Retrieve a named command.
+  def command(name)
+    self.class.command(name)
+  end
+
+  # Get a parameter value.
+  def get(param)
+    @property_hash[param.intern] || :absent
+  end
+
+  def initialize(resource = nil)
+    if resource.is_a?(Hash)
+      # We don't use a duplicate here, because some providers (ParsedFile, at least)
+      # use the hash here for later events.
+      @property_hash = resource
+    elsif resource
+      @resource = resource
+      # LAK 2007-05-09: Keep the model stuff around for backward compatibility
+      @model = resource
+      @property_hash = {}
+    else
+      @property_hash = {}
+    end
+  end
+
+  def name
+    if n = @property_hash[:name]
+      return n
+    elsif self.resource
+      resource.name
+    else
+      raise Puppet::DevError, "No resource and no name in property hash in #{self.class.name} instance"
+    end
+  end
+
+  # Set passed params as the current values.
+  def set(params)
+    params.each do |param, value|
+      @property_hash[param.intern] = value
+    end
+  end
+
+  def to_s
+    "#{@resource}(provider=#{self.class.name})"
+  end
+
+  # Make providers comparable.
+  include Comparable
+  def <=>(other)
+    # We can only have ordering against other providers.
+    return nil unless other.is_a? Puppet::Provider
+    # Otherwise, order by the providers class name.
+    return self.class.name <=> other.class.name
+  end
+end
+