puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/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."
+
+  # 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/vendor/puppet/provider/group/directoryservice.rb

@@ -0,0 +1,12 @@
+require 'puppet/provider/nameservice/directoryservice'
+
+Puppet::Type.type(:group).provide :directoryservice, :parent => Puppet::Provider::NameService::DirectoryService do
+  desc "Group management using DirectoryService on OS X.
+
+  "
+
+  commands :dscl => "/usr/bin/dscl"
+  confine :operatingsystem => :darwin
+  defaultfor :operatingsystem => :darwin
+  has_feature :manages_members
+end

data/lib/vendor/puppet/provider/group/groupadd.rb

@@ -0,0 +1,29 @@
+require 'puppet/provider/nameservice/objectadd'
+
+Puppet::Type.type(:group).provide :groupadd, :parent => Puppet::Provider::NameService::ObjectAdd do
+  desc "Group management via `groupadd` and its ilk. The default for most platforms.
+
+  "
+
+  commands :add => "groupadd", :delete => "groupdel", :modify => "groupmod"
+
+  has_feature :system_groups unless %w{HP-UX Solaris}.include? Facter.value(:operatingsystem)
+
+  verify :gid, "GID must be an integer" do |value|
+    value.is_a? Integer
+  end
+
+  def addcmd
+    cmd = [command(:add)]
+    if gid = @resource.should(:gid)
+      unless gid == :absent
+        cmd << flag(:gid) << gid
+      end
+    end
+    cmd << "-o" if @resource.allowdupe?
+    cmd << "-r" if @resource.system? and self.class.system_groups?
+    cmd << @resource[:name]
+
+    cmd
+  end
+end

data/lib/vendor/puppet/provider/group/ldap.rb

@@ -0,0 +1,45 @@
+require 'puppet/provider/ldap'
+
+Puppet::Type.type(:group).provide :ldap, :parent => Puppet::Provider::Ldap do
+  desc "Group management via LDAP.
+
+    This provider requires that you have valid values for all of the
+    LDAP-related settings in `puppet.conf`, including `ldapbase`.  You will
+    almost definitely need settings for `ldapuser` and `ldappassword` in order
+    for your clients to write to LDAP.
+
+    Note that this provider will automatically generate a GID for you if you do
+    not specify one, but it is a potentially expensive operation, as it
+    iterates across all existing groups to pick the appropriate next one."
+
+  confine :feature => :ldap, :false => (Puppet[:ldapuser] == "")
+
+  # We're mapping 'members' here because we want to make it
+  # easy for the ldap user provider to manage groups.  This
+  # way it can just use the 'update' method in the group manager,
+  # whereas otherwise it would need to replicate that code.
+  manages(:posixGroup).at("ou=Groups").and.maps :name => :cn, :gid => :gidNumber, :members => :memberUid
+
+  # Find the next gid after the current largest gid.
+  provider = self
+  manager.generates(:gidNumber).with do
+    largest = 500
+    if existing = provider.manager.search
+        existing.each do |hash|
+        next unless value = hash[:gid]
+        num = value[0].to_i
+        largest = num if num > largest
+      end
+    end
+    largest + 1
+  end
+
+  # Convert a group name to an id.
+  def self.name2id(group)
+    return nil unless result = manager.search("cn=#{group}") and result.length > 0
+
+    # Only use the first result.
+    group = result[0]
+    gid = group[:gid][0]
+  end
+end

data/lib/vendor/puppet/provider/group/pw.rb

@@ -0,0 +1,48 @@
+require 'puppet/provider/nameservice/pw'
+
+Puppet::Type.type(:group).provide :pw, :parent => Puppet::Provider::NameService::PW do
+  desc "Group management via `pw` on FreeBSD."
+
+  commands :pw => "pw"
+  has_features :manages_members
+
+  defaultfor :operatingsystem => :freebsd
+
+  options :members, :flag => "-M", :method => :mem
+
+  verify :gid, "GID must be an integer" do |value|
+    value.is_a? Integer
+  end
+
+  def addcmd
+    cmd = [command(:pw), "groupadd", @resource[:name]]
+
+    if gid = @resource.should(:gid)
+      unless gid == :absent
+        cmd << flag(:gid) << gid
+      end
+    end
+
+    if members = @resource.should(:members)
+      unless members == :absent
+        if members.is_a?(Array)
+          members = members.join(",")
+        end
+        cmd << "-M" << members
+      end
+    end
+
+    cmd << "-o" if @resource.allowdupe?
+
+    cmd
+  end
+
+  def modifycmd(param, value)
+    # members may be an array, need a comma separated list
+    if param == :members and value.is_a?(Array)
+      value = value.join(",")
+    end
+    super(param, value)
+  end
+end
+

data/lib/vendor/puppet/provider/group/windows_adsi.rb

@@ -0,0 +1,54 @@
+require 'puppet/util/adsi'
+
+Puppet::Type.type(:group).provide :windows_adsi do
+  desc "Local group management for Windows. Nested groups are not supported."
+
+  defaultfor :operatingsystem => :windows
+  confine    :operatingsystem => :windows
+
+  has_features :manages_members
+
+  def group
+    @group ||= Puppet::Util::ADSI::Group.new(@resource[:name])
+  end
+
+  def members
+    group.members
+  end
+
+  def members=(members)
+    group.set_members(members)
+  end
+
+  def create
+    @group = Puppet::Util::ADSI::Group.create(@resource[:name])
+    @group.commit
+
+    self.members = @resource[:members]
+  end
+
+  def exists?
+    Puppet::Util::ADSI::Group.exists?(@resource[:name])
+  end
+
+  def delete
+    Puppet::Util::ADSI::Group.delete(@resource[:name])
+  end
+
+  # Only flush if we created or modified a group, not deleted
+  def flush
+    @group.commit if @group
+  end
+
+  def gid
+    Puppet::Util::Windows::Security.name_to_sid(@resource[:name])
+  end
+
+  def gid=(value)
+    fail "gid is read-only"
+  end
+
+  def self.instances
+    Puppet::Util::ADSI::Group.map { |g| new(:ensure => :present, :name => g.name) }
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'puppet/provider/parsedfile'
+
+hosts = nil
+case Facter.value(:operatingsystem)
+when "Solaris"; hosts = "/etc/inet/hosts"
+when "windows"
+  require 'win32/resolv'
+  hosts = Win32::Resolv.get_hosts_path
+else
+  hosts = "/etc/hosts"
+end
+
+
+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 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
+    },
+    :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
+      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/vendor/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

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

@@ -0,0 +1,137 @@
+require 'puppet/provider'
+
+# The base class for LDAP providers.
+class Puppet::Provider::Ldap < Puppet::Provider
+  require 'puppet/util/ldap/manager'
+
+  class << self
+    attr_reader :manager
+  end
+
+  # Look up all instances at our location.  Yay.
+  def self.instances
+    return [] unless list = manager.search
+
+    list.collect { |entry| new(entry) }
+  end
+
+  # Specify the ldap manager for this provider, which is
+  # used to figure out how we actually interact with ldap.
+  def self.manages(*args)
+    @manager = Puppet::Util::Ldap::Manager.new
+    @manager.manages(*args)
+
+    # Set up our getter/setter methods.
+    mk_resource_methods
+    @manager
+  end
+
+  # Query all of our resources from ldap.
+  def self.prefetch(resources)
+    resources.each do |name, resource|
+      if result = manager.find(name)
+        result[:ensure] = :present
+        resource.provider = new(result)
+      else
+        resource.provider = new(:ensure => :absent)
+      end
+    end
+  end
+
+  def manager
+    self.class.manager
+  end
+
+  def create
+    @property_hash[:ensure] = :present
+    self.class.resource_type.validproperties.each do |property|
+      if val = resource.should(property)
+        if property.to_s == 'gid'
+          self.gid = val
+        else
+          @property_hash[property] = val
+        end
+      end
+    end
+  end
+
+  def delete
+    @property_hash[:ensure] = :absent
+  end
+
+  def exists?
+    @property_hash[:ensure] != :absent
+  end
+
+  # Apply our changes to ldap, yo.
+  def flush
+    # Just call the manager's update() method.
+    @property_hash.delete(:groups)
+    @ldap_properties.delete(:groups)
+    manager.update(name, ldap_properties, properties)
+    @property_hash.clear
+    @ldap_properties.clear
+  end
+
+  def initialize(*args)
+    raise(Puppet::DevError, "No LDAP Configuration defined for #{self.class}") unless self.class.manager
+    raise(Puppet::DevError, "Invalid LDAP Configuration defined for #{self.class}") unless self.class.manager.valid?
+    super
+
+    @property_hash = @property_hash.inject({}) do |result, ary|
+      param, values = ary
+
+      # Skip any attributes we don't manage.
+      next result unless self.class.resource_type.valid_parameter?(param)
+
+      paramclass = self.class.resource_type.attrclass(param)
+
+      unless values.is_a?(Array)
+        result[param] = values
+        next result
+      end
+
+      # Only use the first value if the attribute class doesn't manage
+      # arrays of values.
+      if paramclass.superclass == Puppet::Parameter or paramclass.array_matching == :first
+        result[param] = values[0]
+      else
+        result[param] = values
+      end
+      result
+    end
+
+    # Make a duplicate, so that we have a copy for comparison
+    # at the end.
+    @ldap_properties = @property_hash.dup
+  end
+
+  # Return the current state of ldap.
+  def ldap_properties
+    @ldap_properties.dup
+  end
+
+  # Return (and look up if necessary) the desired state.
+  def properties
+    if @property_hash.empty?
+      @property_hash = query || {:ensure => :absent}
+      @property_hash[:ensure] = :absent if @property_hash.empty?
+    end
+    @property_hash.dup
+  end
+
+  # Collect the current attributes from ldap.  Returns
+  # the results, but also stores the attributes locally,
+  # so we have something to compare against when we update.
+  # LAK:NOTE This is normally not used, because we rely on prefetching.
+  def query
+    # Use the module function.
+    unless attributes = manager.find(name)
+      @ldap_properties = {}
+      return nil
+    end
+
+    @ldap_properties = attributes
+    @ldap_properties.dup
+  end
+end