bolt 0.19.1 → 0.20.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/provider/vlan/cisco.rb

@@ -1,28 +0,0 @@
-require 'puppet/provider/cisco'
-
-Puppet::Type.type(:vlan).provide :cisco, :parent => Puppet::Provider::Cisco do
-
-  desc "Cisco switch/router provider for vlans."
-
-  mk_resource_methods
-
-  def self.lookup(device, id)
-    vlans = {}
-    device.command do |dev|
-      vlans = dev.parse_vlans || {}
-    end
-    vlans[id]
-  end
-
-  def initialize(device, *args)
-    super
-  end
-
-  # Clear out the cached values.
-  def flush
-    device.command do |dev|
-      dev.update_vlan(resource[:name], former_properties, properties)
-    end
-    super
-  end
-end

data/vendored/puppet/lib/puppet/provider/yumrepo/inifile.rb

@@ -1,303 +0,0 @@
-require 'puppet/util/inifile'
-
-Puppet::Type.type(:yumrepo).provide(:inifile) do
-  desc <<-EOD
-    Manage yum repo configurations by parsing yum INI configuration files.
-
-    ### Fetching instances
-
-    When fetching repo instances, directory entries in '/etc/yum/repos.d',
-    '/etc/yum.repos.d', and the directory optionally specified by the reposdir
-    key in '/etc/yum.conf' will be checked. If a given directory does not exist it
-    will be ignored. In addition, all sections in '/etc/yum.conf' aside from
-    'main' will be created as sections.
-
-    ### Storing instances
-
-    When creating a new repository, a new section will be added in the first
-    yum repo directory that exists. The custom directory specified by the
-    '/etc/yum.conf' reposdir property is checked first, followed by
-    '/etc/yum/repos.d', and then '/etc/yum.repos.d'. If none of these exist, the
-    section will be created in '/etc/yum.conf'.
-  EOD
-
-  PROPERTIES = Puppet::Type.type(:yumrepo).validproperties
-
-  # Retrieve all providers based on existing yum repositories
-  #
-  # @api public
-  # @return [Array<Puppet::Provider>] providers generated from existing yum
-  #   repository definitions.
-  def self.instances
-    instances = []
-
-    virtual_inifile.each_section do |section|
-      # Ignore the 'main' section in yum.conf since it's not a repository.
-      next if section.name == "main"
-
-      attributes_hash = {:name => section.name, :ensure => :present, :provider => :yumrepo}
-
-      section.entries.each do |key, value|
-        key = key.to_sym
-        if valid_property?(key)
-          attributes_hash[key] = value
-        elsif key == :name
-          attributes_hash[:descr] = value
-        end
-      end
-      instances << new(attributes_hash)
-    end
-
-    instances
-  end
-
-  # Match catalog type instances to provider instances.
-  #
-  # @api public
-  # @param resources [Array<Puppet::Type::Yumrepo>] Resources to prefetch.
-  # @return [void]
-  def self.prefetch(resources)
-    repos = instances
-    resources.each_key do |name|
-      if provider = repos.find { |repo| repo.name == name }
-        resources[name].provider = provider
-      end
-    end
-  end
-
-  # Return a list of existing directories that could contain repo files.
-  #
-  # @api private
-  # @param conf [String] Configuration file to look for directories in.
-  # @param dirs [Array<String>] Default locations for yum repos.
-  # @return [Array<String>] All present directories that may contain yum repo configs.
-  def self.reposdir(conf='/etc/yum.conf', dirs=['/etc/yum.repos.d', '/etc/yum/repos.d'])
-    reposdir = find_conf_value('reposdir', conf)
-    # Use directories in reposdir if they are set instead of default
-    if reposdir
-      # Follow the code from the yum/config.py
-      reposdir.gsub!("\n", ' ')
-      reposdir.gsub!(',', ' ')
-      dirs = reposdir.split
-    end
-    dirs.select! { |dir| Puppet::FileSystem.exist?(dir) }
-    if dirs.empty?
-      Puppet.debug('No yum directories were found on the local filesystem')
-    end
-
-    dirs
-  end
-
-  # Used for testing only
-  # @api private
-  def self.clear
-    @virtual = nil
-  end
-
-  # Helper method to look up specific values in ini style files.
-  #
-  # @api private
-  # @param value [String] Value to look for in the configuration file.
-  # @param conf [String] Configuration file to check for value.
-  # @return [String] The value of a looked up key from the configuration file.
-  def self.find_conf_value(value, conf='/etc/yum.conf')
-    if Puppet::FileSystem.exist?(conf)
-      file = Puppet::Util::IniConfig::PhysicalFile.new(conf)
-      file.read
-      if (main = file.get_section('main'))
-        main[value]
-      end
-    end
-  end
-
-  # Enumerate all files that may contain yum repository configs.
-  # '/etc/yum.conf' is always included.
-  #
-  # @api private
-  # @return [Array<String>
-  def self.repofiles
-    files = ["/etc/yum.conf"]
-    reposdir.each do |dir|
-      Dir.glob("#{dir}/*.repo").each do |file|
-        files << file
-      end
-    end
-
-    files
-  end
-
-  # Build a virtual inifile by reading in numerous .repo files into a single
-  # virtual file to ease manipulation.
-  # @api private
-  # @return [Puppet::Util::IniConfig::File] The virtual inifile representing
-  #   multiple real files.
-  def self.virtual_inifile
-    unless @virtual
-      @virtual = Puppet::Util::IniConfig::File.new
-      self.repofiles.each do |file|
-        @virtual.read(file) if Puppet::FileSystem.file?(file)
-      end
-    end
-    return @virtual
-  end
-
-  # Is the given key a valid type property?
-  #
-  # @api private
-  # @param key [String] The property to look up.
-  # @return [Boolean] Returns true if the property is defined in the type.
-  def self.valid_property?(key)
-    PROPERTIES.include?(key)
-  end
-
-  # Return an existing INI section or create a new section in the default location
-  #
-  # The default location is determined based on what yum repo directories
-  # and files are present. If /etc/yum.conf has a value for 'reposdir' then that
-  # is preferred. If no such INI property is found then the first default yum
-  # repo directory that is present is used. If no default directories exist then
-  # /etc/yum.conf is used.
-  #
-  # @param name [String] Section name to lookup in the virtual inifile.
-  # @return [Puppet::Util::IniConfig] The IniConfig section
-  def self.section(name)
-    result = self.virtual_inifile[name]
-    # Create a new section if not found.
-    unless result
-      dirs = reposdir()
-      if dirs.empty?
-        # If no repo directories are present, default to using yum.conf.
-        path = '/etc/yum.conf'
-      else
-        # The ordering of reposdir is [defaults, custom], and we want to use
-        # the custom directory if present.
-        path = File.join(dirs.last, "#{name}.repo")
-      end
-      result = self.virtual_inifile.add_section(name, path)
-    end
-    result
-  end
-
-  # Save all yum repository files and force the mode to 0644
-  # @api private
-  # @return [void]
-  def self.store(resource)
-    inifile = self.virtual_inifile
-    inifile.store
-
-    target_mode = 0644
-    inifile.each_file do |file|
-      current_mode = Puppet::FileSystem.stat(file).mode & 0777
-      unless current_mode == target_mode
-        resource.info _("changing mode of %{file} from %{current_mode} to %{target_mode}") %
-                          { file: file, current_mode: "%03o" % current_mode, target_mode: "%03o" % target_mode }
-        Puppet::FileSystem.chmod(target_mode, file)
-      end
-    end
-  end
-
-  # Create a new section for the given repository and set all the specified
-  # properties in the section.
-  #
-  # @api public
-  # @return [void]
-  def create
-    @property_hash[:ensure] = :present
-
-    # We fetch a list of properties from the type, then iterate
-    # over them, avoiding ensure.  We're relying on .should to
-    # check if the property has been set and should be modified,
-    # and if so we set it in the virtual inifile.
-    PROPERTIES.each do |property|
-      next if property == :ensure
-
-      if value = @resource.should(property)
-        self.send("#{property}=", value)
-      end
-    end
-  end
-
-  # Does the given repository already exist?
-  #
-  # @api public
-  # @return [Boolean]
-  def exists?
-    @property_hash[:ensure] == :present
-  end
-
-  # Mark the given repository section for destruction.
-  #
-  # The actual removal of the section will be handled by {#flush} after the
-  # resource has been fully evaluated.
-  #
-  # @api public
-  # @return [void]
-  def destroy
-    # Flag file for deletion on flush.
-    current_section.destroy=(true)
-
-    @property_hash.clear
-  end
-
-  # Finalize the application of the given resource.
-  #
-  # @api public
-  # @return [void]
-  def flush
-    self.class.store(self)
-  end
-
-  # Generate setters and getters for our INI properties.
-  PROPERTIES.each do |property|
-    # The ensure property uses #create, #exists, and #destroy we can't generate
-    # meaningful setters and getters for this
-    next if property == :ensure
-
-    define_method(property) do
-      get_property(property)
-    end
-
-    define_method("#{property}=") do |value|
-      set_property(property, value)
-    end
-  end
-
-  # Map the yumrepo 'descr' type property to the 'name' INI property.
-  def descr
-    if ! @property_hash.has_key?(:descr)
-      @property_hash[:descr] = current_section['name']
-    end
-    value = @property_hash[:descr]
-    value.nil? ? :absent : value
-  end
-
-  def descr=(value)
-    value = (value == :absent ? nil : value)
-    current_section['name'] = value
-    @property_hash[:descr] = value
-  end
-
-  private
-
-  def get_property(property)
-    if ! @property_hash.has_key?(property)
-      @property_hash[property] = current_section[property.to_s]
-    end
-    value = @property_hash[property]
-    value.nil? ? :absent : value
-  end
-
-  def set_property(property, value)
-    value = (value == :absent ? nil : value)
-    current_section[property.to_s] = value
-    @property_hash[property] = value
-  end
-
-  def section(name)
-    self.class.section(name)
-  end
-
-  def current_section
-    self.class.section(self.name)
-  end
-end