bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/provider/user/useradd.rb

@@ -1,265 +0,0 @@
-require 'puppet/provider/nameservice/objectadd'
-require 'date'
-require 'puppet/util/libuser'
-require 'time'
-require 'puppet/error'
-
-Puppet::Type.type(:user).provide :useradd, :parent => Puppet::Provider::NameService::ObjectAdd do
-  desc "User management via `useradd` and its ilk.  Note that you will need to
-    install Ruby's shadow password library (often known as `ruby-libshadow`)
-    if you wish to manage user passwords."
-
-  commands :add => "useradd", :delete => "userdel", :modify => "usermod", :password => "chage"
-
-  options :home, :flag => "-d", :method => :dir
-  options :comment, :method => :gecos
-  options :groups, :flag => "-G"
-  options :password_min_age, :flag => "-m", :method => :sp_min
-  options :password_max_age, :flag => "-M", :method => :sp_max
-  options :password_warn_days, :flag => "-W", :method => :sp_warn
-  options :password, :method => :sp_pwdp
-  options :expiry, :method => :sp_expire,
-    :munge => proc { |value|
-      if value == :absent
-        ''
-      else
-        case Facter.value(:operatingsystem)
-        when 'Solaris'
-          # Solaris uses %m/%d/%Y for useradd/usermod
-          expiry_year, expiry_month, expiry_day = value.split('-')
-          [expiry_month, expiry_day, expiry_year].join('/')
-        else
-          value
-        end
-      end
-    },
-    :unmunge => proc { |value|
-      if value == -1
-        :absent
-      else
-        # Expiry is days after 1970-01-01
-        (Date.new(1970,1,1) + value).strftime('%Y-%m-%d')
-      end
-    }
-
-  optional_commands :localadd => "luseradd", :localdelete => "luserdel", :localmodify => "lusermod", :localpassword => "lchage"
-  has_feature :libuser if Puppet.features.libuser?
-
-  def exists?
-    return !!localuid if @resource.forcelocal?
-    super
-  end
-
-  def uid
-     return localuid if @resource.forcelocal?
-     get(:uid)
-  end
-
-  def finduser(key, value)
-    passwd_file = "/etc/passwd"
-    passwd_keys = ['account', 'password', 'uid', 'gid', 'gecos', 'directory', 'shell']
-    index = passwd_keys.index(key)
-    File.open(passwd_file) do |f|
-      f.each_line do |line|
-         user = line.split(":")
-         if user[index] == value
-             f.close
-             return user
-         end
-      end
-    end
-    false
-  end
-
-  def local_username
-    finduser('uid', @resource.uid)
-  end
-
-  def localuid
-    user = finduser('account', resource[:name])
-    return user[2] if user
-    false
-  end
-
-  def shell=(value)
-    check_valid_shell
-    set("shell", value)
-  end
-
-  verify :gid, "GID must be an integer" do |value|
-    value.is_a? Integer
-  end
-
-  verify :groups, "Groups must be comma-separated" do |value|
-    value !~ /\s/
-  end
-
-  has_features :manages_homedir, :allows_duplicates, :manages_expiry
-  has_features :system_users unless %w{HP-UX Solaris}.include? Facter.value(:operatingsystem)
-
-  has_features :manages_passwords, :manages_password_age if Puppet.features.libshadow?
-  has_features :manages_shell
-
-  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(:uid) and finduser('uid', @resource.should(:uid).to_s)
-           raise(Puppet::Error, "UID #{@resource.should(:uid).to_s} already exists, use allowdupe to force user creation")
-       end
-    elsif @resource.allowdupe? and not @resource.forcelocal?
-       return ["-o"]
-    end
-    []
-  end
-
-  def check_valid_shell
-    unless File.exists?(@resource.should(:shell))
-      raise(Puppet::Error, "Shell #{@resource.should(:shell)} must exist")
-    end
-    unless File.executable?(@resource.should(:shell).to_s)
-      raise(Puppet::Error, "Shell #{@resource.should(:shell)} must be executable")
-    end
-  end
-
-  def check_manage_home
-    cmd = []
-    if @resource.managehome? and not @resource.forcelocal?
-      cmd << "-m"
-    elsif not @resource.managehome? and Facter.value(:osfamily) == 'RedHat'
-      cmd << "-M"
-    end
-    cmd
-  end
-
-  def check_manage_expiry
-    cmd = []
-    if @resource[:expiry] and not @resource.forcelocal?
-      cmd << "-e #{@resource[:expiry]}"
-    end
-
-    cmd
-  end
-
-  def check_system_users
-    if self.class.system_users? and resource.system?
-      ["-r"]
-    else
-      []
-    end
-  end
-
-  def add_properties
-    cmd = []
-    # validproperties is a list of properties in undefined order
-    # sort them to have a predictable command line in tests
-    Puppet::Type.type(:user).validproperties.sort.each do |property|
-      next if property == :ensure
-      next if property_manages_password_age?(property)
-      next if property == :groups and @resource.forcelocal?
-      next if property == :expiry and @resource.forcelocal?
-      # the value needs to be quoted, mostly because -c might
-      # have spaces in it
-      if value = @resource.should(property) and value != ""
-        cmd << flag(property) << munge(property, value)
-      end
-    end
-    cmd
-  end
-
-  def addcmd
-    if @resource.forcelocal?
-      cmd = [command(:localadd)]
-      @custom_environment = Puppet::Util::Libuser.getenv
-    else
-      cmd = [command(:add)]
-    end
-    if not @resource.should(:gid) and Puppet::Util.gid(@resource[:name])
-      cmd += ["-g", @resource[:name]]
-    end
-    cmd += add_properties
-    cmd += check_allow_dup
-    cmd += check_manage_home
-    cmd += check_system_users
-    cmd << @resource[:name]
-  end
-
-  def modifycmd(param, value)
-    if @resource.forcelocal?
-      if param == :groups
-        cmd = [command(:modify)]
-      else
-        cmd = [command(property_manages_password_age?(param) ? :localpassword : :localmodify)]
-      end
-      @custom_environment = Puppet::Util::Libuser.getenv
-    else
-      cmd = [command(property_manages_password_age?(param) ? :password : :modify)]
-    end
-    cmd << flag(param) << value
-    cmd += check_allow_dup if param == :uid
-    cmd << @resource[:name]
-
-    cmd
-  end
-
-  def deletecmd
-    if @resource.forcelocal?
-      cmd = [command(:localdelete)]
-      @custom_environment = Puppet::Util::Libuser.getenv
-    else
-      cmd = [command(:delete)]
-    end
-    cmd += @resource.managehome? ? ['-r'] : []
-    cmd << @resource[:name]
-  end
-
-  def passcmd
-    if @resource.forcelocal?
-      cmd = command(:localpassword)
-      @custom_environment = Puppet::Util::Libuser.getenv
-    else
-      cmd = command(:password)
-    end
-    age_limits = [:password_min_age, :password_max_age, :password_warn_days].select { |property| @resource.should(property) }
-    if age_limits.empty?
-      nil
-    else
-      [cmd, age_limits.collect { |property| [flag(property), @resource.should(property)]}, @resource[:name]].flatten
-    end
-  end
-
-  [:expiry, :password_min_age, :password_max_age, :password_warn_days, :password].each do |shadow_property|
-    define_method(shadow_property) do
-      if Puppet.features.libshadow?
-        if ent = Shadow::Passwd.getspnam(@canonical_name)
-          method = self.class.option(shadow_property, :method)
-          return unmunge(shadow_property, ent.send(method))
-        end
-      end
-      :absent
-    end
-  end
-
-  def create
-    if @resource[:shell]
-      check_valid_shell
-    end
-     super
-     if @resource.forcelocal? and self.groups?
-       set(:groups, @resource[:groups])
-     end
-     if @resource.forcelocal? and @resource[:expiry]
-       set(:expiry, @resource[:expiry])
-     end
-  end
-
-  def groups?
-    !!@resource[:groups]
-  end
-
-  def property_manages_password_age?(property)
-    property.to_s =~ /password_.+_age|password_warn_days/
-  end
-end

data/vendored/puppet/lib/puppet/provider/user/windows_adsi.rb

@@ -1,148 +0,0 @@
-require 'puppet/util/windows'
-
-Puppet::Type.type(:user).provide :windows_adsi do
-  desc "Local user management for Windows."
-
-  defaultfor :operatingsystem => :windows
-  confine    :operatingsystem => :windows
-
-  has_features :manages_homedir, :manages_passwords
-
-  def initialize(value={})
-    super(value)
-    @deleted = false
-  end
-
-  def user
-    @user ||= Puppet::Util::Windows::ADSI::User.new(@resource[:name])
-  end
-
-  def groups
-    @groups ||= Puppet::Util::Windows::ADSI::Group.name_sid_hash(user.groups)
-    @groups.keys
-  end
-
-  def groups=(groups)
-    user.set_groups(groups, @resource[:membership] == :minimum)
-  end
-
-  def groups_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
-
-    # dupes automatically weeded out when hashes built
-    current_groups = Puppet::Util::Windows::ADSI::Group.name_sid_hash(current)
-    specified_groups = Puppet::Util::Windows::ADSI::Group.name_sid_hash(should)
-
-    current_sids = current_groups.keys.to_a
-    specified_sids = specified_groups.keys.to_a
-
-    if @resource[:membership] == :inclusive
-      current_sids.sort == specified_sids.sort
-    else
-      (specified_sids & current_sids) == specified_sids
-    end
-  end
-
-  def groups_to_s(groups)
-    return '' if groups.nil? || !groups.kind_of?(Array)
-    groups = groups.map do |group_name|
-      sid = Puppet::Util::Windows::SID.name_to_principal(group_name)
-      if sid.account =~ /\\/
-        account, _ = Puppet::Util::Windows::ADSI::Group.parse_name(sid.account)
-      else
-        account = sid.account
-      end
-      resource.debug("#{sid.domain}\\#{account} (#{sid.sid})")
-      "#{sid.domain}\\#{account}"
-    end
-    return groups.join(',')
-  end
-
-  def create
-    @user = Puppet::Util::Windows::ADSI::User.create(@resource[:name])
-    @user.password = @resource[:password]
-    @user.commit
-
-    [:comment, :home, :groups].each do |prop|
-      send("#{prop}=", @resource[prop]) if @resource[prop]
-    end
-
-    if @resource.managehome?
-      Puppet::Util::Windows::User.load_profile(@resource[:name], @resource[:password])
-    end
-  end
-
-  def exists?
-    Puppet::Util::Windows::ADSI::User.exists?(@resource[:name])
-  end
-
-  def delete
-    # lookup sid before we delete account
-    sid = uid if @resource.managehome?
-
-    Puppet::Util::Windows::ADSI::User.delete(@resource[:name])
-
-    if sid
-      Puppet::Util::Windows::ADSI::UserProfile.delete(sid)
-    end
-
-    @deleted = true
-  end
-
-  # Only flush if we created or modified a user, not deleted
-  def flush
-    @user.commit if @user && !@deleted
-  end
-
-  def comment
-    user['Description']
-  end
-
-  def comment=(value)
-    user['Description'] = value
-  end
-
-  def home
-    user['HomeDirectory']
-  end
-
-  def home=(value)
-    user['HomeDirectory'] = value
-  end
-
-  def password
-    # avoid a LogonUserW style password check when the resource is not yet
-    # populated with a password (as is the case with `puppet resource user`)
-    return nil if @resource[:password].nil?
-    user.password_is?( @resource[:password] ) ? @resource[:password] : nil
-  end
-
-  def password=(value)
-    user.password = value
-  end
-
-  def uid
-    Puppet::Util::Windows::SID.name_to_sid(@resource[:name])
-  end
-
-  def uid=(value)
-    fail "uid is read-only"
-  end
-
-  [:gid, :shell].each do |prop|
-    define_method(prop) { nil }
-    define_method("#{prop}=") do |v|
-      fail "No support for managing property #{prop} of user #{@resource[:name]} on Windows"
-    end
-  end
-
-  def self.instances
-    Puppet::Util::Windows::ADSI::User.map { |u| new(:ensure => :present, :name => u.name) }
-  end
-end

data/vendored/puppet/lib/puppet/reference/configuration.rb

@@ -1,92 +0,0 @@
-config = Puppet::Util::Reference.newreference(:configuration, :depth => 1, :doc => "A reference for all settings") do
-  docs = {}
-  Puppet.settings.each do |name, object|
-    docs[name] = object
-  end
-
-  str = ""
-  docs.sort { |a, b|
-    a[0].to_s <=> b[0].to_s
-  }.each do |name, object|
-    # Make each name an anchor
-    header = name.to_s
-    str << markdown_header(header, 3)
-
-    # Print the doc string itself
-    begin
-      str << Puppet::Util::Docs.scrub(object.desc)
-    rescue => detail
-      Puppet.log_exception(detail)
-    end
-    str << "\n\n"
-
-    # Now print the data about the item.
-    val = object.default
-    if name.to_s == 'vardir'
-      val = 'Unix/Linux: /opt/puppetlabs/puppet/cache -- Windows: C:\ProgramData\PuppetLabs\puppet\cache -- Non-root user: ~/.puppetlabs/opt/puppet/cache'
-    elsif name.to_s == 'confdir'
-      val = 'Unix/Linux: /etc/puppetlabs/puppet -- Windows: C:\ProgramData\PuppetLabs\puppet\etc -- Non-root user: ~/.puppetlabs/etc/puppet'
-    elsif name.to_s == 'codedir'
-      val = 'Unix/Linux: /etc/puppetlabs/code -- Windows: C:\ProgramData\PuppetLabs\code -- Non-root user: ~/.puppetlabs/etc/code'
-    elsif name.to_s == 'rundir'
-      val = 'Unix/Linux: /var/run/puppetlabs -- Windows: C:\ProgramData\PuppetLabs\puppet\var\run -- Non-root user: ~/.puppetlabs/var/run'
-    elsif name.to_s == 'logdir'
-      val = 'Unix/Linux: /var/log/puppetlabs/puppet -- Windows: C:\ProgramData\PuppetLabs\puppet\var\log -- Non-root user: ~/.puppetlabs/var/log'
-    elsif name.to_s == 'hiera_config'
-      val = '$confdir/hiera.yaml. However, if a file exists at $codedir/hiera.yaml, Puppet uses that instead.'
-    elsif name.to_s == 'certname'
-      val = "the Host's fully qualified domain name, as determined by facter"
-    end
-
-    # Leave out the section information; it was apparently confusing people.
-    #str << "- **Section**: #{object.section}\n"
-    unless val == ""
-      str << "- *Default*: #{val}\n"
-    end
-    str << "\n"
-  end
-
-  return str
-end
-
-config.header = <<EOT
-## Configuration settings
-
-* Each of these settings can be specified in `puppet.conf` or on the
-  command line.
-* Puppet Enterprise (PE) and open source Puppet share the configuration settings
-  that are documented here. However, PE defaults for some settings differ from
-  the open source Puppet defaults. Some examples of settings that have different
-  PE defaults include `disable18n`, `environment_timeout`, `always_retry_plugins`,
-  and the Puppet Server JRuby `max-active-instances` setting. To verify PE
-  configuration defaults, check the `puppet.conf` file after installation.
-* When using boolean settings on the command line, use `--setting` and
-  `--no-setting` instead of `--setting (true|false)`. (Using `--setting false`
-  results in "Error: Could not parse application options: needless argument".)
-* Settings can be interpolated as `$variables` in other settings; `$environment`
-  is special, in that puppet master will interpolate each agent node's
-  environment instead of its own.
-* Multiple values should be specified as comma-separated lists; multiple
-  directories should be separated with the system path separator (usually
-  a colon).
-* Settings that represent time intervals should be specified in duration format:
-  an integer immediately followed by one of the units 'y' (years of 365 days),
-  'd' (days), 'h' (hours), 'm' (minutes), or 's' (seconds). The unit cannot be
-  combined with other units, and defaults to seconds when omitted. Examples are
-  '3600' which is equivalent to '1h' (one hour), and '1825d' which is equivalent
-  to '5y' (5 years).
-* If you use the `splay` setting, note that the period that it waits changes
-  each time the Puppet agent is restarted.
-* Settings that take a single file or directory can optionally set the owner,
-  group, and mode for their value: `rundir = $vardir/run { owner = puppet,
-  group = puppet, mode = 644 }`
-* The Puppet executables will ignore any setting that isn't relevant to
-  their function.
-
-See the [configuration guide][confguide] for more details.
-
-[confguide]: https://puppet.com/docs/puppet/latest/config_about_settings.html
-
-* * *
-
-EOT