From cacafeb4226fd755865dc1b5c64dd9a269444f47 Mon Sep 17 00:00:00 2001 From: James Turnbull Date: Fri, 24 Oct 2008 08:03:31 +1100 Subject: Added augeas type and feature --- lib/puppet/feature/base.rb | 3 + lib/puppet/type/augeas.rb | 289 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 292 insertions(+) create mode 100644 lib/puppet/type/augeas.rb (limited to 'lib/puppet') diff --git a/lib/puppet/feature/base.rb b/lib/puppet/feature/base.rb index 518e9b419..0b12d730a 100644 --- a/lib/puppet/feature/base.rb +++ b/lib/puppet/feature/base.rb @@ -22,3 +22,6 @@ Puppet.features.add(:mongrel, :libs => %w{rubygems mongrel puppet/network/http_s # We have lcs diff Puppet.features.add :diff, :libs => %w{diff/lcs diff/lcs/hunk} + +# We have augeas +Puppet.features.add(:augeas, :libs => ["augeas"]) diff --git a/lib/puppet/type/augeas.rb b/lib/puppet/type/augeas.rb new file mode 100644 index 000000000..55f68b3f7 --- /dev/null +++ b/lib/puppet/type/augeas.rb @@ -0,0 +1,289 @@ +#-- +# Copyright (C) 2008 Red Hat Inc. +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# Author: Bryan Kearney + +require 'augeas' if Puppet.features.augeas? + +Puppet::Type.newtype(:augeas) do + include Puppet::Util + + confine "The augeas Ruby bindings are not available" => Puppet.features.augeas? + + @doc = "Apply the changes (single or array of changes) to the filesystem + via the augeas tool. + + Requires: + - augeas to be installed (http://www.augeas.net) + - ruby-augeas bindings + + Sample usage with a string: + augeas{\"test1\" : + context => \"/files/etc/sysconfig/firstboot\", + changes => \"set RUN_FIRSTBOOT YES\" + onlyif => \"match other_value size > 0\" + } + + Sample usage with an array and custom lenses: + augeas{\"jboss_conf\": + context => \"/files\", + changes => [ + \"set /etc/jbossas/jbossas.conf/JBOSS_IP $ipaddress\", + \"set /etc/jbossas/jbossas.conf/JAVA_HOME /usr\" + ], + load_path => \"$/usr/share/jbossas/lenses\", + } + " + + newparam (:name) do + desc "The name of this task. Used for uniqueness" + isnamevar + end + + newparam (:context) do + desc "Optional context path. This value is pre-pended to the paths of all changes" + defaultto "" + end + + newparam (:onlyif) do + desc "Optional augeas command and comparisons to control the execution of this type. + Supported onlyif syntax: + get [AUGEAS_PATH] [COMPARATOR] [STRING] + match [MATCH_PATH] size [COMPARATOR] [INT] + match [MATCH_PATH] include [STRING] + match [MATCH_PATH] == [AN_ARRAY] + + where + AUGEAS_PATH is a valid path scoped by the context + MATCH_PATH is a valid match synatx scoped by the context + COMPARATOR is in the set [> >= != == <= <] + STRING is a string + INT is a number + AN_ARRAY is in the form ['a string', 'another'] " + defaultto "" + end + + + newparam(:changes) do + desc "The changes which should be applied to the filesystem. This + can be either a string which contains a command or an array of commands. + Commands supported are: + + set [PATH] [VALUE] Sets the value VALUE at loction PATH + rm [PATH] Removes the node at location PATH + remove [PATH] Synonym for rm + clear [PATH] Keeps the node at PATH, but removes the value. + ins [PATH] Inserts an empty node at PATH. + insert [PATH] Synonym for ins + + If the parameter 'context' is set that that value is prepended to PATH" + + # 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_tokens(data) + commands = Array.new() + if data.is_a?(String) + data.each_line do |line| + cmd_array = Array.new() + tokens = line.split(" ") + cmd = tokens.shift() + file = tokens.shift() + other = tokens.join(" ") + cmd_array << cmd if !cmd.nil? + cmd_array << file if !file.nil? + cmd_array << other if other != "" + commands << cmd_array + end + elsif data.is_a?(Array) + data.each do |datum| + commands.concat(parse_tokens(datum)) + end + end + + return commands + end + + munge do |value| + self.parse_tokens(value) + end + end + + newparam(:root) do + desc "A file system path; all files loaded by Augeas are loaded underneath ROOT" + defaultto "/" + end + + newparam(:load_path) do + desc "Optional colon separated list of directories; these directories are searched for schema definitions" + defaultto "" + end + + + newparam(:type_check) do + desc "Set to true if augeas should perform typechecking. Optional, defaults to false" + newvalues(:true, :false) + + defaultto :false + end + + # This is the acutal meat of the code. It forces + # augeas to be run and fails or not based on the augeas return + # code. + newproperty(:returns) do |property| + include Puppet::Util + desc "The expected return code from the augeas command. Should not be set" + + defaultto 0 + + def open_augeas + flags = 0 + (flags = 1 << 2 ) if self.resource[:type_check] == :true + root = self.resource[:root] + load_path = self.resource[:load_path] + debug("Opening augeas with root #{root}, lens path #{load_path}, flags #{flags}") + Augeas.open(root, load_path,flags) + end + + # Make output a bit prettier + def change_to_s(currentvalue, newvalue) + return "executed successfully" + end + + # method to handle the onlif get strings. + # Assumes a syntax of get /files/path [COMPARATOR] value + def process_get(cmd_array) + return_value = 0 + + #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 + aug = open_augeas() + result = aug.get(path) || '' + unless result.nil? + case comparator + when "!=": + return_value = :need_to_run if !(result == arg) + when "=~": + regex = Regexp.new(arg) + loc = result=~ regex + return_value = :need_to_run if ! loc.nil? + else + return_value = :need_to_run if (result.send(comparator, arg)) + end + end + return_value + end + + # This will handle the following cases + def process_match(cmd_array) + return_value = 0 + + #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() + verb = cmd_array.shift() + + #Get the values from augeas + aug = open_augeas() + result = aug.match(path) || '' + # Now do the work + if (!result.nil?) + case verb + when "size": + fail("Invalid command: #{cmd_array.join(" ")}") if cmd_array.length != 2 + comparator = cmd_array.shift() + arg = cmd_array.shift().to_i + return_value = :need_to_run if (result.size.send(comparator, arg)) + when "include": + arg = cmd_array.join(" ") + return_value = :need_to_run if result.include?(arg) + when "==": + begin + arg = cmd_array.join(" ") + new_array = eval arg + return_value = :need_to_run if result == new_array + rescue + fail("Invalid array in command: #{cmd_array.join(" ")}") + end + end + end + return_value + end + + # if the onlyif resource is provided, then the value is parsed. + # a return value of 0 will stop exection becuase it matches the + # default value. + def retrieve + return_value = :need_to_run + filter = self.resource[:onlyif] + unless (filter == "") + cmd_array = filter.split + command = cmd_array[0]; + cmd_array[1]= File.join(resource[:context], cmd_array[1]) + begin + case command + when "get" then return_value = process_get(cmd_array) + when "match" then return_value = process_match(cmd_array) + end + rescue Exception => e + fail("Error sending command '#{command}' with params #{cmd_array[1..-1].inspect}/#{e.message}") + end + end + return_value + end + + # Actually execute the command. + def sync + aug = open_augeas + commands = self.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() + cmd_array[0]=File.join(resource[:context], cmd_array[0]) + debug("sending command '#{command}' with params #{cmd_array.inspect}") + begin + case command + when "set": aug.set(cmd_array[0], cmd_array[1]) + when "rm", "remove": aug.rm(cmd_array[0]) + when "clear": aug.clear(cmd_array[0]) + when "insert", "ins": aug.insert(cmd_array[0]) + else fail("Command '#{command}' is not supported") + end + rescue Exception => e + fail("Error sending command '#{command}' with params #{cmd_array.inspect}/#{e.message}") + end + end + success = aug.save() + if (success != true) + fail("Save failed with return code #{success}") + end + + return :executed + end + end +end -- cgit From bc8cdb1820d08dafeb5f998393cd3efb1c0571b1 Mon Sep 17 00:00:00 2001 From: Bryan Kearney Date: Mon, 27 Oct 2008 13:04:25 -0400 Subject: Beginning provider split, need help on the voodoo --- lib/puppet/provider/augeas.rb | 200 ++++++++++++++++++++++++++++++++++++++++++ lib/puppet/type/augeas.rb | 192 +++------------------------------------- 2 files changed, 211 insertions(+), 181 deletions(-) create mode 100644 lib/puppet/provider/augeas.rb (limited to 'lib/puppet') diff --git a/lib/puppet/provider/augeas.rb b/lib/puppet/provider/augeas.rb new file mode 100644 index 000000000..eaaa04362 --- /dev/null +++ b/lib/puppet/provider/augeas.rb @@ -0,0 +1,200 @@ +#-- +# Copyright (C) 2008 Red Hat Inc. +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# Author: Bryan Kearney + +require 'augeas' if Puppet.features.augeas? + +Puppet::Type.type(:augeas).provide(:augeas) do +#class Puppet::Provider::Augeas < Puppet::Provider + include Puppet::Util + + confine "The augeas Ruby bindings are not available" => Puppet.features.augeas? + + + # 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. + self.def parse_commands(data) + commands = Array.new() + if data.is_a?(String) + data.each_line do |line| + cmd_array = Array.new() + tokens = line.split(" ") + cmd = tokens.shift() + file = tokens.shift() + other = tokens.join(" ") + cmd_array << cmd if !cmd.nil? + cmd_array << file if !file.nil? + cmd_array << other if other != "" + commands << cmd_array + end + elsif data.is_a?(Array) + data.each do |datum| + commands.concat(parse_commands(datum)) + end + end + + return commands + end + + # This is the acutal meat of the code. It forces + # augeas to be run and fails or not based on the augeas return + # code. + newproperty(:returns) do |property| + include Puppet::Util + desc "The expected return code from the augeas command. Should not be set" + + defaultto 0 + + def open_augeas + flags = 0 + (flags = 1 << 2 ) if self.resource[:type_check] == :true + root = self.resource[:root] + load_path = self.resource[:load_path] + debug("Opening augeas with root #{root}, lens path #{load_path}, flags #{flags}") + Augeas.open(root, load_path,flags) + end + + # Make output a bit prettier + def change_to_s(currentvalue, newvalue) + return "executed successfully" + end + + # method to handle the onlif get strings. + # Assumes a syntax of get /files/path [COMPARATOR] value + def process_get(cmd_array) + return_value = 0 + + #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 + aug = open_augeas() + result = aug.get(path) || '' + unless result.nil? + case comparator + when "!=": + return_value = :need_to_run if !(result == arg) + when "=~": + regex = Regexp.new(arg) + loc = result=~ regex + return_value = :need_to_run if ! loc.nil? + else + return_value = :need_to_run if (result.send(comparator, arg)) + end + end + return_value + end + + # This will handle the following cases + def process_match(cmd_array) + return_value = 0 + + #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() + verb = cmd_array.shift() + + #Get the values from augeas + aug = open_augeas() + result = aug.match(path) || '' + # Now do the work + if (!result.nil?) + case verb + when "size": + fail("Invalid command: #{cmd_array.join(" ")}") if cmd_array.length != 2 + comparator = cmd_array.shift() + arg = cmd_array.shift().to_i + return_value = :need_to_run if (result.size.send(comparator, arg)) + when "include": + arg = cmd_array.join(" ") + return_value = :need_to_run if result.include?(arg) + when "==": + begin + arg = cmd_array.join(" ") + new_array = eval arg + return_value = :need_to_run if result == new_array + rescue + fail("Invalid array in command: #{cmd_array.join(" ")}") + end + end + end + return_value + end + + # if the onlyif resource is provided, then the value is parsed. + # a return value of 0 will stop exection becuase it matches the + # default value. + def retrieve + return_value = :need_to_run + filter = self.resource[:onlyif] + unless (filter == "") + cmd_array = filter.split + command = cmd_array[0]; + cmd_array[1]= File.join(resource[:context], cmd_array[1]) + begin + case command + when "get" then return_value = process_get(cmd_array) + when "match" then return_value = process_match(cmd_array) + end + rescue Exception => e + fail("Error sending command '#{command}' with params #{cmd_array[1..-1].inspect}/#{e.message}") + end + end + return_value + end + + # Actually execute the command. + def sync + aug = open_augeas + commands = self.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() + cmd_array[0]=File.join(resource[:context], cmd_array[0]) + debug("sending command '#{command}' with params #{cmd_array.inspect}") + begin + case command + when "set": aug.set(cmd_array[0], cmd_array[1]) + when "rm", "remove": aug.rm(cmd_array[0]) + when "clear": aug.clear(cmd_array[0]) + when "insert", "ins": aug.insert(cmd_array[0]) + else fail("Command '#{command}' is not supported") + end + rescue Exception => e + fail("Error sending command '#{command}' with params #{cmd_array.inspect}/#{e.message}") + end + end + success = aug.save() + if (success != true) + fail("Save failed with return code #{success}") + end + + return :executed + end + end +end diff --git a/lib/puppet/type/augeas.rb b/lib/puppet/type/augeas.rb index 55f68b3f7..61468c080 100644 --- a/lib/puppet/type/augeas.rb +++ b/lib/puppet/type/augeas.rb @@ -11,19 +11,15 @@ # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # -# You should have received a copy of the GNU Lesser General Public +# You should have received a copy of the GNU Lesser General Publicretu # License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # Author: Bryan Kearney -require 'augeas' if Puppet.features.augeas? - Puppet::Type.newtype(:augeas) do include Puppet::Util - confine "The augeas Ruby bindings are not available" => Puppet.features.augeas? - @doc = "Apply the changes (single or array of changes) to the filesystem via the augeas tool. @@ -56,7 +52,7 @@ Puppet::Type.newtype(:augeas) do newparam (:context) do desc "Optional context path. This value is pre-pended to the paths of all changes" - defaultto "" + defaultto "" end newparam (:onlyif) do @@ -76,7 +72,7 @@ Puppet::Type.newtype(:augeas) do AN_ARRAY is in the form ['a string', 'another'] " defaultto "" end - + newparam(:changes) do desc "The changes which should be applied to the filesystem. This @@ -92,40 +88,17 @@ Puppet::Type.newtype(:augeas) do If the parameter 'context' is set that that value is prepended to PATH" - # 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_tokens(data) - commands = Array.new() - if data.is_a?(String) - data.each_line do |line| - cmd_array = Array.new() - tokens = line.split(" ") - cmd = tokens.shift() - file = tokens.shift() - other = tokens.join(" ") - cmd_array << cmd if !cmd.nil? - cmd_array << file if !file.nil? - cmd_array << other if other != "" - commands << cmd_array - end - elsif data.is_a?(Array) - data.each do |datum| - commands.concat(parse_tokens(datum)) - end - end - - return commands - end - - munge do |value| - self.parse_tokens(value) + munge do |value| + puts @resource + puts @resource.provider + puts @resource.class + puts provider.class + puts resource + # provider.parse_commands(value) end end + newparam(:root) do desc "A file system path; all files loaded by Augeas are loaded underneath ROOT" defaultto "/" @@ -143,147 +116,4 @@ Puppet::Type.newtype(:augeas) do defaultto :false end - - # This is the acutal meat of the code. It forces - # augeas to be run and fails or not based on the augeas return - # code. - newproperty(:returns) do |property| - include Puppet::Util - desc "The expected return code from the augeas command. Should not be set" - - defaultto 0 - - def open_augeas - flags = 0 - (flags = 1 << 2 ) if self.resource[:type_check] == :true - root = self.resource[:root] - load_path = self.resource[:load_path] - debug("Opening augeas with root #{root}, lens path #{load_path}, flags #{flags}") - Augeas.open(root, load_path,flags) - end - - # Make output a bit prettier - def change_to_s(currentvalue, newvalue) - return "executed successfully" - end - - # method to handle the onlif get strings. - # Assumes a syntax of get /files/path [COMPARATOR] value - def process_get(cmd_array) - return_value = 0 - - #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 - aug = open_augeas() - result = aug.get(path) || '' - unless result.nil? - case comparator - when "!=": - return_value = :need_to_run if !(result == arg) - when "=~": - regex = Regexp.new(arg) - loc = result=~ regex - return_value = :need_to_run if ! loc.nil? - else - return_value = :need_to_run if (result.send(comparator, arg)) - end - end - return_value - end - - # This will handle the following cases - def process_match(cmd_array) - return_value = 0 - - #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() - verb = cmd_array.shift() - - #Get the values from augeas - aug = open_augeas() - result = aug.match(path) || '' - # Now do the work - if (!result.nil?) - case verb - when "size": - fail("Invalid command: #{cmd_array.join(" ")}") if cmd_array.length != 2 - comparator = cmd_array.shift() - arg = cmd_array.shift().to_i - return_value = :need_to_run if (result.size.send(comparator, arg)) - when "include": - arg = cmd_array.join(" ") - return_value = :need_to_run if result.include?(arg) - when "==": - begin - arg = cmd_array.join(" ") - new_array = eval arg - return_value = :need_to_run if result == new_array - rescue - fail("Invalid array in command: #{cmd_array.join(" ")}") - end - end - end - return_value - end - - # if the onlyif resource is provided, then the value is parsed. - # a return value of 0 will stop exection becuase it matches the - # default value. - def retrieve - return_value = :need_to_run - filter = self.resource[:onlyif] - unless (filter == "") - cmd_array = filter.split - command = cmd_array[0]; - cmd_array[1]= File.join(resource[:context], cmd_array[1]) - begin - case command - when "get" then return_value = process_get(cmd_array) - when "match" then return_value = process_match(cmd_array) - end - rescue Exception => e - fail("Error sending command '#{command}' with params #{cmd_array[1..-1].inspect}/#{e.message}") - end - end - return_value - end - - # Actually execute the command. - def sync - aug = open_augeas - commands = self.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() - cmd_array[0]=File.join(resource[:context], cmd_array[0]) - debug("sending command '#{command}' with params #{cmd_array.inspect}") - begin - case command - when "set": aug.set(cmd_array[0], cmd_array[1]) - when "rm", "remove": aug.rm(cmd_array[0]) - when "clear": aug.clear(cmd_array[0]) - when "insert", "ins": aug.insert(cmd_array[0]) - else fail("Command '#{command}' is not supported") - end - rescue Exception => e - fail("Error sending command '#{command}' with params #{cmd_array.inspect}/#{e.message}") - end - end - success = aug.save() - if (success != true) - fail("Save failed with return code #{success}") - end - - return :executed - end - end end -- cgit From 9ecbd6306d227189ba161954aafc3e7f782a87b9 Mon Sep 17 00:00:00 2001 From: Brice Figureau Date: Sat, 11 Oct 2008 18:45:16 +0200 Subject: Fixed #1104 - Classes and nodes should set $name variables Signed-off-by: Brice Figureau --- lib/puppet/parser/ast/hostclass.rb | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) (limited to 'lib/puppet') diff --git a/lib/puppet/parser/ast/hostclass.rb b/lib/puppet/parser/ast/hostclass.rb index 7f89f8151..4f5c4797c 100644 --- a/lib/puppet/parser/ast/hostclass.rb +++ b/lib/puppet/parser/ast/hostclass.rb @@ -56,7 +56,12 @@ class Puppet::Parser::AST::HostClass < Puppet::Parser::AST::Definition # Don't create a subscope for the top-level class, since it already # has its own scope. - scope = subscope(scope, resource) unless resource.title == :main + unless resource.title == :main + scope = subscope(scope, resource) + + scope.setvar("title", resource.title) + scope.setvar("name", resource.name) + end # Add the parent scope namespaces to our own. if pnames -- cgit From 6ab4f1b0e2a3f5881d865ca181c053c64d5026a7 Mon Sep 17 00:00:00 2001 From: James Turnbull Date: Tue, 28 Oct 2008 14:48:11 +1100 Subject: Fixed #1661 - Type reference: tidy should specify manditory parameters --- lib/puppet/type/tidy.rb | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'lib/puppet') diff --git a/lib/puppet/type/tidy.rb b/lib/puppet/type/tidy.rb index fe8bde9ab..7a464323f 100755 --- a/lib/puppet/type/tidy.rb +++ b/lib/puppet/type/tidy.rb @@ -2,7 +2,10 @@ module Puppet newtype(:tidy, :parent => Puppet.type(:file)) do @doc = "Remove unwanted files based on specific criteria. Multiple criteria are OR'd together, so a file that is too large but is not - old enough will still get tidied." + old enough will still get tidied. + + You must specify either the size or age of the file (or both) for + files to be tidied." newparam(:path) do desc "The path to the file or directory to manage. Must be fully -- cgit From 42cac73a7ce531e125c1c94f7bd942d9002e5445 Mon Sep 17 00:00:00 2001 From: Luke Kanies Date: Mon, 27 Oct 2008 23:22:03 -0500 Subject: Fixing #1698 - all logs again show up in the report. --- lib/puppet/util/log.rb | 17 +---------------- 1 file changed, 1 insertion(+), 16 deletions(-) (limited to 'lib/puppet') diff --git a/lib/puppet/util/log.rb b/lib/puppet/util/log.rb index 0dfd36dfa..b57faad42 100644 --- a/lib/puppet/util/log.rb +++ b/lib/puppet/util/log.rb @@ -369,11 +369,7 @@ class Puppet::Util::Log end def handle(msg) - # Only add messages from objects, since anything else is - # probably unrelated to this run. - if msg.objectsource? - @report.newlog(msg) - end + @report.newlog(msg) end end @@ -505,15 +501,6 @@ class Puppet::Util::Log Log.newmessage(self) end - # Was the source of this log a Puppet resource or parameter? - def objectsource? - if defined? @objectsource and @objectsource - @objectsource - else - false - end - end - # If they pass a source in to us, we make sure it is a string, and # we retrieve any tags we can. def source=(source) @@ -521,10 +508,8 @@ class Puppet::Util::Log # We can't just check for whether it responds to :path, because # plenty of providers respond to that in their normal function. if (source.is_a?(Puppet::Type) or source.is_a?(Puppet::Parameter)) and source.respond_to?(:path) - @objectsource = true @source = source.path else - @objectsource = false @source = source.to_s end if source.respond_to?(:tags) -- cgit From 57e791b9e7da931e61dd8dfc0f68bd13cf2e6449 Mon Sep 17 00:00:00 2001 From: Luke Kanies Date: Mon, 27 Oct 2008 23:37:33 -0500 Subject: Fixing #1660 - Adding specifically supported values for tidy recursion. Basically just copied the code for the recurse parameter from 'file'. Signed-off-by: Luke Kanies --- lib/puppet/type/tidy.rb | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) (limited to 'lib/puppet') diff --git a/lib/puppet/type/tidy.rb b/lib/puppet/type/tidy.rb index 7a464323f..c352ec85b 100755 --- a/lib/puppet/type/tidy.rb +++ b/lib/puppet/type/tidy.rb @@ -252,6 +252,23 @@ module Puppet newparam(:recurse) do desc "If target is a directory, recursively descend into the directory looking for files to tidy." + + newvalues(:true, :false, :inf, /^[0-9]+$/) + + # Replace the validation so that we allow numbers in + # addition to string representations of them. + validate { |arg| } + munge do |value| + newval = super(value) + case newval + when :true, :inf: true + when :false: false + when Integer, Fixnum, Bignum: value + when /^\d+$/: Integer(value) + else + raise ArgumentError, "Invalid recurse value %s" % value.inspect + end + end end newparam(:rmdirs) do -- cgit From e542f8c6fbfb5ae5eead9d5744667bd6840159f7 Mon Sep 17 00:00:00 2001 From: James Turnbull Date: Tue, 28 Oct 2008 15:57:03 +1100 Subject: Fixed #1692 - k5login fails to set mode when file is created --- lib/puppet/type/k5login.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'lib/puppet') diff --git a/lib/puppet/type/k5login.rb b/lib/puppet/type/k5login.rb index 2372f658a..d22be11b7 100644 --- a/lib/puppet/type/k5login.rb +++ b/lib/puppet/type/k5login.rb @@ -46,7 +46,7 @@ Puppet::Type.newtype(:k5login) do write(@resource.should(:principals)) should_mode = @resource.should(:mode) unless self.mode == should_mode - self.mode should_mode + self.mode = should_mode end end -- cgit From 9fd1756a8aa56c5d73957a70d5a31a1f6e4223d7 Mon Sep 17 00:00:00 2001 From: Bryan Kearney Date: Mon, 27 Oct 2008 13:04:25 -0400 Subject: Split Augeas up into a provider and a type. --- lib/puppet/provider/augeas.rb | 200 +++++++++++++++++++++++++++++++++++ lib/puppet/provider/augeas/augeas.rb | 188 ++++++++++++++++++++++++++++++++ lib/puppet/type/augeas.rb | 183 ++++---------------------------- 3 files changed, 410 insertions(+), 161 deletions(-) create mode 100644 lib/puppet/provider/augeas.rb create mode 100644 lib/puppet/provider/augeas/augeas.rb (limited to 'lib/puppet') diff --git a/lib/puppet/provider/augeas.rb b/lib/puppet/provider/augeas.rb new file mode 100644 index 000000000..eaaa04362 --- /dev/null +++ b/lib/puppet/provider/augeas.rb @@ -0,0 +1,200 @@ +#-- +# Copyright (C) 2008 Red Hat Inc. +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# Author: Bryan Kearney + +require 'augeas' if Puppet.features.augeas? + +Puppet::Type.type(:augeas).provide(:augeas) do +#class Puppet::Provider::Augeas < Puppet::Provider + include Puppet::Util + + confine "The augeas Ruby bindings are not available" => Puppet.features.augeas? + + + # 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. + self.def parse_commands(data) + commands = Array.new() + if data.is_a?(String) + data.each_line do |line| + cmd_array = Array.new() + tokens = line.split(" ") + cmd = tokens.shift() + file = tokens.shift() + other = tokens.join(" ") + cmd_array << cmd if !cmd.nil? + cmd_array << file if !file.nil? + cmd_array << other if other != "" + commands << cmd_array + end + elsif data.is_a?(Array) + data.each do |datum| + commands.concat(parse_commands(datum)) + end + end + + return commands + end + + # This is the acutal meat of the code. It forces + # augeas to be run and fails or not based on the augeas return + # code. + newproperty(:returns) do |property| + include Puppet::Util + desc "The expected return code from the augeas command. Should not be set" + + defaultto 0 + + def open_augeas + flags = 0 + (flags = 1 << 2 ) if self.resource[:type_check] == :true + root = self.resource[:root] + load_path = self.resource[:load_path] + debug("Opening augeas with root #{root}, lens path #{load_path}, flags #{flags}") + Augeas.open(root, load_path,flags) + end + + # Make output a bit prettier + def change_to_s(currentvalue, newvalue) + return "executed successfully" + end + + # method to handle the onlif get strings. + # Assumes a syntax of get /files/path [COMPARATOR] value + def process_get(cmd_array) + return_value = 0 + + #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 + aug = open_augeas() + result = aug.get(path) || '' + unless result.nil? + case comparator + when "!=": + return_value = :need_to_run if !(result == arg) + when "=~": + regex = Regexp.new(arg) + loc = result=~ regex + return_value = :need_to_run if ! loc.nil? + else + return_value = :need_to_run if (result.send(comparator, arg)) + end + end + return_value + end + + # This will handle the following cases + def process_match(cmd_array) + return_value = 0 + + #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() + verb = cmd_array.shift() + + #Get the values from augeas + aug = open_augeas() + result = aug.match(path) || '' + # Now do the work + if (!result.nil?) + case verb + when "size": + fail("Invalid command: #{cmd_array.join(" ")}") if cmd_array.length != 2 + comparator = cmd_array.shift() + arg = cmd_array.shift().to_i + return_value = :need_to_run if (result.size.send(comparator, arg)) + when "include": + arg = cmd_array.join(" ") + return_value = :need_to_run if result.include?(arg) + when "==": + begin + arg = cmd_array.join(" ") + new_array = eval arg + return_value = :need_to_run if result == new_array + rescue + fail("Invalid array in command: #{cmd_array.join(" ")}") + end + end + end + return_value + end + + # if the onlyif resource is provided, then the value is parsed. + # a return value of 0 will stop exection becuase it matches the + # default value. + def retrieve + return_value = :need_to_run + filter = self.resource[:onlyif] + unless (filter == "") + cmd_array = filter.split + command = cmd_array[0]; + cmd_array[1]= File.join(resource[:context], cmd_array[1]) + begin + case command + when "get" then return_value = process_get(cmd_array) + when "match" then return_value = process_match(cmd_array) + end + rescue Exception => e + fail("Error sending command '#{command}' with params #{cmd_array[1..-1].inspect}/#{e.message}") + end + end + return_value + end + + # Actually execute the command. + def sync + aug = open_augeas + commands = self.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() + cmd_array[0]=File.join(resource[:context], cmd_array[0]) + debug("sending command '#{command}' with params #{cmd_array.inspect}") + begin + case command + when "set": aug.set(cmd_array[0], cmd_array[1]) + when "rm", "remove": aug.rm(cmd_array[0]) + when "clear": aug.clear(cmd_array[0]) + when "insert", "ins": aug.insert(cmd_array[0]) + else fail("Command '#{command}' is not supported") + end + rescue Exception => e + fail("Error sending command '#{command}' with params #{cmd_array.inspect}/#{e.message}") + end + end + success = aug.save() + if (success != true) + fail("Save failed with return code #{success}") + end + + return :executed + end + end +end diff --git a/lib/puppet/provider/augeas/augeas.rb b/lib/puppet/provider/augeas/augeas.rb new file mode 100644 index 000000000..a487e2ac5 --- /dev/null +++ b/lib/puppet/provider/augeas/augeas.rb @@ -0,0 +1,188 @@ +#-- +# Copyright (C) 2008 Red Hat Inc. +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# Author: Bryan Kearney + +require 'augeas' if Puppet.features.augeas? + +Puppet::Type.type(:augeas).provide(:augeas) do +#class Puppet::Provider::Augeas < Puppet::Provider + include Puppet::Util + + confine :true => Puppet.features.augeas? + + has_features :parse_commands, :need_to_run?,:execute_changes + + # 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) + commands = Array.new() + if data.is_a?(String) + data.each_line do |line| + cmd_array = Array.new() + tokens = line.split(" ") + cmd = tokens.shift() + file = tokens.shift() + other = tokens.join(" ") + cmd_array << cmd if !cmd.nil? + cmd_array << file if !file.nil? + cmd_array << other if other != "" + commands << cmd_array + end + elsif data.is_a?(Array) + data.each do |datum| + commands.concat(parse_commands(datum)) + end + end + + return commands + end + + def open_augeas + flags = 0 + (flags = 1 << 2 ) if self.resource[:type_check] == :true + root = self.resource[:root] + load_path = self.resource[:load_path] + debug("Opening augeas with root #{root}, lens path #{load_path}, flags #{flags}") + Augeas.open(root, load_path,flags) + 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 + aug = open_augeas() + result = aug.get(path) || '' + unless result.nil? + case comparator + when "!=": + return_value = true if !(result == arg) + when "=~": + regex = Regexp.new(arg) + loc = result=~ regex + return_value = true if ! loc.nil? + else + return_value = true if (result.send(comparator, arg)) + end + 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 < 4 + cmd = cmd_array.shift() + path = cmd_array.shift() + verb = cmd_array.shift() + + #Get the values from augeas + aug = open_augeas() + result = aug.match(path) || '' + # Now do the work + if (!result.nil?) + case verb + when "size": + fail("Invalid command: #{cmd_array.join(" ")}") if cmd_array.length != 2 + comparator = cmd_array.shift() + arg = cmd_array.shift().to_i + return_value = true if (result.size.send(comparator, arg)) + when "include": + arg = cmd_array.join(" ") + return_value = true if result.include?(arg) + when "==": + begin + arg = cmd_array.join(" ") + new_array = eval arg + return_value = true if result == new_array + rescue + fail("Invalid array in command: #{cmd_array.join(" ")}") + end + end + end + return_value + end + + # Determines if augeas acutally needs to run. + def need_to_run? + return_value = true + filter = resource[:onlyif] + unless (filter == "") + cmd_array = filter.split + command = cmd_array[0]; + cmd_array[1]= File.join(resource[:context], cmd_array[1]) + begin + data = nil + case command + when "get" then return_value = process_get(cmd_array) + when "match" then return_value = process_match(cmd_array) + end + rescue Exception => e + fail("Error sending command '#{command}' with params #{cmd_array[1..-1].inspect}/#{e.message}") + end + end + return_value + end + + # Actually execute the augeas changes. + def execute_changes + aug = open_augeas + commands = self.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() + cmd_array[0]=File.join(resource[:context], cmd_array[0]) + debug("sending command '#{command}' with params #{cmd_array.inspect}") + begin + case command + when "set": aug.set(cmd_array[0], cmd_array[1]) + when "rm", "remove": aug.rm(cmd_array[0]) + when "clear": aug.clear(cmd_array[0]) + when "insert", "ins": aug.insert(cmd_array[0]) + else fail("Command '#{command}' is not supported") + end + rescue Exception => e + fail("Error sending command '#{command}' with params #{cmd_array.inspect}/#{e.message}") + end + end + success = aug.save() + if (success != true) + fail("Save failed with return code #{success}") + end + + return :executed + end + +end diff --git a/lib/puppet/type/augeas.rb b/lib/puppet/type/augeas.rb index 55f68b3f7..20b5bbbc9 100644 --- a/lib/puppet/type/augeas.rb +++ b/lib/puppet/type/augeas.rb @@ -11,18 +11,18 @@ # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # -# You should have received a copy of the GNU Lesser General Public +# You should have received a copy of the GNU Lesser General Publicretu # License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # Author: Bryan Kearney -require 'augeas' if Puppet.features.augeas? - Puppet::Type.newtype(:augeas) do include Puppet::Util - - confine "The augeas Ruby bindings are not available" => Puppet.features.augeas? + + feature :parse_commands, "Parse the command string" + feature :need_to_run?, "If the command should run" + feature :execute_changes, "Actually make the changes" @doc = "Apply the changes (single or array of changes) to the filesystem via the augeas tool. @@ -56,7 +56,7 @@ Puppet::Type.newtype(:augeas) do newparam (:context) do desc "Optional context path. This value is pre-pended to the paths of all changes" - defaultto "" + defaultto "" end newparam (:onlyif) do @@ -76,7 +76,7 @@ Puppet::Type.newtype(:augeas) do AN_ARRAY is in the form ['a string', 'another'] " defaultto "" end - + newparam(:changes) do desc "The changes which should be applied to the filesystem. This @@ -92,40 +92,12 @@ Puppet::Type.newtype(:augeas) do If the parameter 'context' is set that that value is prepended to PATH" - # 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_tokens(data) - commands = Array.new() - if data.is_a?(String) - data.each_line do |line| - cmd_array = Array.new() - tokens = line.split(" ") - cmd = tokens.shift() - file = tokens.shift() - other = tokens.join(" ") - cmd_array << cmd if !cmd.nil? - cmd_array << file if !file.nil? - cmd_array << other if other != "" - commands << cmd_array - end - elsif data.is_a?(Array) - data.each do |datum| - commands.concat(parse_tokens(datum)) - end - end - - return commands - end - - munge do |value| - self.parse_tokens(value) + munge do |value| + provider.parse_commands(value) end end + newparam(:root) do desc "A file system path; all files loaded by Augeas are loaded underneath ROOT" defaultto "/" @@ -143,7 +115,7 @@ Puppet::Type.newtype(:augeas) do defaultto :false end - + # This is the acutal meat of the code. It forces # augeas to be run and fails or not based on the augeas return # code. @@ -152,138 +124,27 @@ Puppet::Type.newtype(:augeas) do desc "The expected return code from the augeas command. Should not be set" defaultto 0 - - def open_augeas - flags = 0 - (flags = 1 << 2 ) if self.resource[:type_check] == :true - root = self.resource[:root] - load_path = self.resource[:load_path] - debug("Opening augeas with root #{root}, lens path #{load_path}, flags #{flags}") - Augeas.open(root, load_path,flags) - end - + # Make output a bit prettier def change_to_s(currentvalue, newvalue) return "executed successfully" - end - - # method to handle the onlif get strings. - # Assumes a syntax of get /files/path [COMPARATOR] value - def process_get(cmd_array) - return_value = 0 - - #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 - aug = open_augeas() - result = aug.get(path) || '' - unless result.nil? - case comparator - when "!=": - return_value = :need_to_run if !(result == arg) - when "=~": - regex = Regexp.new(arg) - loc = result=~ regex - return_value = :need_to_run if ! loc.nil? - else - return_value = :need_to_run if (result.send(comparator, arg)) - end - end - return_value - end - - # This will handle the following cases - def process_match(cmd_array) - return_value = 0 - - #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() - verb = cmd_array.shift() - - #Get the values from augeas - aug = open_augeas() - result = aug.match(path) || '' - # Now do the work - if (!result.nil?) - case verb - when "size": - fail("Invalid command: #{cmd_array.join(" ")}") if cmd_array.length != 2 - comparator = cmd_array.shift() - arg = cmd_array.shift().to_i - return_value = :need_to_run if (result.size.send(comparator, arg)) - when "include": - arg = cmd_array.join(" ") - return_value = :need_to_run if result.include?(arg) - when "==": - begin - arg = cmd_array.join(" ") - new_array = eval arg - return_value = :need_to_run if result == new_array - rescue - fail("Invalid array in command: #{cmd_array.join(" ")}") - end - end - end - return_value - end - + end + # if the onlyif resource is provided, then the value is parsed. # a return value of 0 will stop exection becuase it matches the # default value. def retrieve - return_value = :need_to_run - filter = self.resource[:onlyif] - unless (filter == "") - cmd_array = filter.split - command = cmd_array[0]; - cmd_array[1]= File.join(resource[:context], cmd_array[1]) - begin - case command - when "get" then return_value = process_get(cmd_array) - when "match" then return_value = process_match(cmd_array) - end - rescue Exception => e - fail("Error sending command '#{command}' with params #{cmd_array[1..-1].inspect}/#{e.message}") - end + if @resource.provider.need_to_run?() + :need_to_run + else + 0 end - return_value - end + end # Actually execute the command. def sync - aug = open_augeas - commands = self.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() - cmd_array[0]=File.join(resource[:context], cmd_array[0]) - debug("sending command '#{command}' with params #{cmd_array.inspect}") - begin - case command - when "set": aug.set(cmd_array[0], cmd_array[1]) - when "rm", "remove": aug.rm(cmd_array[0]) - when "clear": aug.clear(cmd_array[0]) - when "insert", "ins": aug.insert(cmd_array[0]) - else fail("Command '#{command}' is not supported") - end - rescue Exception => e - fail("Error sending command '#{command}' with params #{cmd_array.inspect}/#{e.message}") - end - end - success = aug.save() - if (success != true) - fail("Save failed with return code #{success}") - end - - return :executed + @resource.provider.execute_changes() end - end + end + end -- cgit From c906afd9e36017bba339ca50998e1651e54dbd0c Mon Sep 17 00:00:00 2001 From: Luke Kanies Date: Tue, 28 Oct 2008 17:13:31 -0500 Subject: Fixing #1667 - regex automatic value documentation is now readable. Signed-off-by: Luke Kanies --- lib/puppet/parameter.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'lib/puppet') diff --git a/lib/puppet/parameter.rb b/lib/puppet/parameter.rb index f90193fc8..06dfe5b91 100644 --- a/lib/puppet/parameter.rb +++ b/lib/puppet/parameter.rb @@ -63,7 +63,7 @@ class Puppet::Parameter end unless regs.empty? @doc += " Values can also match ``" + - regs.join("``, ``") + "``." + regs.collect { |r| r.inspect }.join("``, ``") + "``." end end -- cgit From c7ccc4ba7c42d56595564491ae578a1604c628d1 Mon Sep 17 00:00:00 2001 From: Brice Figureau Date: Tue, 28 Oct 2008 14:12:36 +0100 Subject: Fix #1682 - ASTArray should flatten product of evaluation of its children If the ASTArray contains children that evaluate to arrays themselves, they aren't flattened. --- lib/puppet/parser/ast/astarray.rb | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'lib/puppet') diff --git a/lib/puppet/parser/ast/astarray.rb b/lib/puppet/parser/ast/astarray.rb index 8f09aa922..0fccbca75 100644 --- a/lib/puppet/parser/ast/astarray.rb +++ b/lib/puppet/parser/ast/astarray.rb @@ -30,10 +30,9 @@ class Puppet::Parser::AST items << child end } - rets = items.flatten.collect { |child| child.safeevaluate(scope) - } + }.flatten return rets.reject { |o| o.nil? } end -- cgit From 4806c51d309e43d0adc45d743a0ea85c3dc2da0d Mon Sep 17 00:00:00 2001 From: Luke Kanies Date: Tue, 28 Oct 2008 19:13:45 -0500 Subject: Fixing #1669 - The dump parameter can now be changed on mounts. Signed-off-by: Luke Kanies --- lib/puppet/type/mount.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'lib/puppet') diff --git a/lib/puppet/type/mount.rb b/lib/puppet/type/mount.rb index 1679b73a3..4eb149488 100755 --- a/lib/puppet/type/mount.rb +++ b/lib/puppet/type/mount.rb @@ -143,7 +143,7 @@ module Puppet desc "Whether to dump the mount. Not all platforms support this. Valid values are ``1`` or ``0``. Default is ``0``." - newvalue(%r{(0|1)}) { } + newvalue(%r{(0|1)}) defaultto { if @resource.managed? -- cgit From 649a9e009a3a5bd070051b972c2cf26989af8e8c Mon Sep 17 00:00:00 2001 From: James Turnbull Date: Wed, 29 Oct 2008 15:53:39 +1100 Subject: Fixed augeas examples in type --- lib/puppet/type/augeas.rb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'lib/puppet') diff --git a/lib/puppet/type/augeas.rb b/lib/puppet/type/augeas.rb index 20b5bbbc9..61339407b 100644 --- a/lib/puppet/type/augeas.rb +++ b/lib/puppet/type/augeas.rb @@ -34,8 +34,8 @@ Puppet::Type.newtype(:augeas) do Sample usage with a string: augeas{\"test1\" : context => \"/files/etc/sysconfig/firstboot\", - changes => \"set RUN_FIRSTBOOT YES\" - onlyif => \"match other_value size > 0\" + changes => \"set RUN_FIRSTBOOT YES\", + onlyif => \"match other_value size > 0\", } Sample usage with an array and custom lenses: -- cgit From 9f30306d2c768bad3327ecb7748669afb10cd4aa Mon Sep 17 00:00:00 2001 From: Brice Figureau Date: Tue, 28 Oct 2008 14:15:08 +0100 Subject: Fix #857 - Multiple class of the same name don't append code The following manifest wasn't working: class one { notice('class one') } class one { notice('second class one') } include one It all boiled down to class code not being arrays. Encapsulating code in ASTArray when needed is enough to append code, because of the property of ASTArray to evaluate all their members in turn. Signed-off-by: Brice Figureau --- lib/puppet/parser/parser_support.rb | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'lib/puppet') diff --git a/lib/puppet/parser/parser_support.rb b/lib/puppet/parser/parser_support.rb index 853d6aa86..1583973a7 100644 --- a/lib/puppet/parser/parser_support.rb +++ b/lib/puppet/parser/parser_support.rb @@ -291,10 +291,14 @@ class Puppet::Parser::Parser if tmp == "" tmp = "main" end - + Puppet.debug addcontext("Adding code to %s" % tmp) # Else, add our code to it. if other.code and code + # promote if neededcodes to ASTArray so that we can append code + # ASTArray knows how to evaluate its members. + other.code = ast AST::ASTArray, :children => [other.code] unless other.code.is_a?(AST::ASTArray) + code = ast AST::ASTArray, :children => [code] unless code.is_a?(AST::ASTArray) other.code.children += code.children else other.code ||= code -- cgit From 2d37f09aa093b10cb64b9b649f0066217c53d48f Mon Sep 17 00:00:00 2001 From: Brice Figureau Date: Tue, 28 Oct 2008 14:17:12 +0100 Subject: Fix #1402 - Allow multiline comments Signed-off-by: Brice Figureau --- lib/puppet/parser/lexer.rb | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'lib/puppet') diff --git a/lib/puppet/parser/lexer.rb b/lib/puppet/parser/lexer.rb index 9226434da..dd6c29d9f 100644 --- a/lib/puppet/parser/lexer.rb +++ b/lib/puppet/parser/lexer.rb @@ -157,6 +157,11 @@ class Puppet::Parser::Lexer TOKENS.add_token :COMMENT, %r{#.*}, :skip => true + TOKENS.add_token :MLCOMMENT, %r{/\*(.*?)\*/}m do |lexer, value| + lexer.line += value.count("\n") + [nil,nil] + end + TOKENS.add_token :RETURN, "\n", :skip => true, :incr_line => true, :skip_text => true TOKENS.add_token :SQUOTE, "'" do |lexer, value| -- cgit From f0635179b60f5cf30d1f7070f4c3c998ad5131c0 Mon Sep 17 00:00:00 2001 From: Bryan Kearney Date: Wed, 29 Oct 2008 11:29:12 -0400 Subject: Added unit tests for the augeas type and provider --- lib/puppet/provider/augeas/augeas.rb | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'lib/puppet') diff --git a/lib/puppet/provider/augeas/augeas.rb b/lib/puppet/provider/augeas/augeas.rb index a487e2ac5..cadbd667b 100644 --- a/lib/puppet/provider/augeas/augeas.rb +++ b/lib/puppet/provider/augeas/augeas.rb @@ -158,12 +158,13 @@ Puppet::Type.type(:augeas).provide(:augeas) do # Actually execute the augeas changes. def execute_changes aug = open_augeas - commands = self.resource[:changes] + commands = resource[:changes] + context = resource[:context] commands.each do |cmd_array| fail("invalid command #{cmd_array.join[" "]}") if cmd_array.length < 2 command = cmd_array[0] cmd_array.shift() - cmd_array[0]=File.join(resource[:context], cmd_array[0]) + cmd_array[0]=File.join(context, cmd_array[0]) debug("sending command '#{command}' with params #{cmd_array.inspect}") begin case command -- cgit