Class: Puppet::Agent

Inherits:
Object show all
Includes:
Disabler, Locker, Util::Splayer
Defined in:
lib/puppet/agent.rb

Overview

A general class for triggering a run of another class.

Defined Under Namespace

Modules: Disabler, Locker

Constant Summary

Constants included from Disabler

Disabler::DISABLED_MESSAGE_JSON_KEY

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Util::Splayer

#splay, #splayed?

Methods included from Disabler

#disable, #disable_message, #disabled?, #enable

Methods included from Locker

#lock, #lockfile_path, #running?

Constructor Details

#initialize(client_class, should_fork = true) ⇒ Agent

Returns a new instance of Agent.



18
19
20
21
 
# File 'lib/puppet/agent.rb', line 18

def initialize(client_class, should_fork=true)
  @should_fork = can_fork? && should_fork
  @client_class = client_class
end

Instance Attribute Details

#client ⇒ Object (readonly) 



16
17
18
 
# File 'lib/puppet/agent.rb', line 16

def client
  @client
end

#client_class ⇒ Object (readonly) 



16
17
18
 
# File 'lib/puppet/agent.rb', line 16

def client_class
  @client_class
end

#should_fork ⇒ Object (readonly) 



16
17
18
 
# File 'lib/puppet/agent.rb', line 16

def should_fork
  @should_fork
end

Instance Method Details

#can_fork? ⇒ Boolean

Returns:

  • (Boolean) 


23
24
25
 
# File 'lib/puppet/agent.rb', line 23

def can_fork?
  Puppet.features.posix? && RUBY_PLATFORM != 'java'
end

#needing_restart? ⇒ Boolean

Returns:

  • (Boolean) 


27
28
29
 
# File 'lib/puppet/agent.rb', line 27

def needing_restart?
  Puppet::Application.restart_requested?
end

#run(client_options = {}) ⇒ Object

Perform a run with our client.



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/puppet/agent.rb', line 32

def run(client_options = {})
  if disabled?
    Puppet.notice "Skipping run of #{client_class}; administratively disabled (Reason: '#{disable_message}');\nUse 'puppet agent --enable' to re-enable."
    return
  end

  result = nil
  block_run = Puppet::Application.controlled_run do
    splay client_options.fetch :splay, Puppet[:splay]
    result = run_in_fork(should_fork) do
      with_client do |client|
        begin
          client_args = client_options.merge(:pluginsync => Puppet[:pluginsync])
          lock { client.run(client_args) }
        rescue Puppet::LockError
          Puppet.notice "Run of #{client_class} already in progress; skipping  (#{lockfile_path} exists)"
          return
        rescue StandardError => detail
          Puppet.log_exception(detail, "Could not run #{client_class}: #{detail}")
        end
      end
    end
    true
  end
  Puppet.notice "Shutdown/restart in progress (#{Puppet::Application.run_status.inspect}); skipping run" unless block_run
  result
end

#run_in_fork(forking = true) ⇒ Object 



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/puppet/agent.rb', line 64

def run_in_fork(forking = true)
  return yield unless forking or Puppet.features.windows?

  child_pid = Kernel.fork do
    $0 = "puppet agent: applying configuration"
    begin
      exit(yield)
    rescue SystemExit
      exit(-1)
    rescue NoMemoryError
      exit(-2)
    end
  end
  exit_code = Process.waitpid2(child_pid)
  case exit_code[1].exitstatus
  when -1
    raise SystemExit
  when -2
    raise NoMemoryError
  end
  exit_code[1].exitstatus
end

#stopping? ⇒ Boolean

Returns:

  • (Boolean) 


60
61
62
 
# File 'lib/puppet/agent.rb', line 60

def stopping?
  Puppet::Application.stop_requested?
end