puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/provider/augeas/augeas.rb

@@ -0,0 +1,418 @@
+#
+#   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 ],
+    "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
+      flags |= Augeas::NO_MODL_AUTOLOAD if resource[:incl]
+      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
+
+      if resource[:incl]
+        aug.set("/augeas/load/Xfm/lens", resource[:lens])
+        aug.set("/augeas/load/Xfm/incl", resource[:incl])
+        aug.load
+      end
+    end
+    @aug
+  end
+
+  def close_augeas
+    if @aug
+      @aug.close
+      debug("Closed the augeas connection")
+      @aug = nil
+    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) || ''
+    case comparator
+    when "!="
+      return_value = (result != arg)
+    when "=~"
+      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 File.exists?("#{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
+
+  # Determines if augeas acutally 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
+          fail("Save failed with return code #{save_result}") unless save_result
+
+          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]
+                notice "\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
+    success = @aug.save
+    fail("Save failed with return code #{success}") if success != true
+
+    :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"
+            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)
+          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 "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

data/lib/vendor/puppet/provider/cisco.rb

@@ -0,0 +1,9 @@
+require 'puppet/util/network_device/cisco/device'
+require 'puppet/provider/network_device'
+
+# This is the base class of all prefetched cisco device providers
+class Puppet::Provider::Cisco < Puppet::Provider::NetworkDevice
+  def self.device(url)
+    Puppet::Util::NetworkDevice::Cisco::Device.new(url)
+  end
+end

data/lib/vendor/puppet/provider/computer/computer.rb

@@ -0,0 +1,20 @@
+require 'puppet/provider/nameservice/directoryservice'
+
+Puppet::Type.type(:computer).provide :directoryservice, :parent => Puppet::Provider::NameService::DirectoryService do
+  desc "Computer object management using DirectoryService on OS X.
+  Note that these are distinctly different kinds of objects to 'hosts',
+  as they require a MAC address and can have all sorts of policy attached to
+  them.
+
+  This provider only manages Computer objects in the local directory service
+  domain, not in remote directories.
+
+  If you wish to manage /etc/hosts on Mac OS X, then simply use the host
+  type as per other platforms."
+
+  confine :operatingsystem => :darwin
+  defaultfor :operatingsystem => :darwin
+
+  # hurray for abstraction. The nameservice directoryservice provider can
+  # handle everything we need. super.
+end

data/lib/vendor/puppet/provider/confine/exists.rb

@@ -0,0 +1,19 @@
+require 'puppet/provider/confine'
+
+class Puppet::Provider::Confine::Exists < Puppet::Provider::Confine
+  def self.summarize(confines)
+    confines.inject([]) { |total, confine| total + confine.summary }
+  end
+
+  def pass?(value)
+    value && (for_binary? ? which(value) : FileTest.exist?(value))
+  end
+
+  def message(value)
+    "file #{value} does not exist"
+  end
+
+  def summary
+    result.zip(values).inject([]) { |array, args| val, f = args; array << f unless val; array }
+  end
+end

data/lib/vendor/puppet/provider/confine/false.rb

@@ -0,0 +1,19 @@
+require 'puppet/provider/confine'
+
+class Puppet::Provider::Confine::False < Puppet::Provider::Confine
+  def self.summarize(confines)
+    confines.inject(0) { |count, confine| count + confine.summary }
+  end
+
+  def pass?(value)
+    ! value
+  end
+
+  def message(value)
+    "true value when expecting false"
+  end
+
+  def summary
+    result.find_all { |v| v == false }.length
+  end
+end

data/lib/vendor/puppet/provider/confine/feature.rb

@@ -0,0 +1,17 @@
+require 'puppet/provider/confine'
+
+class Puppet::Provider::Confine::Feature < Puppet::Provider::Confine
+  def self.summarize(confines)
+    confines.collect { |c| c.values }.flatten.uniq.find_all { |value| ! confines[0].pass?(value) }
+  end
+
+  # Is the named feature available?
+  def pass?(value)
+    Puppet.features.send(value.to_s + "?")
+  end
+
+  def message(value)
+    "feature #{value} is missing"
+  end
+end
+

data/lib/vendor/puppet/provider/confine/true.rb

@@ -0,0 +1,20 @@
+require 'puppet/provider/confine'
+
+class Puppet::Provider::Confine::True < Puppet::Provider::Confine
+  def self.summarize(confines)
+    confines.inject(0) { |count, confine| count + confine.summary }
+  end
+
+  def pass?(value)
+    # Double negate, so we only get true or false.
+    ! ! value
+  end
+
+  def message(value)
+    "false value when expecting true"
+  end
+
+  def summary
+    result.find_all { |v| v == true }.length
+  end
+end

data/lib/vendor/puppet/provider/confine/variable.rb

@@ -0,0 +1,59 @@
+require 'puppet/provider/confine'
+
+# Require a specific value for a variable, either a Puppet setting
+# or a Facter value.  This class is a bit weird because the name
+# is set explicitly by the ConfineCollection class -- from this class,
+# it's not obvious how the name would ever get set.
+class Puppet::Provider::Confine::Variable < Puppet::Provider::Confine
+  # Provide a hash summary of failing confines -- the key of the hash
+  # is the name of the confine, and the value is the missing yet required values.
+  # Only returns failed values, not all required values.
+  def self.summarize(confines)
+    result = Hash.new { |hash, key| hash[key] = [] }
+    confines.inject(result) { |total, confine| total[confine.name] += confine.values unless confine.valid?; total }
+  end
+
+  # This is set by ConfineCollection.
+  attr_accessor :name
+
+  # Retrieve the value from facter
+  def facter_value
+    @facter_value ||= ::Facter.value(name).to_s.downcase
+  end
+
+  def initialize(values)
+    super
+    @values = @values.collect { |v| v.to_s.downcase }
+  end
+
+  def message(value)
+    "facter value '#{test_value}' for '#{self.name}' not in required list '#{values.join(",")}'"
+  end
+
+  # Compare the passed-in value to the retrieved value.
+  def pass?(value)
+    test_value.downcase.to_s == value.to_s.downcase
+  end
+
+  def reset
+    # Reset the cache.  We want to cache it during a given
+    # run, but not across runs.
+    @facter_value = nil
+  end
+
+  def valid?
+    @values.include?(test_value.to_s.downcase)
+  ensure
+    reset
+  end
+
+  private
+
+  def setting?
+    Puppet.settings.valid?(name)
+  end
+
+  def test_value
+    setting? ? Puppet.settings[name] : facter_value
+  end
+end

data/lib/vendor/puppet/provider/confine.rb

@@ -0,0 +1,80 @@
+# The class that handles testing whether our providers
+# actually work or not.
+require 'puppet/util'
+
+class Puppet::Provider::Confine
+  include Puppet::Util
+
+  @tests = {}
+
+  class << self
+    attr_accessor :name
+  end
+
+  def self.inherited(klass)
+    name = klass.to_s.split("::").pop.downcase.to_sym
+    raise "Test #{name} is already defined" if @tests.include?(name)
+
+    klass.name = name
+
+    @tests[name] = klass
+  end
+
+  def self.test(name)
+    unless @tests[name]
+      begin
+        require "puppet/provider/confine/#{name}"
+      rescue LoadError => detail
+        unless detail.to_s =~ /No such file|cannot load such file/i
+          warn "Could not load confine test '#{name}': #{detail}"
+        end
+        # Could not find file
+      end
+    end
+    @tests[name]
+  end
+
+  attr_reader :values
+
+  # Mark that this confine is used for testing binary existence.
+  attr_accessor :for_binary
+  def for_binary?
+    for_binary
+  end
+
+  # Used for logging.
+  attr_accessor :label
+
+  def initialize(values)
+    values = [values] unless values.is_a?(Array)
+    @values = values
+  end
+
+  # Provide a hook for the message when there's a failure.
+  def message(value)
+    ""
+  end
+
+  # Collect the results of all of them.
+  def result
+    values.collect { |value| pass?(value) }
+  end
+
+  # Test whether our confine matches.
+  def valid?
+    values.each do |value|
+      unless pass?(value)
+        Puppet.debug(label + ": " + message(value))
+        return false
+      end
+    end
+
+    return true
+  ensure
+    reset
+  end
+
+  # Provide a hook for subclasses.
+  def reset
+  end
+end