puppet 2.6.18 → 2.7.1

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

@@ -1,21 +1,17 @@
-#--
-#  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 General Public
-#  License as published by the Free Software Foundation; either
-#  version 2 of the License, or (at your option) any later version.
+#   Copyright 2011 Bryan Kearney <bkearney@redhat.com>
 #
-#  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
-#  General Public License for more details.
+#   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
 #
-#  You should have received a copy of the GNU 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
+#       http://www.apache.org/licenses/LICENSE-2.0
 #
-# Author: Bryan Kearney <bkearney@redhat.com>
+#   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'
@@ -32,10 +28,14 @@ Puppet::Type.type(:augeas).provide(:augeas) do
 
   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],
@@ -46,6 +46,7 @@ Puppet::Type.type(:augeas).provide(:augeas) do
 
   COMMANDS["ins"] = COMMANDS["insert"]
   COMMANDS["remove"] = COMMANDS["rm"]
+  COMMANDS["move"] = COMMANDS["mv"]
 
   attr_accessor :aug
 
@@ -213,7 +214,12 @@ Puppet::Type.type(:augeas).provide(:augeas) do
       fail("Invalid command: #{cmd_array.join(" ")}") if clause_array.length != 2
       comparator = clause_array.shift
       arg = clause_array.shift
-      return_value = (result.size.send(comparator, arg))
+      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)
@@ -329,6 +335,10 @@ Puppet::Type.type(:augeas).provide(:augeas) do
             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])
@@ -349,6 +359,18 @@ Puppet::Type.type(:augeas).provide(:augeas) do
             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

data/lib/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/puppet/provider/cron/crontab.rb

@@ -11,13 +11,7 @@ tab = case Facter.value(:operatingsystem)
 
 
 
-      Puppet::Type.type(:cron).provide(
-        :crontab,
-  :parent => Puppet::Provider::ParsedFile,
-  :default_target => ENV["USER"] || "root",
-        
-  :filetype => tab
-) do
+Puppet::Type.type(:cron).provide(:crontab, :parent => Puppet::Provider::ParsedFile, :default_target => ENV["USER"] || "root", :filetype => tab) do
   commands :crontab => "crontab"
 
   text_line :comment, :match => %r{^#}, :post_parse => proc { |record|

data/lib/puppet/provider/exec/posix.rb

@@ -4,12 +4,9 @@ Puppet::Type.type(:exec).provide :posix do
   confine :feature => :posix
   defaultfor :feature => :posix
 
-  desc <<-EOT
-    Executes external binaries directly, without passing through a shell or
-    performing any interpolation. This is a safer and more predictable way
-    to execute most commands, but prevents the use of globbing and shell
-    built-ins (including control logic like "for" and "if" statements).
-  EOT
+  desc "Execute external binaries directly, on POSIX systems.
+This does not pass through a shell, or perform any interpolation, but
+only directly calls the command with the arguments given."
 
   def run(command, check = false)
     output = nil

data/lib/puppet/provider/exec/shell.rb

@@ -3,17 +3,8 @@ Puppet::Type.type(:exec).provide :shell, :parent => :posix do
 
   confine :feature => :posix
 
-  desc <<-EOT
-    Passes the provided command through `/bin/sh`; only available on
-    POSIX systems. This allows the use of shell globbing and built-ins, and
-    does not require that the path to a command be fully-qualified. Although
-    this can be more convenient than the `posix` provider, it also means that
-    you need to be more careful with escaping; as ever, with great power comes
-    etc. etc.
-
-    This provider closely resembles the behavior of the `exec` type
-    in Puppet 0.25.x.
-  EOT
+  desc "Execute external binaries directly, on POSIX systems.
+passing through a shell so that shell built ins are available."
 
   def run(command, check = false)
     command = %Q{/bin/sh -c "#{command.gsub(/"/,'\"')}"}

data/lib/puppet/provider/file/posix.rb

@@ -54,7 +54,7 @@ Puppet::Type.type(:file).provide :posix do
   end
 
   def retrieve(resource)
-    unless stat = resource.stat(false)
+    unless stat = resource.stat
       return :absent
     end
 

data/lib/puppet/provider/file/win32.rb

@@ -49,7 +49,7 @@ Puppet::Type.type(:file).provide :microsoft_windows do
   end
 
   def retrieve(resource)
-    unless stat = resource.stat(false)
+    unless stat = resource.stat
       return :absent
     end
 

data/lib/puppet/provider/group/aix.rb

@@ -0,0 +1,141 @@
+#
+# Group Puppet provider for AIX. It uses standard commands to manage groups:
+#  mkgroup, rmgroup, lsgroup, chgroup
+#
+# Author::    Hector Rivas Gandara <keymon@gmail.com>
+#  
+require 'puppet/provider/aixobject'
+
+Puppet::Type.type(:group).provide :aix, :parent => Puppet::Provider::AixObject do
+  desc "Group management for AIX! Users are managed with mkgroup, rmgroup, lsgroup, chgroup"
+
+  # This will the the default provider for this platform
+  defaultfor :operatingsystem => :aix
+  confine :operatingsystem => :aix
+
+  # Provider features
+  has_features :manages_aix_lam
+  has_features :manages_members
+
+  # Commands that manage the element
+  commands :list      => "/usr/sbin/lsgroup"
+  commands :add       => "/usr/bin/mkgroup"
+  commands :delete    => "/usr/sbin/rmgroup"
+  commands :modify    => "/usr/bin/chgroup"
+
+  # Group attributes to ignore
+  def self.attribute_ignore
+    []
+  end
+
+  # AIX attributes to properties mapping.
+  # 
+  # Valid attributes to be managed by this provider.
+  # It is a list with of hash
+  #  :aix_attr      AIX command attribute name
+  #  :puppet_prop   Puppet propertie name
+  #  :to            Method to adapt puppet property to aix command value. Optional.
+  #  :from          Method to adapt aix command value to puppet property. Optional
+  self.attribute_mapping = [
+    #:name => :name,
+    {:aix_attr => :id,       :puppet_prop => :gid },
+    {:aix_attr => :users,    :puppet_prop => :members,
+      :from => :users_from_attr},
+    {:aix_attr => :attributes, :puppet_prop => :attributes},
+  ]
+  
+  #--------------
+  # Command definition
+  
+  # Return the IA module arguments based on the resource param ia_load_module
+  def get_ia_module_args
+    if @resource[:ia_load_module]
+      ["-R", @resource[:ia_load_module].to_s]
+    else
+      []
+    end
+  end
+  
+  def lscmd(value=@resource[:name])
+    [self.class.command(:list)] +
+      self.get_ia_module_args +
+      [ value]
+  end
+
+  def lsallcmd()
+    lscmd("ALL")
+  end
+
+  def addcmd(extra_attrs = [])
+    # Here we use the @resource.to_hash to get the list of provided parameters
+    # Puppet does not call to self.<parameter>= method if it does not exists.
+    #
+    # It gets an extra list of arguments to add to the user.
+    [self.class.command(:add) ] +
+      self.get_ia_module_args +
+      self.hash2args(@resource.to_hash) +
+      extra_attrs + [@resource[:name]]
+  end
+
+  def modifycmd(hash = property_hash)
+    args = self.hash2args(hash)
+    return nil if args.empty?
+    
+    [self.class.command(:modify)] +
+      self.get_ia_module_args +
+      args + [@resource[:name]]
+  end
+
+  def deletecmd
+    [self.class.command(:delete)] +
+      self.get_ia_module_args +
+      [@resource[:name]]
+  end
+
+
+  #--------------
+  # Overwrite get_arguments to add the attributes arguments
+  def get_arguments(key, value, mapping, objectinfo)
+    # In the case of attributes, return a list of key=vlaue
+    if key == :attributes
+      raise Puppet::Error, "Attributes must be a list of pairs key=value on #{@resource.class.name}[#{@resource.name}]" \
+        unless value and value.is_a? Hash
+      return value.select { |k,v| true }.map { |pair| pair.join("=") }
+    end
+    super(key, value, mapping, objectinfo)
+  end
+
+  def filter_attributes(hash)
+    # Return only not managed attributtes.
+    hash.select {
+        |k,v| !self.class.attribute_mapping_from.include?(k) and
+                !self.class.attribute_ignore.include?(k)
+      }.inject({}) {
+        |hash, array| hash[array[0]] = array[1]; hash
+      }
+  end
+
+  def attributes
+    filter_attributes(getosinfo(refresh = false))
+  end
+
+  def attributes=(attr_hash)
+    #self.class.validate(param, value)
+    param = :attributes
+    cmd = modifycmd({param => filter_attributes(attr_hash)})
+    if cmd 
+      begin
+        execute(cmd)
+      rescue Puppet::ExecutionFailure  => detail
+        raise Puppet::Error, "Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}"
+      end
+    end
+  end
+
+  # Force convert users it a list.
+  def users_from_attr(value)
+    (value.is_a? String) ? value.split(',') : value
+  end
+
+
+end

data/lib/puppet/provider/group/directoryservice.rb

@@ -1,17 +1,3 @@
-#  Created by Jeff McCune on 2007-07-22
-#  Copyright (c) 2007. All rights reserved.
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation (version 2 of the License)
-# This program 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 General Public License for more details.
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston MA  02110-1301 USA
-
 require 'puppet/provider/nameservice/directoryservice'
 
 Puppet::Type.type(:group).provide :directoryservice, :parent => Puppet::Provider::NameService::DirectoryService do

data/lib/puppet/provider/host/parsed.rb

@@ -8,66 +8,34 @@ else
 end
 
 
-      Puppet::Type.type(:host).provide(
-        :parsed,
-  :parent => Puppet::Provider::ParsedFile,
-  :default_target => hosts,
-        
-  :filetype => :flat
-) do
+Puppet::Type.type(:host).provide(:parsed,:parent => Puppet::Provider::ParsedFile,
+  :default_target => hosts,:filetype => :flat) do
   confine :exists => hosts
 
   text_line :comment, :match => /^#/
   text_line :blank, :match => /^\s*$/
 
-  record_line :parsed, :fields => %w{ip name host_aliases},
-    :optional => %w{host_aliases},
-    :rts => true do |line|
-    hash = {}
-    if line.sub!(/^(\S+)\s+(\S+)\s*/, '')
-      hash[:ip] = $1
-      hash[:name] = $2
-
-      if line.empty?
-        hash[:host_aliases] = []
-      else
-        line.sub!(/\s*/, '')
-        line.sub!(/^([^#]+)\s*/) do |value|
-          aliases = $1
-          unless aliases =~ /^\s*$/
-            hash[:host_aliases] = aliases.split(/\s+/)
-          end
-
-          ""
-        end
+  record_line :parsed, :fields => %w{ip name host_aliases comment},
+    :optional => %w{host_aliases comment},
+    :match    => /^(\S+)\s+(\S+)\s*(.*?)?(?:\s*#\s*(.*))?$/,
+    :post_parse => proc { |hash|
+      # An absent comment should match "comment => ''"
+      hash[:comment] = '' if hash[:comment].nil? or hash[:comment] == :absent
+      unless hash[:host_aliases].nil? or hash[:host_aliases] == :absent
+        hash[:host_aliases].gsub!(/\s+/,' ') # Change delimiter
       end
-    else
-      raise Puppet::Error, "Could not match '#{line}'"
-    end
-
-    hash[:host_aliases] = [] if hash[:host_aliases] == ""
-
-    return hash
-  end
-
-  # Convert the current object into a host-style string.
-  def self.to_line(hash)
-    return super unless hash[:record_type] == :parsed
-    [:ip, :name].each do |n|
-      raise ArgumentError, "#{n} is a required attribute for hosts" unless hash[n] and hash[n] != :absent
-    end
-
-    str = "#{hash[:ip]}\t#{hash[:name]}"
-
-    if hash.include? :host_aliases and !hash[:host_aliases].empty?
-      if hash[:host_aliases].is_a? Array
-        str += "\t#{hash[:host_aliases].join("\t")}"
-      else
-        raise ArgumentError, "Host aliases must be specified as an array"
+    },
+    :to_line  => proc { |hash|
+      [:ip, :name].each do |n|
+        raise ArgumentError, "#{n} is a required attribute for hosts" unless hash[n] and hash[n] != :absent
       end
-    end
-
-    str
-  end
+      str = "#{hash[:ip]}\t#{hash[:name]}"
+      if hash.include? :host_aliases and !hash[:host_aliases].nil? and hash[:host_aliases] != :absent
+        str += "\t#{hash[:host_aliases]}"
+      end
+      if hash.include? :comment and !hash[:comment].empty?
+        str += "\t# #{hash[:comment]}"
+      end
+      str
+    }
 end
-

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

@@ -0,0 +1,27 @@
+require 'puppet/provider/cisco'
+
+Puppet::Type.type(:interface).provide :cisco, :parent => Puppet::Provider::Cisco do
+
+  desc "Cisco switch/router provider for interface."
+
+  mk_resource_methods
+
+  def self.lookup(device, name)
+    interface = nil
+    device.command do |ng|
+      interface = device.interface(name)
+    end
+    interface
+  end
+
+  def initialize(device, *args)
+    super
+  end
+
+  def flush
+    device.command do |device|
+      device.new_interface(name).update(former_properties, properties)
+    end
+    super
+  end
+end