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

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_checks, 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(version, reporter, options = {}) ⇒ UpgradeRunner

Returns a new instance of UpgradeRunner.



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

def initialize(version, reporter, options = {})
  super(reporter, [], options)
  @version = version
  scenarios_present = find_scenarios(:tags => :upgrade_scenario).any?(&matching_version_test)
  raise "Unknown version #{version}" unless scenarios_present

  @scenario_cache = {}
  self.phase = :pre_upgrade_checks
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

#finish_upgrade ⇒ Object 



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

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

#load ⇒ Object

deserializes the state of the run from the storage



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

def load
  return unless storage[:serialized]

  load_from_hash(storage[:serialized])
end

#matching_version_test ⇒ Object 



57
58
59
60
61
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 57

def matching_version_test
  proc do |scenario|
    scenario.respond_to?(:target_version) && scenario.target_version == @version
  end
end

#run ⇒ Object 



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

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 



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

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 



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

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



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

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

#scenario(phase) ⇒ Object 



47
48
49
50
51
52
53
54
55
 
# File 'lib/foreman_maintain/upgrade_runner.rb', line 47

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

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

  @scenario_cache[phase] = matching_scenarios.first
end

#skip_phase(skipped_phase) ⇒ Object 



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

def skip_phase(skipped_phase)
  with_non_empty_scenario(skipped_phase) do |scenario|
    @reporter.before_scenario_starts(scenario)
    @reporter.puts <<-MESSAGE.strip_heredoc
      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 



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

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

#update_current_target_version ⇒ Object 



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

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