puppet 4.0.0 → 4.9.1

data/lib/puppet/provider/service/smf.rb

@@ -1,3 +1,5 @@
+require 'timeout'
+
 # Solaris 10 SMF-style services.
 Puppet::Type.type(:service).provide :smf, :parent => :base do
   desc <<-EOT
@@ -19,6 +21,8 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
   commands :adm => "/usr/sbin/svcadm", :svcs => "/usr/bin/svcs"
   commands :svccfg => "/usr/sbin/svccfg"
 
+  has_feature :refreshable
+
   def setupservice
       if resource[:manifest]
         [command(:svcs), "-l", @resource[:name]]
@@ -32,11 +36,12 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
   end
 
   def self.instances
-   svcs.split("\n").select{|l| l !~ /^legacy_run/ }.collect do |line|
-     state,stime,fmri = line.split(/\s+/)
+   svcs("-H", "-o", "state,fmri" ).split("\n").select{|l| l !~ /^legacy_run/ }.collect do |line|
+     state,fmri = line.split(/\s+/)
      status =  case state
                when /online/; :running
                when /maintenance/; :maintenance
+               when /degraded/; :degraded
                else :stopped
                end
      new({:name => fmri, :ensure => status})
@@ -61,19 +66,63 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
   end
 
   def restartcmd
-    [command(:adm), :restart, @resource[:name]]
+    if Puppet::Util::Package.versioncmp(Facter.value(:operatingsystemrelease), '11.2') >= 0
+      [command(:adm), :restart, "-s", @resource[:name]]
+    else
+      # Synchronous restart only supported in Solaris 11.2 and above
+      [command(:adm), :restart, @resource[:name]]
+    end
   end
 
   def startcmd
     self.setupservice
     case self.status
-    when :maintenance
+    when :maintenance, :degraded
       [command(:adm), :clear, @resource[:name]]
     else
-      [command(:adm), :enable, "-s", @resource[:name]]
+      [command(:adm), :enable, "-rs", @resource[:name]]
     end
   end
 
+  # Wait for the service to transition into the specified state before returning.
+  # This is necessary due to the asynchronous nature of SMF services.
+  # desired_state should be online, offline, disabled, or uninitialized.
+  # See PUP-5474 for long-term solution to this issue.
+  def wait(*desired_state)
+    Timeout.timeout(60) do
+      loop do
+        states = self.service_states
+        break if desired_state.include?(states[0]) && states[1] == '-'
+        sleep(1)
+      end
+    end
+  rescue Timeout::Error
+    raise Puppet::Error.new("Timed out waiting for #{@resource[:name]} to transition states")
+  end
+
+  def start
+    # Wait for the service to actually start before returning.
+    super
+    self.wait('online')
+  end
+
+  def stop
+    # Wait for the service to actually stop before returning.
+    super
+    self.wait('offline', 'disabled', 'uninitialized')
+  end
+
+  def restart
+    # Wait for the service to actually start before returning.
+    super
+    self.wait('online')
+  end
+
+  # Determine the current and next states of a service.
+  def service_states
+    svcs("-H", "-o", "state,nstate", @resource[:name]).chomp.split
+  end
+
   def status
     if @resource[:status]
       super
@@ -83,11 +132,11 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
     begin
       # get the current state and the next state, and if the next
       # state is set (i.e. not "-") use it for state comparison
-      states = svcs("-H", "-o", "state,nstate", @resource[:name]).chomp.split
+      states = service_states
       state = states[1] == "-" ? states[0] : states[1]
     rescue Puppet::ExecutionFailure
-      info "Could not get status on service #{self.name}"
-      return :stopped
+      debug "Could not get status on service #{self.name} #{$!}"
+      return :absent
     end
 
     case state
@@ -99,6 +148,8 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
       return :stopped
     when "maintenance"
       return :maintenance
+    when "degraded"
+      return :degraded
     when "legacy_run"
       raise Puppet::Error,
         "Cannot manage legacy services through SMF"

data/lib/puppet/provider/service/src.rb

@@ -1,3 +1,5 @@
+require 'timeout'
+
 # AIX System Resource controller (SRC)
 Puppet::Type.type(:service).provide :src, :parent => :base do
 
@@ -63,6 +65,31 @@ Puppet::Type.type(:service).provide :src, :parent => :base do
     rmitab(@resource[:name])
   end
 
+  # Wait for the service to transition into the specified state before returning.
+  # This is necessary due to the asynchronous nature of AIX services.
+  # desired_state should either be :running or :stopped.
+  def wait(desired_state)
+    Timeout.timeout(60) do
+      loop do
+        status = self.status
+        break if status == desired_state.to_sym
+        sleep(1)
+      end
+    end
+  rescue Timeout::Error
+    raise Puppet::Error.new("Timed out waiting for #{@resource[:name]} to transition states")
+  end
+
+  def start
+    super
+    self.wait(:running)
+  end
+
+  def stop
+    super
+    self.wait(:stopped)
+  end
+
   def restart
       execute([command(:lssrc), "-Ss", @resource[:name]]).each_line do |line|
         args = line.split(":")

data/lib/puppet/provider/service/systemd.rb

@@ -1,19 +1,36 @@
-# Manage systemd services using /bin/systemctl
+# Manage systemd services using systemctl
 
 Puppet::Type.type(:service).provide :systemd, :parent => :base do
-  desc "Manages `systemd` services using `systemctl`."
+  desc "Manages `systemd` services using `systemctl`.
+
+  Because `systemd` defaults to assuming the `.service` unit type, the suffix
+  may be omitted.  Other unit types (such as `.path`) may be managed by
+  providing the proper suffix."
 
   commands :systemctl => "systemctl"
 
+  if Facter.value(:osfamily).downcase == 'debian'
+    # With multiple init systems on Debian, it is possible to have
+    # pieces of systemd around (e.g. systemctl) but not really be
+    # using systemd.  We do not do this on other platforms as it can
+    # cause issues when running in a chroot without /run mounted
+    # (PUP-5577)
+    confine :exists => "/run/systemd/system"
+  end
+
   defaultfor :osfamily => [:archlinux]
   defaultfor :osfamily => :redhat, :operatingsystemmajrelease => "7"
-  defaultfor :osfamily => :redhat, :operatingsystem => :fedora, :operatingsystemmajrelease => ["17", "18", "19", "20", "21"]
-  defaultfor :osfamily => :suse, :operatingsystemmajrelease => ["12", "13"]
+  defaultfor :osfamily => :redhat, :operatingsystem => :fedora
+  defaultfor :osfamily => :suse
+  defaultfor :osfamily => :coreos
+  defaultfor :operatingsystem => :debian, :operatingsystemmajrelease => "8"
+  defaultfor :operatingsystem => :ubuntu, :operatingsystemmajrelease => ["15.04","15.10","16.04","16.10"]
+  defaultfor :operatingsystem => :cumuluslinux, :operatingsystemmajrelease => ["3"]
 
   def self.instances
     i = []
     output = systemctl('list-unit-files', '--type', 'service', '--full', '--all',  '--no-pager')
-    output.scan(/^(\S+)\s+(disabled|enabled)\s*$/i).each do |m|
+    output.scan(/^(\S+)\s+(disabled|enabled|masked|indirect)\s*$/i).each do |m|
       i << new(:name => m[0])
     end
     return i
@@ -21,35 +38,100 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
     return []
   end
 
+  # This helper ensures that the enable state cache is always reset
+  # after a systemctl enable operation. A particular service state is not guaranteed
+  # after such an operation, so the cache must be emptied to prevent inconsistencies
+  # in the provider's believed state of the service and the actual state.
+  # @param action [String,Symbol] One of 'enable', 'disable', 'mask' or 'unmask'
+  def systemctl_change_enable(action)
+    output = systemctl(action, @resource[:name])
+  rescue
+    raise Puppet::Error, "Could not #{action} #{self.name}: #{output}", $!.backtrace
+  ensure
+    @cached_enabled = nil
+  end
+
   def disable
-    output = systemctl(:disable, @resource[:name])
-  rescue Puppet::ExecutionFailure
-    raise Puppet::Error, "Could not disable #{self.name}: #{output}", $!.backtrace
+    systemctl_change_enable(:disable)
+  end
+
+  def get_start_link_count
+    # Start links don't include '.service'. Just search for the service name.
+    if @resource[:name].match(/\.service/)
+      link_name = @resource[:name].split('.')[0]
+    else
+      link_name = @resource[:name]
+    end
+
+    Dir.glob("/etc/rc*.d/S??#{link_name}").length
+  end
+
+  def cached_enabled?
+    return @cached_enabled if @cached_enabled
+    cmd = [command(:systemctl), 'is-enabled', @resource[:name]]
+    @cached_enabled = execute(cmd, :failonfail => false).strip
   end
 
   def enabled?
-    begin
-      systemctl("is-enabled", @resource[:name])
-    rescue Puppet::ExecutionFailure
-      return :false
+    output = cached_enabled?
+    code = $CHILD_STATUS.exitstatus
+
+    # The masked state is equivalent to the disabled state in terms of
+    # comparison so we only care to check if it is masked if we want to keep
+    # it masked.
+    #
+    # We only return :mask if we're trying to mask the service. This prevents
+    # flapping when simply trying to disable a masked service.
+    return :mask if (@resource[:enable] == :mask) && (output == 'masked')
+
+    # The indirect state indicates that the unit is not enabled.
+    return :false if output == 'indirect'
+    return :true if (code == 0)
+    if (output.empty?) && (code > 0) && (Facter.value(:osfamily).downcase == 'debian')
+      ret = debian_enabled?
+      return ret if ret
     end
 
-    :true
+    return :false
   end
 
-  def status
-    begin
-      systemctl("is-active", @resource[:name])
-    rescue Puppet::ExecutionFailure
-      return :stopped
+  # This method is required for Debian systems due to the way the SysVInit-Systemd
+  # compatibility layer works. When we are trying to manage a service which does not
+  # have a Systemd unit file, we need to go through the old init script to determine
+  # whether it is enabled or not. See PUP-5016 for more details.
+  #
+  def debian_enabled?
+    system("/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start")
+    if [104, 106].include?($CHILD_STATUS.exitstatus)
+      return :true
+    elsif [101, 105].include?($CHILD_STATUS.exitstatus)
+      # 101 is action not allowed, which means we have to do the check manually.
+      # 105 is unknown, which generally means the initscript does not support query
+      # The debian policy states that the initscript should support methods of query
+      # For those that do not, perform the checks manually
+      # http://www.debian.org/doc/debian-policy/ch-opersys.html
+      if get_start_link_count >= 4
+        return :true
+      else
+        return :false
+      end
+    else
+      return :false
     end
-    return :running
   end
 
   def enable
-    output = systemctl("enable", @resource[:name])
-  rescue Puppet::ExecutionFailure
-    raise Puppet::Error, "Could not enable #{self.name}: #{output}", $!.backtrace
+    self.unmask
+    systemctl_change_enable(:enable)
+  end
+
+  def mask
+    self.disable
+    systemctl_change_enable(:mask)
+  end
+
+  def unmask
+    systemctl_change_enable(:unmask)
   end
 
   def restartcmd
@@ -57,11 +139,48 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
   end
 
   def startcmd
+    self.unmask
     [command(:systemctl), "start", @resource[:name]]
   end
 
   def stopcmd
     [command(:systemctl), "stop", @resource[:name]]
   end
+
+  def statuscmd
+    [command(:systemctl), "is-active", @resource[:name]]
+  end
+
+  def restart
+    begin
+      super
+    rescue Puppet::Error => e
+      raise Puppet::Error.new(prepare_error_message(@resource[:name], 'restart', e))
+    end
+  end
+
+  def start
+    begin
+      super
+    rescue Puppet::Error => e
+      raise Puppet::Error.new(prepare_error_message(@resource[:name], 'start', e))
+    end
+  end
+
+  def stop
+    begin
+      super
+    rescue Puppet::Error => e
+      raise Puppet::Error.new(prepare_error_message(@resource[:name], 'stop', e))
+    end
+  end
+
+  def prepare_error_message(name, action, exception)
+    error_return = "Systemd #{action} for #{name} failed!\n"
+    journalctl_command = "journalctl -n 50 --since '5 minutes ago' -u #{name} --no-pager"
+    Puppet.debug("Runing journalctl command to get logs for systemd #{action} failure: #{journalctl_command}")
+    journalctl_output = execute(journalctl_command)
+    error_return << "journalctl log for #{name}:\n#{journalctl_output}"
+  end
 end
 

data/lib/puppet/provider/service/upstart.rb

@@ -18,7 +18,7 @@ Puppet::Type.type(:service).provide :upstart, :parent => :debian do
     Facter.value(:operatingsystem) == 'LinuxMint',
   ]
 
-  defaultfor :operatingsystem => :ubuntu
+  defaultfor :operatingsystem => :ubuntu, :operatingsystemmajrelease => ["10.04", "12.04", "14.04", "14.10"]
 
   commands :start   => "/sbin/start",
            :stop    => "/sbin/stop",

data/lib/puppet/provider/ssh_authorized_key/parsed.rb

@@ -68,7 +68,7 @@ Puppet::Type.type(:ssh_authorized_key).provide(
     end
   end
 
-  # parse sshv2 option strings, wich is a comma separated list of
+  # Parse sshv2 option strings, which is a comma-separated list of
   # either key="values" elements or bare-word elements
   def self.parse_options(options)
     result = []

data/lib/puppet/provider/sshkey/parsed.rb

@@ -1,23 +1,14 @@
 require 'puppet/provider/parsedfile'
 
-known = nil
-case Facter.value(:operatingsystem)
-when "Darwin"; known = "/etc/ssh_known_hosts"
-else
-  known = "/etc/ssh/ssh_known_hosts"
-end
-
-
 Puppet::Type.type(:sshkey).provide(
   :parsed,
   :parent => Puppet::Provider::ParsedFile,
-  :default_target => known,
   :filetype => :flat
 ) do
   desc "Parse and generate host-wide known hosts files for SSH."
 
   text_line :comment, :match => /^#/
-  text_line :blank, :match => /^\s+/
+  text_line :blank, :match => /^\s*$/
 
   record_line :parsed, :fields => %w{name type key},
     :post_parse => proc { |hash|
@@ -36,5 +27,24 @@ Puppet::Type.type(:sshkey).provide(
   def self.default_mode
     0644
   end
+
+  def self.default_target
+    case Facter.value(:operatingsystem)
+    when "Darwin"
+      # Versions 10.11 and up use /etc/ssh/ssh_known_hosts
+      version = Facter.value(:macosx_productversion_major)
+      if version
+        if Puppet::Util::Package.versioncmp(version, '10.11') >= 0
+          "/etc/ssh/ssh_known_hosts"
+        else
+          "/etc/ssh_known_hosts"
+        end
+      else
+        "/etc/ssh_known_hosts"
+      end
+    else
+      "/etc/ssh/ssh_known_hosts"
+    end
+  end
 end
 

data/lib/puppet/provider/user/aix.rb

@@ -7,7 +7,7 @@
 #   but puppet does not allow it. There is a ticket open for that (#5431)
 # - AIX maximum password age is in WEEKs, not days
 #
-# See  http://docs.puppetlabs.com/guides/provider_development.html
+# See  https://docs.puppetlabs.com/guides/provider_development.html
 # for more information
 #
 # Author::    Hector Rivas Gandara <keymon@gmail.com>
@@ -56,7 +56,7 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
   # Valid attributes to be managed by this provider.
   # It is a list with of hash
   #  :aix_attr      AIX command attribute name
-  #  :puppet_prop   Puppet propertie name
+  #  :puppet_prop   Puppet property name
   #  :to            Method to adapt puppet property to aix command value. Optional.
   #  :from          Method to adapt aix command value to puppet property. Optional
   self.attribute_mapping = [
@@ -279,6 +279,7 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
 
   def managed_attribute_keys(hash)
     managed_attributes ||= @resource.original_parameters[:attributes] || hash.keys.map{|k| k.to_s}
+    managed_attributes = [managed_attributes] unless managed_attributes.is_a?(Array)
     managed_attributes.map {|attr| key, value = attr.split("="); key.strip.to_sym}
   end
 
@@ -289,7 +290,7 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
   end
 
   def filter_attributes(hash)
-    # Return only managed attributtes.
+    # Return only managed attributes.
     managed_keys = managed_attribute_keys(hash)
     results = hash.select {
         |k,v| should_include?(k, managed_keys)