RubyGems - bolt - Versions diffs - 0.24.0 → 0.25.0 - Mend

bolt 0.24.0 → 0.25.0

Potentially problematic release.

This version of bolt might be problematic. Click here for more details.

Files changed (1155) hide show

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

@@ -1,82 +0,0 @@
-# Group Puppet provider for AIX. It uses standard commands to manage groups:
-#  mkgroup, rmgroup, lsgroup, chgroup
-require 'puppet/provider/aix_object'
-Puppet::Type.type(:group).provide :aix, :parent => Puppet::Provider::AixObject do
-  desc "Group management for AIX."
-  # This will the default provider for this platform
-  defaultfor :operatingsystem => :aix
-  confine :operatingsystem => :aix
-  # 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"
-  # Provider features
-  has_features :manages_aix_lam
-  has_features :manages_members
-  class << self
-    # Used by the AIX user provider. Returns a hash of:
-    #   {
-    #     :name => <group_name>,
-    #     :gid  => <gid>
-    #   }
-    #
-    # that matches the group, which can either be the group name or
-    # the gid. Takes an optional set of ia_module_args
-    def find(group, ia_module_args = [])
-      groups = list_all(ia_module_args)
-      id_property = mappings[:puppet_property][:id]
-      if group.is_a?(String)
-        # Find by name
-        group_hash = groups.find { |cur_group| cur_group[:name] == group }
-      else
-        # Find by gid
-        group_hash = groups.find do |cur_group|
-          id_property.convert_attribute_value(cur_group[:id]) == group
-        end
-      end
-      unless group_hash
-        raise ArgumentError, _("No AIX group exists with a group name or gid of %{group}!") % { group: group }
-      end
-      # Convert :id => :gid
-      id = group_hash.delete(:id)
-      group_hash[:gid] = id_property.convert_attribute_value(id)
-      group_hash
-    end
-    # Define some Puppet Property => AIX Attribute (and vice versa)
-    # conversion functions here. This is so we can unit test them.
-    def members_to_users(members)
-      return members unless members.is_a?(Array)
-      members.join(',')
-    end
-    def users_to_members(users)
-      users.split(',')
-    end
-  end
-  mapping puppet_property: :members,
-          aix_attribute: :users,
-          property_to_attribute: method(:members_to_users),
-          attribute_to_property: method(:users_to_members)
-  numeric_mapping puppet_property: :gid,
-                  aix_attribute: :id
-  # Now that we have all of our mappings, let's go ahead and make
-  # the resource methods (property getters + setters for our mapped
-  # properties + a getter for the attributes property).
-  mk_resource_methods
-end

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

@@ -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 DELETED

@@ -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 DELETED

@@ -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 DELETED

@@ -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 DELETED

@@ -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/ldap.rb DELETED

@@ -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