puppet-retrospec 0.12.2 → 1.0.0

data/vendor/gems/puppet-3.7.3/lib/puppet/provider/aixobject.rb

@@ -1,392 +0,0 @@
-#
-# Common code for AIX providers. This class implements basic structure for
-# AIX resources.
-# Author::    Hector Rivas Gandara <keymon@gmail.com>
-#
-class Puppet::Provider::AixObject < Puppet::Provider
-  desc "Generic AIX resource provider"
-
-  # The real provider must implement these functions.
-  def lscmd( _value = @resource[:name] )
-    raise Puppet::Error, "Method not defined #{@resource.class.name} #{@resource.name}: Base AixObject provider doesn't implement lscmd"
-  end
-
-  def addcmd( _extra_attrs = [] )
-    raise Puppet::Error, "Method not defined #{@resource.class.name} #{@resource.name}: Base AixObject provider doesn't implement addcmd"
-  end
-
-  def modifycmd( _attributes_hash = {} )
-    raise Puppet::Error, "Method not defined #{@resource.class.name} #{@resource.name}: Base AixObject provider doesn't implement modifycmd"
-  end
-
-  def deletecmd
-    raise Puppet::Error, "Method not defined #{@resource.class.name} #{@resource.name}: Base AixObject provider doesn't implement deletecmd"
-  end
-
-  # Valid attributes to be managed by this provider.
-  # It is a list of hashes
-  #  :aix_attr      AIX command attribute name
-  #  :puppet_prop   Puppet propertie name
-  #  :to            Optional. Method name that adapts puppet property to aix command value.
-  #  :from          Optional. Method to adapt aix command line value to puppet property. Optional
-  class << self
-    attr_accessor :attribute_mapping
-  end
-
-  # Mapping from Puppet property to AIX attribute.
-  def self.attribute_mapping_to
-    if ! @attribute_mapping_to
-      @attribute_mapping_to = {}
-      attribute_mapping.each { |elem|
-        attribute_mapping_to[elem[:puppet_prop]] = {
-          :key => elem[:aix_attr],
-          :method => elem[:to]
-        }
-      }
-    end
-    @attribute_mapping_to
-  end
-
-  # Mapping from AIX attribute to Puppet property.
-  def self.attribute_mapping_from
-    if ! @attribute_mapping_from
-      @attribute_mapping_from = {}
-      attribute_mapping.each { |elem|
-        attribute_mapping_from[elem[:aix_attr]] = {
-          :key => elem[:puppet_prop],
-          :method => elem[:from]
-        }
-      }
-    end
-    @attribute_mapping_from
-  end
-
-  # This functions translates a key and value using the given mapping.
-  # Mapping can be nil (no translation) or a hash with this format
-  # {:key => new_key, :method => translate_method}
-  # It returns a list with the pair [key, value]
-  def translate_attr(key, value, mapping)
-    return [key, value] unless mapping
-    return nil unless mapping[key]
-
-    if mapping[key][:method]
-      new_value = method(mapping[key][:method]).call(value)
-    else
-      new_value = value
-    end
-    [mapping[key][:key], new_value]
-  end
-
-  # Loads an AIX attribute (key=value) and stores it in the given hash with
-  # puppet semantics. It translates the pair using the given mapping.
-  #
-  # This operation works with each property one by one,
-  # subclasses must reimplement this if more complex operations are needed
-  def load_attribute(key, value, mapping, objectinfo)
-    if mapping.nil?
-      objectinfo[key] = value
-    elsif mapping[key].nil?
-      # is not present in mapping, ignore it.
-      true
-    elsif mapping[key][:method].nil?
-      objectinfo[mapping[key][:key]] = value
-    elsif
-      objectinfo[mapping[key][:key]] = method(mapping[key][:method]).call(value)
-    end
-
-    return objectinfo
-  end
-
-  # Gets the given command line argument for the given key and value,
-  # using the given mapping to translate key and value.
-  # All the objectinfo hash (@resource or @property_hash) is passed.
-  #
-  # This operation works with each property one by one,
-  # and default behaviour is return the arguments as key=value pairs.
-  # Subclasses must reimplement this if more complex operations/arguments
-  # are needed
-  #
-  def get_arguments(key, value, mapping, objectinfo)
-    if mapping.nil?
-      new_key = key
-      new_value = value
-    elsif mapping[key].nil?
-      # is not present in mapping, ignore it.
-      new_key = nil
-      new_value = nil
-    elsif mapping[key][:method].nil?
-      new_key = mapping[key][:key]
-      new_value = value
-    elsif
-      new_key = mapping[key][:key]
-      new_value = method(mapping[key][:method]).call(value)
-    end
-
-    # convert it to string
-    new_value = Array(new_value).join(',')
-
-    if new_key
-      return [ "#{new_key}=#{new_value}" ]
-    else
-      return []
-    end
-  end
-
-  # Convert the provider properties (hash) to AIX command arguments
-  # (list of strings)
-  # This function will translate each value/key and generate the argument using
-  # the get_arguments function.
-  def hash2args(hash, mapping=self.class.attribute_mapping_to)
-    return "" unless hash
-    arg_list = []
-    hash.each {|key, val|
-      arg_list += self.get_arguments(key, val, mapping, hash)
-    }
-    arg_list
-  end
-
-  # Parse AIX command attributes from the output of an AIX command, that
-  # which format is a list of space separated of key=value pairs:
-  # "uid=100 groups=a,b,c".
-  # It returns a hash.
-  #
-  # If a mapping is provided, the keys are translated as defined in the
-  # mapping hash. And only values included in mapping will be added
-  #
-  # NOTE: it will ignore the items not including '='
-  def parse_attr_list(str, mapping=self.class.attribute_mapping_from)
-    properties = {}
-    attrs = []
-    if str.nil? or (attrs = str.split()).empty?
-      return nil
-    end
-
-    attrs.each { |i|
-      if i.include? "=" # Ignore if it does not include '='
-        (key_str, val) = i.split('=')
-        # Check the key
-        if key_str.nil? or key_str.empty?
-          info "Empty key in string 'i'?"
-          continue
-        end
-        key_str.strip!
-        key = key_str.to_sym
-        val.strip! if val
-
-        properties = self.load_attribute(key, val, mapping, properties)
-      end
-    }
-    properties.empty? ? nil : properties
-  end
-
-  # Parse AIX command output in a colon separated list of attributes,
-  # This function is useful to parse the output of commands like lsfs -c:
-  #   #MountPoint:Device:Vfs:Nodename:Type:Size:Options:AutoMount:Acct
-  #   /:/dev/hd4:jfs2::bootfs:557056:rw:yes:no
-  #   /home:/dev/hd1:jfs2:::2129920:rw:yes:no
-  #   /usr:/dev/hd2:jfs2::bootfs:9797632:rw:yes:no
-  #
-  # If a mapping is provided, the keys are translated as defined in the
-  # mapping hash. And only values included in mapping will be added
-  def parse_colon_list(str, key_list, mapping=self.class.attribute_mapping_from)
-    properties = {}
-    attrs = []
-    if str.nil? or (attrs = str.split(':')).empty?
-      return nil
-    end
-
-    attrs.each { |val|
-      key = key_list.shift.downcase.to_sym
-      properties = self.load_attribute(key, val, mapping, properties)
-    }
-    properties.empty? ? nil : properties
-  end
-
-  # Default parsing function for AIX commands.
-  # It will choose the method depending of the first line.
-  # For the colon separated list it will:
-  #  1. Get keys from first line.
-  #  2. Parse next line.
-  def parse_command_output(output, mapping=self.class.attribute_mapping_from)
-    lines = output.split("\n")
-    # if it begins with #something:... is a colon separated list.
-    if lines[0] =~ /^#.*:/
-      self.parse_colon_list(lines[1], lines[0][1..-1].split(':'), mapping)
-    else
-      self.parse_attr_list(lines[0], mapping)
-    end
-  end
-
-  # Retrieve all the information of an existing resource.
-  # It will execute 'lscmd' command and parse the output, using the mapping
-  # 'attribute_mapping_from' to translate the keys and values.
-  def getinfo(refresh = false)
-    if @objectinfo.nil? or refresh == true
-      # Execute lsuser, split all attributes and add them to a dict.
-      begin
-        output = execute(self.lscmd)
-        @objectinfo = self.parse_command_output(output)
-        # All attributtes without translation
-        @objectosinfo = self.parse_command_output(output, nil)
-      rescue Puppet::ExecutionFailure => detail
-        # Print error if needed. FIXME: Do not check the user here.
-        Puppet.debug "aix.getinfo(): Could not find #{@resource.class.name} #{@resource.name}: #{detail}"
-      end
-    end
-    @objectinfo
-  end
-
-  # Like getinfo, but it will not use the mapping to translate the keys and values.
-  # It might be usefult to retrieve some raw information.
-  def getosinfo(refresh = false)
-    if @objectosinfo.nil? or refresh == true
-      getinfo(refresh)
-    end
-    @objectosinfo || Hash.new
-  end
-
-
-  # List all elements of given type. It works for colon separated commands and
-  # list commands.
-  # It returns a list of names.
-  def self.list_all
-    names = []
-    begin
-      output = execute([self.command(:list), 'ALL'])
-
-      output = output.split("\n").select{ |line| line != /^#/ }
-
-      output.each do |line|
-        name = line.split(/[ :]/)[0]
-        names << name if not name.empty?
-      end
-    rescue Puppet::ExecutionFailure => detail
-      # Print error if needed
-      Puppet.debug "aix.list_all(): Could not get all resources of type #{@resource.class.name}: #{detail}"
-    end
-    names
-  end
-
-
-  #-------------
-  # Provider API
-  # ------------
-
-  # Clear out the cached values.
-  def flush
-    @property_hash.clear if @property_hash
-    @objectinfo.clear if @objectinfo
-  end
-
-  # Check that the user exists
-  def exists?
-    !!getinfo(true) # !! => converts to bool
-  end
-
-  # Return all existing instances
-  # 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
-    objects=[]
-    list_all.each { |entry|
-      objects << new(:name => entry, :ensure => :present)
-    }
-    objects
-  end
-
-  #- **ensure**
-  #    The basic state that the object should be in.  Valid values are
-  #    `present`, `absent`, `role`.
-  # From ensurable: exists?, create, delete
-  def ensure
-    if exists?
-      :present
-    else
-      :absent
-    end
-  end
-
-  # Create a new instance of the resource
-  def create
-    if exists?
-      info "already exists"
-      # The object already exists
-      return nil
-    end
-
-    begin
-      execute(self.addcmd)
-    rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error, "Could not create #{@resource.class.name} #{@resource.name}: #{detail}", detail.backtrace
-    end
-  end
-
-  # Delete this instance of the resource
-  def delete
-    unless exists?
-      info "already absent"
-      # the object already doesn't exist
-      return nil
-    end
-
-    begin
-      execute(self.deletecmd)
-    rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error, "Could not delete #{@resource.class.name} #{@resource.name}: #{detail}", detail.backtrace
-    end
-  end
-
-  #--------------------------------
-  # Call this method when the object is initialized.
-  # It creates getter/setter methods for each property our resource type supports.
-  # If setter or getter already defined it will not be overwritten
-  def self.mk_resource_methods
-    [resource_type.validproperties, resource_type.parameters].flatten.each do |prop|
-      next if prop == :ensure
-      define_method(prop) { get(prop) || :absent} unless public_method_defined?(prop)
-      define_method(prop.to_s + "=") { |*vals| set(prop, *vals) } unless public_method_defined?(prop.to_s + "=")
-    end
-  end
-
-  # Define the needed getters and setters as soon as we know the resource type
-  def self.resource_type=(resource_type)
-    super
-    mk_resource_methods
-  end
-
-  # Retrieve a specific value by name.
-  def get(param)
-    (hash = getinfo(false)) ? hash[param] : nil
-  end
-
-  # Set a property.
-  def set(param, value)
-    @property_hash[param.intern] = value
-
-    if getinfo().nil?
-      # This is weird...
-      raise Puppet::Error, "Trying to update parameter '#{param}' to '#{value}' for a resource that does not exists #{@resource.class.name} #{@resource.name}: #{detail}"
-    end
-    if value == getinfo()[param.to_sym]
-      return
-    end
-
-    #self.class.validate(param, value)
-    if cmd = modifycmd({param =>value})
-      begin
-        execute(cmd)
-      rescue Puppet::ExecutionFailure  => detail
-        raise Puppet::Error, "Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}", detail.backtrace
-      end
-    end
-
-    # Refresh de info.
-    getinfo(true)
-  end
-
-  def initialize(resource)
-    super
-    @objectinfo = nil
-    @objectosinfo = nil
-  end
-end

data/vendor/gems/puppet-3.7.3/lib/puppet/provider/augeas/augeas.rb

@@ -1,509 +0,0 @@
-#
-#   Copyright 2011 Bryan Kearney <bkearney@redhat.com>
-#
-#   Licensed under the Apache License, Version 2.0 (the "License");
-#   you may not use this file except in compliance with the License.
-#   You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS,
-#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#   See the License for the specific language governing permissions and
-#   limitations under the License.
-
-require 'augeas' if Puppet.features.augeas?
-require 'strscan'
-require 'puppet/util'
-require 'puppet/util/diff'
-require 'puppet/util/package'
-
-Puppet::Type.type(:augeas).provide(:augeas) do
-  include Puppet::Util
-  include Puppet::Util::Diff
-  include Puppet::Util::Package
-
-  confine :feature => :augeas
-
-  has_features :parse_commands, :need_to_run?,:execute_changes
-
-  SAVE_NOOP = "noop"
-  SAVE_OVERWRITE = "overwrite"
-  SAVE_NEWFILE = "newfile"
-  SAVE_BACKUP = "backup"
-
-  COMMANDS = {
-    "set" => [ :path, :string ],
-    "setm" => [ :path, :string, :string ],
-    "rm" => [ :path ],
-    "clear" => [ :path ],
-    "clearm" => [ :path, :string ],
-    "mv" => [ :path, :path ],
-    "insert" => [ :string, :string, :path ],
-    "get" => [ :path, :comparator, :string ],
-    "defvar" => [ :string, :path ],
-    "defnode" => [ :string, :path, :string ],
-    "match" => [ :path, :glob ],
-    "size" => [:comparator, :int],
-    "include" => [:string],
-    "not_include" => [:string],
-    "==" => [:glob],
-    "!=" => [:glob]
-  }
-
-  COMMANDS["ins"] = COMMANDS["insert"]
-  COMMANDS["remove"] = COMMANDS["rm"]
-  COMMANDS["move"] = COMMANDS["mv"]
-
-  attr_accessor :aug
-
-  # Extracts an 2 dimensional array of commands which are in the
-  # form of command path value.
-  # The input can be
-  # - A string with one command
-  # - A string with many commands per line
-  # - An array of strings.
-  def parse_commands(data)
-    context = resource[:context]
-    # Add a trailing / if it is not there
-    if (context.length > 0)
-      context << "/" if context[-1, 1] != "/"
-    end
-
-    data = data.split($/) if data.is_a?(String)
-    data = data.flatten
-    args = []
-    data.each do |line|
-      line.strip!
-      next if line.nil? || line.empty?
-      argline = []
-      sc = StringScanner.new(line)
-      cmd = sc.scan(/\w+|==|!=/)
-      formals = COMMANDS[cmd]
-      fail("Unknown command #{cmd}") unless formals
-      argline << cmd
-      narg = 0
-      formals.each do |f|
-        sc.skip(/\s+/)
-        narg += 1
-        if f == :path
-          start = sc.pos
-          nbracket = 0
-          inSingleTick = false
-          inDoubleTick = false
-          begin
-            sc.skip(/([^\]\[\s\\'"]|\\.)+/)
-            ch = sc.getch
-            nbracket += 1 if ch == "["
-            nbracket -= 1 if ch == "]"
-            inSingleTick = !inSingleTick if ch == "'"
-            inDoubleTick = !inDoubleTick if ch == "\""
-            fail("unmatched [") if nbracket < 0
-          end until ((nbracket == 0 && !inSingleTick && !inDoubleTick && (ch =~ /\s/)) || sc.eos?)
-            len = sc.pos - start
-            len -= 1 unless sc.eos?
-          unless p = sc.string[start, len]
-            fail("missing path argument #{narg} for #{cmd}")
-          end
-          # Rip off any ticks if they are there.
-          p = p[1, (p.size - 2)] if p[0,1] == "'" || p[0,1] == "\""
-          p.chomp!("/")
-          if p[0,1] != '$' && p[0,1] != "/"
-            argline << context + p
-          else
-            argline << p
-          end
-        elsif f == :string
-          delim = sc.peek(1)
-          if delim == "'" || delim == "\""
-            sc.getch
-            argline << sc.scan(/([^\\#{delim}]|(\\.))*/)
-            sc.getch
-          else
-            argline << sc.scan(/[^\s]+/)
-          end
-          fail("missing string argument #{narg} for #{cmd}") unless argline[-1]
-        elsif f == :comparator
-          argline << sc.scan(/(==|!=|=~|<=|>=|<|>)/)
-          unless argline[-1]
-            puts sc.rest
-            fail("invalid comparator for command #{cmd}")
-          end
-        elsif f == :int
-          argline << sc.scan(/\d+/).to_i
-        elsif f== :glob
-          argline << sc.rest
-        end
-      end
-      args << argline
-    end
-    args
-  end
-
-
-  def open_augeas
-    unless @aug
-      flags = Augeas::NONE
-      flags = Augeas::TYPE_CHECK if resource[:type_check] == :true
-
-      if resource[:incl]
-        flags |= Augeas::NO_MODL_AUTOLOAD
-      else
-        flags |= Augeas::NO_LOAD
-      end
-
-      root = resource[:root]
-      load_path = get_load_path(resource)
-      debug("Opening augeas with root #{root}, lens path #{load_path}, flags #{flags}")
-      @aug = Augeas::open(root, load_path,flags)
-
-      debug("Augeas version #{get_augeas_version} is installed") if versioncmp(get_augeas_version, "0.3.6") >= 0
-
-      # Optimize loading if the context is given and it's a simple path,
-      # requires the glob function from Augeas 0.8.2 or up
-      glob_avail = !aug.match("/augeas/version/pathx/functions/glob").empty?
-      opt_ctx = resource[:context].match("^/files/[^'\"\\[\\]]+$") if resource[:context]
-
-      restricted = false
-      if resource[:incl]
-        aug.set("/augeas/load/Xfm/lens", resource[:lens])
-        aug.set("/augeas/load/Xfm/incl", resource[:incl])
-        restricted_metadata = "/augeas//error"
-      elsif glob_avail and opt_ctx
-        # Optimize loading if the context is given, requires the glob function
-        # from Augeas 0.8.2 or up
-        ctx_path = resource[:context].sub(/^\/files(.*?)\/?$/, '\1/')
-        load_path = "/augeas/load/*['%s' !~ glob(incl) + regexp('/.*')]" % ctx_path
-
-        if aug.match(load_path).size < aug.match("/augeas/load/*").size
-          aug.rm(load_path)
-          restricted_metadata = "/augeas/files#{ctx_path}/error"
-        else
-          # This will occur if the context is less specific than any glob
-          debug("Unable to optimize files loaded by context path, no glob matches")
-        end
-      end
-      aug.load
-      print_load_errors(restricted_metadata)
-    end
-    @aug
-  end
-
-  def close_augeas
-    if @aug
-      @aug.close
-      debug("Closed the augeas connection")
-      @aug = nil
-    end
-  end
-
-  def is_numeric?(s)
-    case s
-    when Fixnum
-      true
-    when String
-      s.match(/\A[+-]?\d+?(\.\d+)?\Z/n) == nil ? false : true
-    else
-      false
-    end
-  end
-
-  # Used by the need_to_run? method to process get filters. Returns
-  # true if there is a match, false if otherwise
-  # Assumes a syntax of get /files/path [COMPARATOR] value
-  def process_get(cmd_array)
-    return_value = false
-
-    #validate and tear apart the command
-    fail ("Invalid command: #{cmd_array.join(" ")}") if cmd_array.length < 4
-    cmd = cmd_array.shift
-    path = cmd_array.shift
-    comparator = cmd_array.shift
-    arg = cmd_array.join(" ")
-
-    #check the value in augeas
-    result = @aug.get(path) || ''
-
-    if ['<', '<=', '>=', '>'].include? comparator and is_numeric?(result) and
-                                                      is_numeric?(arg)
-      resultf = result.to_f
-      argf = arg.to_f
-      return_value = (resultf.send(comparator, argf))
-    elsif comparator == "!="
-      return_value = (result != arg)
-    elsif comparator == "=~"
-      regex = Regexp.new(arg)
-      return_value = (result =~ regex)
-    else
-      return_value = (result.send(comparator, arg))
-    end
-    !!return_value
-  end
-
-  # Used by the need_to_run? method to process match filters. Returns
-  # true if there is a match, false if otherwise
-  def process_match(cmd_array)
-    return_value = false
-
-    #validate and tear apart the command
-    fail("Invalid command: #{cmd_array.join(" ")}") if cmd_array.length < 3
-    cmd = cmd_array.shift
-    path = cmd_array.shift
-
-    # Need to break apart the clause
-    clause_array = parse_commands(cmd_array.shift)[0]
-    verb = clause_array.shift
-
-    #Get the values from augeas
-    result = @aug.match(path) || []
-    fail("Error trying to match path '#{path}'") if (result == -1)
-
-    # Now do the work
-    case verb
-    when "size"
-      fail("Invalid command: #{cmd_array.join(" ")}") if clause_array.length != 2
-      comparator = clause_array.shift
-      arg = clause_array.shift
-      case comparator
-      when "!="
-        return_value = !(result.size.send(:==, arg))
-      else
-        return_value = (result.size.send(comparator, arg))
-      end
-    when "include"
-      arg = clause_array.shift
-      return_value = result.include?(arg)
-    when "not_include"
-      arg = clause_array.shift
-      return_value = !result.include?(arg)
-    when "=="
-      begin
-        arg = clause_array.shift
-        new_array = eval arg
-        return_value = (result == new_array)
-      rescue
-        fail("Invalid array in command: #{cmd_array.join(" ")}")
-      end
-    when "!="
-      begin
-        arg = clause_array.shift
-        new_array = eval arg
-        return_value = (result != new_array)
-      rescue
-        fail("Invalid array in command: #{cmd_array.join(" ")}")
-      end
-    end
-    !!return_value
-  end
-
-  # Generate lens load paths from user given paths and local pluginsync dir
-  def get_load_path(resource)
-    load_path = []
-
-    # Permits colon separated strings or arrays
-    if resource[:load_path]
-      load_path = [resource[:load_path]].flatten
-      load_path.map! { |path| path.split(/:/) }
-      load_path.flatten!
-    end
-
-    if Puppet::FileSystem.exist?("#{Puppet[:libdir]}/augeas/lenses")
-      load_path << "#{Puppet[:libdir]}/augeas/lenses"
-    end
-
-    load_path.join(":")
-  end
-
-  def get_augeas_version
-    @aug.get("/augeas/version") || ""
-  end
-
-  def set_augeas_save_mode(mode)
-    @aug.set("/augeas/save", mode)
-  end
-
-  def print_load_errors(path)
-    errors = @aug.match("/augeas//error")
-    unless errors.empty?
-      if path && !@aug.match(path).empty?
-        warning("Loading failed for one or more files, see debug for /augeas//error output")
-      else
-        debug("Loading failed for one or more files, output from /augeas//error:")
-      end
-    end
-    print_errors(errors)
-  end
-
-  def print_put_errors
-    errors = @aug.match("/augeas//error[. = 'put_failed']")
-    debug("Put failed on one or more files, output from /augeas//error:") unless errors.empty?
-    print_errors(errors)
-  end
-
-  def print_errors(errors)
-    errors.each do |errnode|
-      error = @aug.get(errnode)
-      debug("#{errnode} = #{error}") unless error.nil?
-      @aug.match("#{errnode}/*").each do |subnode|
-        subvalue = @aug.get(subnode)
-        debug("#{subnode} = #{subvalue}")
-      end
-    end
-  end
-
-  # Determines if augeas actually needs to run.
-  def need_to_run?
-    force = resource[:force]
-    return_value = true
-    begin
-      open_augeas
-      filter = resource[:onlyif]
-      unless filter == ""
-        cmd_array = parse_commands(filter)[0]
-        command = cmd_array[0];
-        begin
-          case command
-          when "get"; return_value = process_get(cmd_array)
-          when "match"; return_value = process_match(cmd_array)
-          end
-        rescue SystemExit,NoMemoryError
-          raise
-        rescue Exception => e
-          fail("Error sending command '#{command}' with params #{cmd_array[1..-1].inspect}/#{e.message}")
-        end
-      end
-
-      unless force
-        # If we have a verison of augeas which is at least 0.3.6 then we
-        # can make the changes now and see if changes were made.
-        if return_value and versioncmp(get_augeas_version, "0.3.6") >= 0
-          debug("Will attempt to save and only run if files changed")
-          # Execute in NEWFILE mode so we can show a diff
-          set_augeas_save_mode(SAVE_NEWFILE)
-          do_execute_changes
-          save_result = @aug.save
-          unless save_result
-            print_put_errors
-            fail("Saving failed, see debug")
-          end
-
-          saved_files = @aug.match("/augeas/events/saved")
-          if saved_files.size > 0
-            root = resource[:root].sub(/^\/$/, "")
-            saved_files.map! {|key| @aug.get(key).sub(/^\/files/, root) }
-            saved_files.uniq.each do |saved_file|
-              if Puppet[:show_diff] && @resource[:show_diff]
-                self.send(@resource[:loglevel], "\n" + diff(saved_file, saved_file + ".augnew"))
-              end
-              File.delete(saved_file + ".augnew")
-            end
-            debug("Files changed, should execute")
-            return_value = true
-          else
-            debug("Skipping because no files were changed")
-            return_value = false
-          end
-        end
-      end
-    ensure
-      if not return_value or resource.noop? or not save_result
-        close_augeas
-      end
-    end
-    return_value
-  end
-
-  def execute_changes
-    # Workaround Augeas bug where changing the save mode doesn't trigger a
-    # reload of the previously saved file(s) when we call Augeas#load
-    @aug.match("/augeas/events/saved").each do |file|
-      @aug.rm("/augeas#{@aug.get(file)}/mtime")
-    end
-
-    # Reload augeas, and execute the changes for real
-    set_augeas_save_mode(SAVE_OVERWRITE) if versioncmp(get_augeas_version, "0.3.6") >= 0
-    @aug.load
-    do_execute_changes
-    unless @aug.save
-      print_put_errors
-      fail("Save failed, see debug")
-    end
-
-    :executed
-  ensure
-    close_augeas
-  end
-
-  # Actually execute the augeas changes.
-  def do_execute_changes
-    commands = parse_commands(resource[:changes])
-    commands.each do |cmd_array|
-      fail("invalid command #{cmd_array.join[" "]}") if cmd_array.length < 2
-      command = cmd_array[0]
-      cmd_array.shift
-      begin
-        case command
-          when "set"
-            debug("sending command '#{command}' with params #{cmd_array.inspect}")
-            rv = aug.set(cmd_array[0], cmd_array[1])
-            fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (!rv)
-          when "setm"
-            if aug.respond_to?(command)
-              debug("sending command '#{command}' with params #{cmd_array.inspect}")
-              rv = aug.setm(cmd_array[0], cmd_array[1], cmd_array[2])
-              fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (rv == -1)
-            else
-              fail("command '#{command}' not supported in installed version of ruby-augeas")
-            end
-          when "rm", "remove"
-            debug("sending command '#{command}' with params #{cmd_array.inspect}")
-            rv = aug.rm(cmd_array[0])
-            fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (rv == -1)
-          when "clear"
-            debug("sending command '#{command}' with params #{cmd_array.inspect}")
-            rv = aug.clear(cmd_array[0])
-            fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (!rv)
-          when "clearm"
-            # Check command exists ... doesn't currently in ruby-augeas 0.4.1
-            if aug.respond_to?(command)
-              debug("sending command '#{command}' with params #{cmd_array.inspect}")
-              rv = aug.clearm(cmd_array[0], cmd_array[1])
-              fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (!rv)
-            else
-              fail("command '#{command}' not supported in installed version of ruby-augeas")
-            end
-          when "insert", "ins"
-            label = cmd_array[0]
-            where = cmd_array[1]
-            path = cmd_array[2]
-            case where
-              when "before"; before = true
-              when "after"; before = false
-              else fail("Invalid value '#{where}' for where param")
-            end
-            debug("sending command '#{command}' with params #{[label, where, path].inspect}")
-            rv = aug.insert(path, label, before)
-            fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (rv == -1)
-          when "defvar"
-            debug("sending command '#{command}' with params #{cmd_array.inspect}")
-            rv = aug.defvar(cmd_array[0], cmd_array[1])
-            fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (!rv)
-          when "defnode"
-            debug("sending command '#{command}' with params #{cmd_array.inspect}")
-            rv = aug.defnode(cmd_array[0], cmd_array[1], cmd_array[2])
-            fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (!rv)
-          when "mv", "move"
-            debug("sending command '#{command}' with params #{cmd_array.inspect}")
-            rv = aug.mv(cmd_array[0], cmd_array[1])
-            fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (rv == -1)
-          else fail("Command '#{command}' is not supported")
-        end
-      rescue SystemExit,NoMemoryError
-        raise
-      rescue Exception => e
-        fail("Error sending command '#{command}' with params #{cmd_array.inspect}/#{e.message}")
-      end
-    end
-  end
-end