bolt 0.19.1 → 0.20.0

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

@@ -1,22 +0,0 @@
-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
-
-  def members_insync?(current, should)
-    return false unless current
-    if current == :absent
-      return should.empty?
-    else
-      return current.sort.uniq == should.sort.uniq
-    end
-  end
-
-end

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

@@ -1,111 +0,0 @@
-require 'puppet/provider/nameservice/objectadd'
-require 'puppet/util/libuser'
-
-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
-
-  optional_commands :localadd => "lgroupadd", :localdelete => "lgroupdel", :localmodify => "lgroupmod"
-
-  has_feature :libuser if Puppet.features.libuser?
-
-  def exists?
-    return !!localgid if @resource.forcelocal?
-    super
-  end
-
-  def gid
-    return localgid if @resource.forcelocal?
-    get(:gid)
-  end
-
-  def findgroup(key, value)
-    group_file = "/etc/group"
-    group_keys = ['group_name', 'password', 'gid', 'user_list']
-    index = group_keys.index(key)
-    File.open(group_file) do |f|
-      f.each_line do |line|
-         group = line.split(":")
-         if group[index] == value
-             f.close
-             return group
-         end
-      end
-    end
-    false
-  end
-
-  def localgid
-    group = findgroup('group_name', resource[:name])
-    return group[2] if group
-    false
-  end
-
-  def check_allow_dup
-    # We have to manually check for duplicates when using libuser
-    # because by default duplicates are allowed.  This check is
-    # to ensure consistent behaviour of the useradd provider when
-    # using both useradd and luseradd
-    if not @resource.allowdupe? and @resource.forcelocal?
-       if @resource.should(:gid) and findgroup('gid', @resource.should(:gid).to_s)
-           raise(Puppet::Error, _("GID %{resource} already exists, use allowdupe to force group creation") % { resource: @resource.should(:gid).to_s })
-       end
-    elsif @resource.allowdupe? and not @resource.forcelocal?
-       return ["-o"]
-    end
-    []
-  end
-
-  def addcmd
-    if @resource.forcelocal?
-      cmd = [command(:localadd)]
-      @custom_environment = Puppet::Util::Libuser.getenv
-    else
-      cmd = [command(:add)]
-    end
-
-    if gid = @resource.should(:gid)
-      unless gid == :absent
-        cmd << flag(:gid) << gid
-      end
-    end
-    cmd += check_allow_dup
-    cmd << "-r" if @resource.system? and self.class.system_groups?
-    cmd << @resource[:name]
-    cmd
-  end
-
-  def modifycmd(param, value)
-    if @resource.forcelocal?
-      cmd = [command(:localmodify)]
-      @custom_environment = Puppet::Util::Libuser.getenv
-    else
-      cmd = [command(:modify)]
-    end
-    cmd << flag(param) << value
-    # TODO the group type only really manages gid, so there are currently no
-    # tests for this behavior
-    cmd += check_allow_dup if param == :gid
-    cmd << @resource[:name]
-
-    cmd
-  end
-
-  def deletecmd
-    if @resource.forcelocal?
-      @custom_environment = Puppet::Util::Libuser.getenv
-      [command(:localdelete), @resource[:name]]
-    else
-      [command(:delete), @resource[:name]]
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-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]
-    group[:gid][0]
-  end
-end

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

@@ -1,49 +0,0 @@
-require 'puppet/provider/nameservice/pw'
-
-Puppet::Type.type(:group).provide :pw, :parent => Puppet::Provider::NameService::PW do
-  desc "Group management via `pw` on FreeBSD and DragonFly BSD."
-
-  commands :pw => "pw"
-  has_features :manages_members
-
-  defaultfor :operatingsystem => [:freebsd, :dragonfly]
-  confine    :operatingsystem => [:freebsd, :dragonfly]
-
-  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/vendored/puppet/lib/puppet/provider/group/windows_adsi.rb

@@ -1,106 +0,0 @@
-require 'puppet/util/windows'
-
-Puppet::Type.type(:group).provide :windows_adsi do
-  desc "Local group management for Windows. Group members can be both users and groups.
-    Additionally, local groups can contain domain users."
-
-  defaultfor :operatingsystem => :windows
-  confine    :operatingsystem => :windows
-
-  has_features :manages_members
-
-  def initialize(value={})
-    super(value)
-    @deleted = false
-  end
-
-  def members_insync?(current, should)
-    return false unless current
-
-    # By comparing account SIDs we don't have to worry about case
-    # sensitivity, or canonicalization of account names.
-
-    # Cannot use munge of the group property to canonicalize @should
-    # since the default array_matching comparison is not commutative
-
-    current_sids = current.map(&:sid)
-    # dupes automatically weeded out when hashes built
-    specified_sids = Puppet::Util::Windows::ADSI::Group.name_sid_hash(should).keys.to_a
-
-    if @resource[:auth_membership]
-      current_sids.sort == specified_sids.sort
-    else
-      (specified_sids & current_sids) == specified_sids
-    end
-  end
-
-  def members_to_s(users)
-    return '' if users.nil? or !users.kind_of?(Array)
-    users = users.map do |user_name|
-      sid = Puppet::Util::Windows::SID.name_to_principal(user_name)
-      if !sid
-        resource.debug("#{user_name} (unresolvable to SID)")
-        next user_name
-      end
-
-      if sid.account =~ /\\/
-        account, _ = Puppet::Util::Windows::ADSI::User.parse_name(sid.account)
-      else
-        account = sid.account
-      end
-      resource.debug("#{sid.domain}\\#{account} (#{sid.sid})")
-      "#{sid.domain}\\#{account}"
-    end
-    return users.join(',')
-  end
-
-  def member_valid?(user_name)
-    ! Puppet::Util::Windows::SID.name_to_principal(user_name).nil?
-  end
-
-  def group
-    @group ||= Puppet::Util::Windows::ADSI::Group.new(@resource[:name])
-  end
-
-  def members
-    group.members
-  end
-
-  def members=(members)
-    group.set_members(members, @resource[:auth_membership])
-  end
-
-  def create
-    @group = Puppet::Util::Windows::ADSI::Group.create(@resource[:name])
-    @group.commit
-
-    self.members = @resource[:members]
-  end
-
-  def exists?
-    Puppet::Util::Windows::ADSI::Group.exists?(@resource[:name])
-  end
-
-  def delete
-    Puppet::Util::Windows::ADSI::Group.delete(@resource[:name])
-
-    @deleted = true
-  end
-
-  # Only flush if we created or modified a group, not deleted
-  def flush
-    @group.commit if @group && !@deleted
-  end
-
-  def gid
-    Puppet::Util::Windows::SID.name_to_sid(@resource[:name])
-  end
-
-  def gid=(value)
-    fail "gid is read-only"
-  end
-
-  def self.instances
-    Puppet::Util::Windows::ADSI::Group.map { |g| new(:ensure => :present, :name => g.name) }
-  end
-end

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

@@ -1,46 +0,0 @@
-require 'puppet/provider/parsedfile'
-
-hosts = nil
-case Facter.value(:osfamily)
-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*$/
-  hosts_pattern = '^([0-9a-f:]\S+)\s+([^#\s+]\S+)\s*(.*?)?(?:\s*#\s*(.*))?$'
-  record_line :parsed, :fields => %w{ip name host_aliases comment},
-    :optional => %w{host_aliases comment},
-    :match    => /#{hosts_pattern}/,
-    :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, _("%{attr} is a required attribute for hosts") % { attr: n } 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
-    }
-
-  text_line :incomplete, :match => /(?! (#{hosts_pattern}))/
-end

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

@@ -1,27 +0,0 @@
-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 |dev|
-      interface = dev.interface(name)
-    end
-    interface
-  end
-
-  def initialize(device, *args)
-    super
-  end
-
-  def flush
-    device.command do |dev|
-      dev.new_interface(name).update(former_properties, properties)
-    end
-    super
-  end
-end

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

@@ -1,137 +0,0 @@
-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 %{class_name}") % { class_name: self.class }) unless self.class.manager
-    raise(Puppet::DevError, _("Invalid LDAP Configuration defined for %{class_name}") % { class_name: 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