Class: ForemanMaintain::Utils::Backup

Inherits:
Object
  • Object
show all
Includes:
Concerns::SystemHelpers
Defined in:
lib/foreman_maintain/utils/backup.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Concerns::SystemHelpers

#check_max_version, #check_min_version, #command_present?, #create_lv_snapshot, #directory_empty?, #execute, #execute!, #execute?, #execute_runner, #execute_with_status, #file_exists?, #file_nonzero?, #find_dir_containing_file, #find_package, #find_symlinks, #format_shell_args, #get_lv_info, #get_lv_path, #hostname, included, #package_manager, #package_version, #packages_action, #parse_csv, #parse_json, #rpm_version, #server?, #shellescape, #systemd_installed?, #version

Methods included from Concerns::Finders

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

Methods included from Concerns::Logger

#logger

Constructor Details

#initialize(backup_dir) ⇒ Backup

Returns a new instance of Backup.



14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/foreman_maintain/utils/backup.rb', line 14

def initialize(backup_dir)
  # fpc stands for foreman proxy w/ content
  @backup_dir = backup_dir
  @standard_files = ['config_files.tar.gz']
  @katello_online_files = ['mongo_dump', 'candlepin.dump', 'foreman.dump']
  if feature(:pulpcore)
    @katello_online_files << 'pulpcore.dump'
  end
  @katello_offline_files = ['mongo_data.tar.gz', 'pgsql_data.tar.gz']
  @foreman_online_files = ['foreman.dump']
  @foreman_offline_files = ['pgsql_data.tar.gz']
  @fpc_online_files = ['mongo_dump']
  @fpc_offline_files = ['mongo_data.tar.gz']
end

Instance Attribute Details

#foreman_offline_files ⇒ Object

Returns the value of attribute foreman_offline_files.



10
11
12
 
# File 'lib/foreman_maintain/utils/backup.rb', line 10

def foreman_offline_files
  @foreman_offline_files
end

#foreman_online_files ⇒ Object

Returns the value of attribute foreman_online_files.



10
11
12
 
# File 'lib/foreman_maintain/utils/backup.rb', line 10

def foreman_online_files
  @foreman_online_files
end

#fpc_offline_files ⇒ Object

Returns the value of attribute fpc_offline_files.



10
11
12
 
# File 'lib/foreman_maintain/utils/backup.rb', line 10

def fpc_offline_files
  @fpc_offline_files
end

#fpc_online_files ⇒ Object

Returns the value of attribute fpc_online_files.



10
11
12
 
# File 'lib/foreman_maintain/utils/backup.rb', line 10

def fpc_online_files
  @fpc_online_files
end

#katello_offline_files ⇒ Object

Returns the value of attribute katello_offline_files.



10
11
12
 
# File 'lib/foreman_maintain/utils/backup.rb', line 10

def katello_offline_files
  @katello_offline_files
end

#katello_online_files ⇒ Object

Returns the value of attribute katello_online_files.



10
11
12
 
# File 'lib/foreman_maintain/utils/backup.rb', line 10

def katello_online_files
  @katello_online_files
end

#standard_files ⇒ Object

Returns the value of attribute standard_files.



10
11
12
 
# File 'lib/foreman_maintain/utils/backup.rb', line 10

def standard_files
  @standard_files
end

Instance Method Details

#check_backup ⇒ Object 



65
66
67
68
69
70
71
72
73
 
# File 'lib/foreman_maintain/utils/backup.rb', line 65

def check_backup
  if feature(:instance).foreman_proxy_with_content?
    valid_fpc_backup?
  elsif feature(:katello)
    valid_katello_backup?
  else
    valid_foreman_backup?
  end
end

#check_file_existence(existence_map) ⇒ Object 



87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/foreman_maintain/utils/backup.rb', line 87

def check_file_existence(existence_map)
  unless feature(:pulpcore)
    existence_map[:present].delete(:pulpcore_dump)
    existence_map[:absent].delete(:pulpcore_dump)
  end

  existence_map[:present].each do |file|
    unless file_map[file][:present]
      return false
    end
  end

  existence_map[:absent].each do |file|
    if file_map[file][:present]
      return false
    end
  end

  true
end

#file_map ⇒ Object 



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/foreman_maintain/utils/backup.rb', line 29

def file_map
  @file_map ||= {
    :mongo_data => map_file(@backup_dir, 'mongo_data.tar.gz'),
    :pgsql_data => map_file(@backup_dir, 'pgsql_data.tar.gz'),
    :pulp_data => map_file(@backup_dir, 'pulp_data.tar'),
    :foreman_dump => map_file(@backup_dir, 'foreman.dump'),
    :candlepin_dump => map_file(@backup_dir, 'candlepin.dump'),
    :mongo_dump => map_file(@backup_dir, 'mongo_dump'),
    :config_files => map_file(@backup_dir, 'config_files.tar.gz'),
    :pg_globals => map_file(@backup_dir, 'pg_globals.dump'),
    :metadata => map_file(@backup_dir, 'metadata.yml')
  }
  if feature(:pulpcore)
    @file_map[:pulpcore_dump] = map_file(@backup_dir, 'pulpcore.dump')
  end
  @file_map
end

#foreman_logical_backup? ⇒ Boolean

Returns:

  • (Boolean) 


158
159
160
161
 
# File 'lib/foreman_maintain/utils/backup.rb', line 158

def foreman_logical_backup?
  check_file_existence(:present => [:pgsql_data, :foreman_dump],
                       :absent => [:candlepin_dump, :mongo_data, :mongo_dump])
end

#foreman_online_backup? ⇒ Boolean

Returns:

  • (Boolean) 


152
153
154
155
156
 
# File 'lib/foreman_maintain/utils/backup.rb', line 152

def foreman_online_backup?
  check_file_existence(:present => [:foreman_dump],
                       :absent => [:candlepin_dump, :pgsql_data,
                                   :mongo_data, :mongo_dump])
end

#foreman_standard_backup? ⇒ Boolean

Returns:

  • (Boolean) 


146
147
148
149
150
 
# File 'lib/foreman_maintain/utils/backup.rb', line 146

def foreman_standard_backup?
  check_file_existence(:present => [:pgsql_data],
                       :absent => [:candlepin_dump, :foreman_dump, :pulpcore_dump,
                                   :mongo_data, :mongo_dump])
end

#fpc_logical_backup? ⇒ Boolean

Returns:

  • (Boolean) 


140
141
142
143
144
 
# File 'lib/foreman_maintain/utils/backup.rb', line 140

def fpc_logical_backup?
  absent = [:pgsql_data, :candlepin_dump, :foreman_dump]
  check_file_existence(:present => [:mongo_dump, :mongo_data], :absent => absent) ||
    check_file_existence(:present => [:pulpcore_dump], :absent => absent)
end

#fpc_online_backup? ⇒ Boolean

Returns:

  • (Boolean) 


133
134
135
136
137
138
 
# File 'lib/foreman_maintain/utils/backup.rb', line 133

def fpc_online_backup?
  absent = [:mongo_data, :pgsql_data, :candlepin_dump, :foreman_dump]

  check_file_existence(:present => [:mongo_dump], :absent => absent) ||
    check_file_existence(:present => [:pulpcore_dump], :absent => absent)
end

#fpc_standard_backup? ⇒ Boolean

Returns:

  • (Boolean) 


127
128
129
130
131
 
# File 'lib/foreman_maintain/utils/backup.rb', line 127

def fpc_standard_backup?
  check_file_existence(:present => [:mongo_data],
                       :absent => [:pgsql_data, :candlepin_dump,
                                   :foreman_dump, :mongo_dump, :pulpcore_dump])
end

#incremental? ⇒ Boolean

Returns:

  • (Boolean) 


204
205
206
 
# File 'lib/foreman_maintain/utils/backup.rb', line 204

def incremental?
  !!metadata.fetch('incremental', false)
end

#katello_logical_backup? ⇒ Boolean

Returns:

  • (Boolean) 


121
122
123
124
125
 
# File 'lib/foreman_maintain/utils/backup.rb', line 121

def katello_logical_backup?
  check_file_existence(:present => [:mongo_dump, :mongo_data, :pgsql_data,
                                    :candlepin_dump, :pulpcore_dump, :foreman_dump],
                       :absent => [])
end

#katello_online_backup? ⇒ Boolean

Returns:

  • (Boolean) 


115
116
117
118
119
 
# File 'lib/foreman_maintain/utils/backup.rb', line 115

def katello_online_backup?
  check_file_existence(:present => [:candlepin_dump, :foreman_dump,
                                    :pulpcore_dump, :mongo_dump],
                       :absent => [:mongo_data, :pgsql_data])
end

#katello_standard_backup? ⇒ Boolean

TODO: Need to check for pulpcore feature?

Returns:

  • (Boolean) 


109
110
111
112
113
 
# File 'lib/foreman_maintain/utils/backup.rb', line 109

def katello_standard_backup?
  check_file_existence(:present => [:mongo_data, :pgsql_data],
                       :absent => [:candlepin_dump, :foreman_dump,
                                   :pulpcore_dump, :mongo_dump])
end

#map_file(backup_dir, filename) ⇒ Object 



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

def map_file(backup_dir, filename)
  file_path = File.join(backup_dir, filename)
  present = File.exist?(file_path)
  {
    :present => present,
    :path => file_path
  }
end

#metadata ⇒ Object 



180
181
182
183
184
185
186
 
# File 'lib/foreman_maintain/utils/backup.rb', line 180

def metadata
  if file_map[:metadata][:present]
    YAML.load_file(file_map[:metadata][:path])
  else
    {}
  end
end

#online_backup? ⇒ Boolean

Returns:

  • (Boolean) 


208
209
210
 
# File 'lib/foreman_maintain/utils/backup.rb', line 208

def online_backup?
  !!metadata.fetch('online', false)
end

#present_files ⇒ Object 



56
57
58
59
 
# File 'lib/foreman_maintain/utils/backup.rb', line 56

def present_files
  present_files = file_map.select { |_k, v| v[:present] }
  present_files.values.map { |f| File.basename(f[:path]) }
end

#pulp_tar_split? ⇒ Boolean

Returns:

  • (Boolean) 


188
189
190
 
# File 'lib/foreman_maintain/utils/backup.rb', line 188

def pulp_tar_split?
  File.exist?(File.join(@backup_dir, 'pulp_data.part0002'))
end

#sql_dump_files_exist? ⇒ Boolean

Returns:

  • (Boolean) 


198
199
200
201
202
 
# File 'lib/foreman_maintain/utils/backup.rb', line 198

def sql_dump_files_exist?
  file_map[:foreman_dump][:present] ||
    file_map[:candlepin_dump][:present] ||
    (feature(:pulpcore) && file_map[:pulpcore_dump][:present])
end

#tar_backups_exist? ⇒ Boolean

Returns:

  • (Boolean) 


192
193
194
195
196
 
# File 'lib/foreman_maintain/utils/backup.rb', line 192

def tar_backups_exist?
  file_map[:mongo_data][:present] ||
    file_map[:pulp_data][:present] ||
    file_map[:pgsql_data][:present]
end

#valid_backup? ⇒ Boolean

Returns:

  • (Boolean) 


61
62
63
 
# File 'lib/foreman_maintain/utils/backup.rb', line 61

def valid_backup?
  file_map[:config_files][:present] && check_backup
end

#valid_foreman_backup? ⇒ Boolean

Returns:

  • (Boolean) 


83
84
85
 
# File 'lib/foreman_maintain/utils/backup.rb', line 83

def valid_foreman_backup?
  foreman_standard_backup? || foreman_online_backup? || foreman_logical_backup?
end

#valid_fpc_backup? ⇒ Boolean

Returns:

  • (Boolean) 


75
76
77
 
# File 'lib/foreman_maintain/utils/backup.rb', line 75

def valid_fpc_backup?
  fpc_online_backup? || fpc_standard_backup? || fpc_logical_backup?
end

#valid_katello_backup? ⇒ Boolean

Returns:

  • (Boolean) 


79
80
81
 
# File 'lib/foreman_maintain/utils/backup.rb', line 79

def valid_katello_backup?
  katello_online_backup? || katello_standard_backup? || katello_logical_backup?
end

#validate_hostname? ⇒ Boolean

Returns:

  • (Boolean) 


163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/foreman_maintain/utils/backup.rb', line 163

def validate_hostname?
  # make sure that the system hostname is the same as the backup
  config_tarball = file_map[:config_files][:path]
  tar_cmd = "tar zxf #{config_tarball} etc/httpd/conf/httpd.conf --to-stdout --occurrence=1"
  status, httpd_config = execute_with_status(tar_cmd)

  # Incremental backups sometimes don't include httpd.conf. Since a "base" backup
  # is restored before an incremental, we can assume that the hostname is checked
  # during the base backup restore
  if status == 0
    match = httpd_config.match(/\s*ServerName\s+"*([^ "]+)"*\s*$/)
    match ? match[1] == hostname : false
  else
    true
  end
end