Class: MongoDbUtils::Cmd

Inherits:
Object
  • Object
show all
Includes:
Tools
Defined in:
lib/mongo-db-utils/cmd.rb

Class Method Summary collapse

Class Method Details

.backup(db, folder, final_path = nil, tar_it = true) ⇒ Object 



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/mongo-db-utils/cmd.rb', line 9

def self.backup(db, folder, final_path = nil, tar_it = true)
  puts ">> Backing up: #{db}, #{folder}, #{final_path}"
  unless (db_exists?(db))
    return false
  end

  if (final_path.nil?)
    out_path = File.join(folder, db.to_host_s, db.name, timestamp)
  else
    out_path = File.join(folder, final_path)
  end

  full_path = File.expand_path(out_path)

  puts ">> final backup path: #{full_path}"

  FileUtils.mkdir_p(full_path)

  Dump.new(
    db.to_host_s,
    db.name,
    full_path,
    db.username,
    db.password).run

  full_db_path = File.join(full_path, db.name)

  if (tar_it)
    Dir.chdir(full_path)
    `tar --create --verbose --file=#{db.name}.tar #{db.name}`
    delete_folder full_db_path
    "#{full_db_path}.tar"
  else
    full_db_path
  end
end

.backup_s3(backup_folder, db, bucket_name, access_key_id, secret_access_key) ⇒ Object 



88
89
90
91
92
93
94
95
 
# File 'lib/mongo-db-utils/cmd.rb', line 88

def self.backup_s3(backup_folder, db, bucket_name, access_key_id, secret_access_key)
  tar_file = MongoDbUtils::Cmd.backup(db, backup_folder)
  name = tar_file.gsub(File.expand_path(backup_folder), '')
  MongoDbUtils::S3::put_file(tar_file, name, bucket_name, access_key_id, secret_access_key)
  file = File.basename(tar_file)
  folder = tar_file.gsub(file, '')
  delete_folder folder
end

.copy(path, source, destination, halt_on_no_backup = true, skip_backup = false) ⇒ Object

With remote dbs you can’t do a copy_database if you’re not an admin.



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/mongo-db-utils/cmd.rb', line 47

def self.copy(path, source, destination, halt_on_no_backup = true, skip_backup = false)

  backup_made = if skip_backup
                  true
                else
                  backup(destination, path)
                end

  if !backup_made && halt_on_no_backup
    puts 'aborting - no backup was made'
    return
  end

  tmp_path = File.join(ConfigLoader::CONFIG_LOCATION, 'tmp')

  FileUtils.mkdir_p(tmp_path)

  puts "backup to: #{File.join(tmp_path, source.name)}"
  tmp_dump_path = backup(source, tmp_path, source.name, false)

  # if the destination db doesn't exist
  # we assume that the user has admin control of the server
  # eg its a local server (this needs to be thought through a bit more)
  username = ''
  password = ''

  if db_exists? destination
    username = destination.username
    password = destination.password
  end

  Restore.new(
    destination.to_host_s,
    destination.name,
    "#{tmp_dump_path}",
    username,
    password).run

  delete_folder tmp_path
end

.delete_backup(backup_folder, backup) ⇒ Object 



139
140
141
 
# File 'lib/mongo-db-utils/cmd.rb', line 139

def self.delete_backup(backup_folder, backup)
  delete_folder File.join(backup_folder, backup)
end

.download_backup_from_s3(backup_folder, backup, bucket_name, access_key_id, secret_access_key) ⇒ Object 



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/mongo-db-utils/cmd.rb', line 112

def self.download_backup_from_s3(backup_folder, backup, bucket_name, access_key_id, secret_access_key)
  if backup == 'latest'
    backup = get_latest_backup(bucket_name, access_key_id, secret_access_key)
  end
  backup_file = File.join(backup_folder, File.basename(backup))

  puts "download_backup_from_s3 #{backup_file}"
  if File.exists? backup_file
    puts "File downloaded already #{backup_file}"
  else
    FileUtils.mkdir_p(backup_folder)
    puts "Downloading #{backup_file}"
    download_backup(backup_file, backup, bucket_name, access_key_id, secret_access_key)
  end
  backup
end

.list_backup_folders(backup_folder, backup) ⇒ Object 



106
107
108
109
110
 
# File 'lib/mongo-db-utils/cmd.rb', line 106

def self.list_backup_folders(backup_folder, backup)
  puts "reading backup folders from #{backup_folder} #{backup}"
  folders = list_archive_folders(backup_folder, backup)
  folders.map { |a| a.slice! File.basename(backup, '.tgz'); a.delete '/' }.select { |a| a != '' }
end

.list_backups(bucket_name, access_key_id, secret_access_key) ⇒ Object 



97
98
99
 
# File 'lib/mongo-db-utils/cmd.rb', line 97

def self.list_backups(bucket_name, access_key_id, secret_access_key)
  MongoDbUtils::S3::list_bucket(bucket_name, access_key_id, secret_access_key)
end

.list_downloaded_backups(backup_folder) ⇒ Object 



101
102
103
104
 
# File 'lib/mongo-db-utils/cmd.rb', line 101

def self.list_downloaded_backups(backup_folder)
  FileUtils.mkdir_p(backup_folder)
  Dir.entries(backup_folder).select { |a| a.end_with? '.tgz' }
end

.restore_from_backup(backup_folder, db, backup, source_db) ⇒ Object 



129
130
131
132
133
134
135
136
 
# File 'lib/mongo-db-utils/cmd.rb', line 129

def self.restore_from_backup(backup_folder, db, backup, source_db)
  Dir.mktmpdir do |dir|
    puts "Unzipping archive ..."
    unzip(File.join(backup_folder, backup), dir)
    puts "Restoring db ..."
    restore_db(db, File.join(dir, source_db ))
  end
end