Class: ForemanMaintain::UpgradeRunner

Inherits:
Runner
  • Object
show all
Extended by:
Concerns::Finders
Includes:
Concerns::Finders
Defined in:
lib/foreman_maintain/upgrade_runner.rb

Constant Summary collapse

PHASES =

Phases of the upgrade, see README.md for more info

[:pre_upgrade_checks,
:pre_migrations,
:migrations,
:post_migrations,
:post_upgrade_checks].freeze

Constants inherited from Runner

Runner::FAILURE_EXIT_CODE, Runner::WARNING_EXIT_CODE

Instance Attribute Summary collapse

Attributes inherited from Runner

#exit_code, #reporter

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Concerns::Finders

check, detector, feature, find_all_scenarios, find_procedures, find_scenarios, procedure

Methods inherited from Runner

#add_steps, #ask_to_quit, #assumeyes?, #quit?, #rescue?, #run_scenario, #whitelisted_step?

Methods included from Concerns::Logger

#logger

Constructor Details

#initialize(reporter, options = {}) ⇒ UpgradeRunner

Returns a new instance of UpgradeRunner.



37
38
39
40
41
42
43
44
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 37

def initialize(reporter, options = {})
  super(reporter, [], options)
  @scenario_cache = {}
  @phase = :pre_upgrade_checks
  condition = { :tags => [:upgrade_scenario, phase] }
  matching_scenarios = find_scenarios(condition)
  @version = matching_scenarios.first&.target_version
end

Instance Attribute Details

#phase ⇒ Object

Returns the value of attribute phase.



35
36
37
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 35

def phase
  @phase
end

#tag ⇒ Object (readonly)

Returns the value of attribute tag.



35
36
37
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 35

def tag
  @tag
end

#version ⇒ Object (readonly)

Returns the value of attribute version.



35
36
37
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 35

def version
  @version
end

Class Method Details

.available_targets ⇒ Object 



15
16
17
18
19
20
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 15

def available_targets
  # when some upgrade is in progress, we don't allow upgrade to different version
  return [current_target_version] if current_target_version

  find_scenarios(:tags => :upgrade_scenario).map(&:target_version).uniq.sort
end

.clear_current_target_version ⇒ Object 



30
31
32
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 30

def clear_current_target_version
  ForemanMaintain.storage.update_and_save(:upgrade_target_version => nil)
end

.current_target_version ⇒ Object 



22
23
24
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 22

def current_target_version
  ForemanMaintain.storage[:upgrade_target_version]
end

.current_target_version=(value) ⇒ Object 



26
27
28
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 26

def current_target_version=(value)
  ForemanMaintain.storage.update_and_save(:upgrade_target_version => value)
end

Instance Method Details

#available? ⇒ Boolean

Returns:

  • (Boolean) 


46
47
48
49
50
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 46

def available?
  condition = { :tags => [:upgrade_scenario, :pre_upgrade_checks] }
  matching_scenarios = find_scenarios(condition)
  !matching_scenarios.empty?
end

#finish_upgrade ⇒ Object 



93
94
95
96
97
98
99
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 93

def finish_upgrade
  @finished = true
  @reporter.hline
  @reporter.puts <<~MESSAGE
    Upgrade finished.
  MESSAGE
end

#load ⇒ Object

deserializes the state of the run from the storage



116
117
118
119
120
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 116

def load
  return unless storage[:serialized]

  load_from_hash(storage[:serialized])
end

#run ⇒ Object 



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 62

def run
  self.class.current_target_version = @version
  PHASES.each do |phase|
    return run_rollback if quit?

    if skip?(phase)
      skip_phase(phase)
    else
      run_phase(phase)
    end
  end
  unless quit?
    finish_upgrade
  end
ensure
  update_current_target_version
end

#run_phase(phase) ⇒ Object 



122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 122

def run_phase(phase)
  with_non_empty_scenario(phase) do |scenario|
    confirm_scenario(scenario)
    return if quit?

    self.phase = phase
    run_scenario(scenario)
    # if we started from the :pre_upgrade_checks, ensure to ask before
    # continuing with the rest of the upgrade
    @ask_to_confirm_upgrade = phase == :pre_upgrade_checks
  end
end

#run_rollback ⇒ Object 



86
87
88
89
90
91
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 86

def run_rollback
  # we only are able to rollback from pre_migrations phase
  if phase == :pre_migrations
    rollback_pre_migrations
  end
end

#save ⇒ Object

serializes the state of the run to storage



106
107
108
109
110
111
112
113
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 106

def save
  if @finished
    storage.delete(:serialized)
  else
    storage[:serialized] = to_hash
  end
  storage.save
end

#scenario(phase) ⇒ Object 



52
53
54
55
56
57
58
59
60
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 52

def scenario(phase)
  return @scenario_cache[phase] if @scenario_cache.key?(phase)

  condition = { :tags => [:upgrade_scenario, phase] }
  matching_scenarios = find_scenarios(condition)
  raise "Too many scenarios match #{condition.inspect}" if matching_scenarios.size > 1

  @scenario_cache[phase] = matching_scenarios.first
end

#skip_phase(skipped_phase) ⇒ Object 



135
136
137
138
139
140
141
142
143
144
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 135

def skip_phase(skipped_phase)
  with_non_empty_scenario(skipped_phase) do |scenario|
    @reporter.before_scenario_starts(scenario)
    @reporter.puts <<~MESSAGE
      Skipping #{skipped_phase} phase as it was already run before.
      To enforce to run the phase, use `upgrade run --phase #{skipped_phase}`
    MESSAGE
    @reporter.after_scenario_finishes(scenario)
  end
end

#storage ⇒ Object 



101
102
103
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 101

def storage
  ForemanMaintain.storage("upgrade_#{version}")
end

#update_current_target_version ⇒ Object 



80
81
82
83
84
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 80

def update_current_target_version
  if phase == :pre_upgrade_checks || @finished
    UpgradeRunner.clear_current_target_version
  end
end