bolt 0.20.0 → 0.20.2

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

@@ -0,0 +1,265 @@
+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

@@ -0,0 +1,148 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,303 @@
+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