chef_backup 0.0.1.dev.1

data/spec/unit/strategy/backup/shared_examples/backup.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+shared_examples 'a tar based backup' do
+  it 'populates the data map with services and configs' do
+    expect(subject).to receive(:populate_data_map).once
+    subject.backup
+  end
+
+  it 'creates a backup manifest' do
+    expect(subject).to receive(:write_manifest).once
+    subject.backup
+  end
+
+  it 'creates a tarball of the backup' do
+    expect(subject).to receive(:create_tarball).once
+    subject.backup
+  end
+
+  it 'cleans up the temp directory' do
+    expect(subject).to receive(:cleanup).at_least(:once)
+    subject.backup
+  end
+end
+
+shared_examples 'a tar based frontend' do
+  it 'doesnt stop any services' do
+    expect(subject).to_not receive(:stop_service)
+    subject.backup
+  end
+
+  it 'doesnt dump the db' do
+    expect(subject).to_not receive(:dump_db)
+    subject.backup
+  end
+end
+
+shared_examples 'a tar based online backend' do
+  it "doesn't start any services" do
+    expect(subject).to_not receive(:start_service)
+    subject.backup
+  end
+
+  it "doesn't stop any services" do
+    expect(subject).to_not receive(:stop_service)
+    subject.backup
+  end
+
+  it 'dumps the db' do
+    expect(subject).to receive(:dump_db).once
+    subject.backup
+  end
+end
+
+shared_examples 'a tar based offline backend' do
+  it 'stops all services besides keepalived and postgres' do
+    expect(subject).to receive(:stop_chef_server).once
+
+    %w(postgresql keepalived).each do |service|
+      expect(subject).to_not receive(:stop_service).with(service)
+    end
+
+    subject.backup
+  end
+
+  it 'starts all the services again' do
+    expect(subject).to receive(:start_chef_server).at_least(:once)
+    subject.backup
+  end
+
+  it 'dumps the db' do
+    expect(subject).to receive(:dump_db).once
+    subject.backup
+  end
+end

data/spec/unit/strategy/backup/tar_spec.rb

@@ -0,0 +1,280 @@
+require 'spec_helper'
+require 'chef/mixin/deep_merge'
+require_relative 'shared_examples/backup'
+
+describe ChefBackup::Strategy::TarBackup do
+  set_common_variables
+
+  subject { described_class.new }
+
+  before do
+    use_default_running_config
+    allow(subject).to receive(:tmp_dir).and_return(tmp_dir)
+    allow(subject).to receive(:backup_time).and_return(backup_time)
+  end
+
+  describe '.backup' do
+    before do
+      %i(write_manifest dump_db stop_service create_tarball cleanup
+         start_service export_tarball
+      ).each do |method|
+        allow(subject).to receive(method).and_return(true)
+      end
+
+      allow(subject).to receive(:enabled_services).and_return(enabled_services)
+      allow(subject).to receive(:all_services).and_return(all_services)
+      allow(subject).to receive(:dump_db).and_return(true)
+    end
+
+    context 'on a frontend' do
+      before { private_chef('role' => 'frontend') }
+
+      it_behaves_like 'a tar based backup'
+      it_behaves_like 'a tar based frontend'
+    end
+
+    context 'on a backend' do
+      before { private_chef('role' => 'backend') }
+
+      context 'during an online backup' do
+        before do
+          private_chef('role' => 'backend', 'backup' => { 'mode' => 'online' })
+        end
+
+        it_behaves_like 'a tar based backup'
+        it_behaves_like 'a tar based online backend'
+      end
+
+      context 'during an offline backup' do
+        it_behaves_like 'a tar based backup'
+        it_behaves_like 'a tar based offline backend'
+      end
+
+      context 'when no mode is configured' do
+        before do
+          private_chef('role' => 'backend', 'backup' => { 'mode' => nil })
+        end
+
+        it_behaves_like 'a tar based backup'
+        it_behaves_like 'a tar based offline backend'
+      end
+    end
+
+    context 'on a standlone' do
+      before { private_chef('role' => 'standalone') }
+
+      context 'during an online backup' do
+        before do
+          private_chef('role' => 'standalone',
+                       'backup' => { 'mode' => 'online' })
+        end
+
+        it_behaves_like 'a tar based backup'
+        it_behaves_like 'a tar based online backend'
+      end
+
+      context 'during an offline backup' do
+        it_behaves_like 'a tar based backup'
+        it_behaves_like 'a tar based offline backend'
+      end
+
+      context 'when no mode is configured' do
+        before do
+          private_chef('role' => 'standalone', 'backup' => { 'mode' => nil })
+        end
+
+        it_behaves_like 'a tar based backup'
+        it_behaves_like 'a tar based offline backend'
+      end
+    end
+  end
+
+  describe '.dump_db' do
+    let(:dump_cmd) do
+      ['/opt/opscode/embedded/bin/chpst',
+       '-u opscode-pgsql',
+       '/opt/opscode/embedded/bin/pg_dumpall',
+       "> #{tmp_dir}/chef_backup-#{backup_time}.sql"
+      ].join(' ')
+    end
+
+    let(:tmp_dir) { '/tmp/notaswear' }
+    let(:backup_time) { Time.now }
+
+    before do
+      allow(subject).to receive(:tmp_dir).and_return(tmp_dir)
+      allow(subject).to receive(:backup_time).and_return(backup_time)
+      allow(subject).to receive(:shell_out!).with(dump_cmd).and_return(true)
+      private_chef('postgresql' => { 'username' => 'opscode-pgsql' })
+      subject.data_map.add_service('postgresql', '/data/dir')
+    end
+
+    %w(backend standalone).each do |role|
+      context "on a #{role}" do
+        before do
+          private_chef('role' => role)
+        end
+
+        it 'dumps the db' do
+          expect(subject).to receive(:shell_out!).with(dump_cmd)
+          subject.dump_db
+        end
+
+        it 'updates the data map' do
+          subject.dump_db
+          expect(subject.data_map.services['postgresql'])
+            .to include('pg_dump_success' => true)
+        end
+
+        it 'adds the postgresql username to the data map' do
+          subject.dump_db
+          expect(subject.data_map.services['postgresql'])
+            .to include('username' => 'opscode-pgsql')
+        end
+      end
+    end
+
+    context 'on a frontend' do
+      before { private_chef('role' => 'frontend') }
+
+      it "doesn't dump the db" do
+        expect(subject).to_not receive(:shell_out).with(/pg_dumpall/)
+        subject.dump_db
+      end
+    end
+  end
+
+  describe '.create_tarball' do
+    before do
+      allow(subject).to receive(:data_map).and_return(data_map)
+      allow(Dir).to receive(:[]).and_return(%w(sql.sql manifest.json))
+    end
+
+    it 'creates a tarball with all items in the temp directory' do
+      cmd = [
+        "tar -czf #{tmp_dir}/chef-backup-#{backup_time}.tgz",
+        data_map.services.map { |_, v| v['data_dir'] }.compact.join(' '),
+        data_map.configs.map { |_, v| v['data_dir'] }.compact.join(' '),
+        Dir["#{tmp_dir}/*"].map { |f| File.basename(f) }.join(' ')
+      ].join(' ').strip
+
+      allow(subject).to receive(:shell_out).with(cmd, cdw: tmp_dir)
+      expect(subject).to receive(:shell_out).with(cmd, cwd: tmp_dir)
+      subject.create_tarball
+    end
+  end
+
+  describe '.export_tarball' do
+    before do
+      allow(subject).to receive(:export_dir).and_return('/mnt/chef-backups')
+    end
+
+    it 'moves the tarball to the archive location' do
+      cmd = "rsync -chaz #{tmp_dir}/chef-backup-#{backup_time}.tgz"
+      cmd << " #{export_dir}/"
+
+      allow(subject).to receive(:shell_out).with(cmd)
+      expect(subject).to receive(:shell_out).with(cmd)
+      subject.export_tarball
+    end
+  end
+
+  describe '.write_manifest' do
+    let(:manifest) do
+      { 'some' => {
+        'nested' => {
+          'hash' => true
+        },
+        'another' => true
+      }
+      }
+    end
+
+    let(:file) { double('file', write: true) }
+
+    before do
+      allow(subject).to receive(:manifest).and_return(manifest)
+      allow(subject).to receive(:tmp_dir).and_return(tmp_dir)
+      allow(File).to receive(:open).and_yield(file)
+    end
+
+    it 'converts the manifest to json' do
+      json_manifest = JSON.pretty_generate(subject.manifest)
+      expect(file).to receive(:write).with(json_manifest)
+      subject.write_manifest
+    end
+
+    it 'writes a json file to the tmp_dir' do
+      expect(File).to receive(:open).with("#{tmp_dir}/manifest.json", 'w')
+      subject.write_manifest
+    end
+  end
+
+  describe '.populate_data_map' do
+    let(:services) { %w(opscode-solr4 bookshelf rabbitmq) }
+    let(:configs) { %w(opscode opscode-manage opscode-analytics) }
+    let(:config) do
+      { 'bookshelf' => { 'data_dir' => '/bookshelf/data' },
+        'opscode-solr4' => { 'data_dir' => '/solr4/data' },
+        'rabbitmq' => { 'data_dir' => '/rabbitmq/data' }
+      }
+    end
+
+    before do
+      allow(subject).to receive(:data_map).and_return(data_map)
+      allow(subject).to receive(:stateful_services).and_return(services)
+      allow(subject).to receive(:config_directories).and_return(configs)
+      %w(add_service add_config).each do |method|
+        allow(data_map).to receive(method.to_sym).and_return(true)
+      end
+    end
+
+    %w(frontend backend standalone).each do |role|
+      context "on a #{role}" do
+        before { private_chef(config.merge('role' => role)) }
+
+        it 'populates the data map with config directories' do
+          configs.each do |config|
+            expect(subject.data_map)
+              .to receive(:add_config)
+              .with(config, "/etc/#{config}")
+          end
+
+          subject.populate_data_map
+        end
+      end
+    end
+
+    %w(backend standalone).each do |role|
+      context "on a #{role}" do
+        before { private_chef(config.merge('role' => role)) }
+
+        it 'populates the data map with service directories' do
+          services.each do |service|
+            expect(subject.data_map)
+              .to receive(:add_service)
+              .with(service, config[service]['data_dir'])
+          end
+
+          subject.populate_data_map
+        end
+
+        it 'populates the data map with the upgrades' do
+          expect(subject.data_map)
+            .to receive(:add_service)
+            .with('upgrades', '/var/opt/opscode/upgrades')
+
+          subject.populate_data_map
+        end
+      end
+    end
+
+    context 'on a frontend' do
+      before { private_chef(config.merge('role' => 'frontend')) }
+
+      it "doesn't populate the data map with the services" do
+        expect(subject.data_map).to_not receive(:add_service)
+      end
+    end
+  end
+end

data/spec/unit/strategy/restore/shared_examples/restore.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+shared_examples 'a tar based restore' do
+  it "cleanse's the chef server" do
+    expect(subject).to receive(:cleanse_chef_server).once
+    subject.restore
+  end
+
+  it 'restores the configs' do
+    configs.each do |config|
+      expect(subject).to receive(:restore_data).with(:configs, config).once
+    end
+    subject.restore
+  end
+
+  it 'touches the bootstrap sentinel file' do
+    expect(subject).to receive(:touch_sentinel).once
+    subject.restore
+  end
+
+  it 'reconfigures the server' do
+    expect(subject).to receive(:reconfigure_server).once
+    subject.restore
+  end
+
+  it 'updates the config' do
+    expect(subject).to receive(:update_config).once
+    subject.restore
+  end
+
+  it 'starts the server' do
+    expect(subject).to receive(:start_chef_server).once
+    subject.restore
+  end
+
+  it 'cleans up the temp directory' do
+    expect(subject).to receive(:cleanup).once
+    subject.restore
+  end
+end
+
+shared_examples 'a tar based frontend restore' do
+  it 'does not restore services' do
+    expect(subject).to_not receive(:restore_services)
+    subject.restore
+  end
+
+  it 'does not start postgres' do
+    expect(subject).to_not receive(:start_service).with(:postgresql)
+    subject.restore
+  end
+
+  it 'does not attempt to import a database' do
+    expect(subject).to_not receive(:import_db)
+    subject.restore
+  end
+end
+
+shared_examples 'a tar based backend restore' do
+  it 'restores the stateful services' do
+    services.each do |service|
+      expect(subject)
+        .to receive(:restore_data)
+        .with(:services, service)
+        .once
+    end
+    subject.restore
+  end
+end
+
+shared_examples 'a tar based backend restore with db dump' do
+  it 'restores the db dump' do
+    expect(subject).to receive(:import_db)
+    subject.restore
+  end
+end
+
+shared_examples 'a tar based backend restore without db dump' do
+  it 'does not try to import a db dump' do
+    expect(subject).to_not receive(:import_db)
+    expect(subject).to_not receive(:start_service).with(:postgresql)
+    subject.restore
+  end
+end

data/spec/unit/strategy/restore/tar_spec.rb

@@ -0,0 +1,238 @@
+require 'spec_helper'
+require_relative 'shared_examples/restore'
+
+describe ChefBackup::Strategy::TarRestore do
+  let(:manifest) do
+    { 'strategy' => 'tar',
+      'backup_time' => '2014-12-02-22-46-58',
+      'services' => {
+        'rabbitmq' => { 'data_dir' => '/var/opt/opscode/rabbitmq/db' },
+        'opscode-solr4' => {
+          'data_dir' => '/var/opt/opscode/opscode-solr4/data'
+        },
+        'redis_lb' => { 'data_dir' => '/var/opt/opscode/redis_lb/data' },
+        'postgresql' => {
+          'data_dir' => '/var/opt/opscode/postgresql/9.2/data',
+          'pg_dump_success' => pg_dump_success,
+          'username' => 'opscode-pgsql'
+        },
+        'bookshelf' => { 'data_dir' => '/var/opt/opscode/bookshelf/data' }
+      },
+      'configs' => {
+        'opscode' => { 'data_dir' => '/etc/opscode' },
+        'opscode-manage' => { 'data_dir' => '/etc/opscode-manage' },
+        'opscode-reporting' => { 'data_dir' => '/etc/opscode-reporting' },
+        'opscode-analytics' => { 'data_dir' => '/etc/opscode-analytics' }
+      }
+    }
+  end
+
+  let(:pg_dump_success) { true }
+  let(:tarball_path) { '/var/backups/chef-backup-2014-12-02-22-46-58.tgz' }
+  let(:configs) { manifest['configs'].keys }
+  let(:services) { manifest['services'].keys }
+  let(:restore_dir) { ChefBackup::Config['restore_dir'] }
+
+  subject { described_class.new(tarball_path) }
+
+  before(:each) { use_default_cli_args }
+
+  describe '.restore' do
+    before do
+      %i(shell_out shell_out! unpack_tarball stop_chef_server ensure_file!
+         start_chef_server reconfigure_server cleanse_chef_server
+         update_config import_db touch_sentinel
+      ).each do |method|
+        allow(subject).to receive(method).and_return(true)
+      end
+      configs.each do |config|
+        allow(subject)
+          .to receive(:restore_data)
+          .with(:configs, config)
+          .and_return(true)
+      end
+      services.each do |service|
+        allow(subject)
+          .to receive(:restore_data)
+          .with(:services, service)
+          .and_return(true)
+      end
+
+      allow(subject).to receive(:tarball_path).and_return(tarball_path)
+      allow(subject).to receive(:manifest).and_return(manifest)
+    end
+
+    it_behaves_like 'a tar based restore'
+
+    context 'on a frontend' do
+      before do
+        allow(subject).to receive(:frontend?).and_return(true)
+      end
+
+      it_behaves_like 'a tar based frontend restore'
+    end
+
+    context 'on a backend' do
+      before do
+        allow(subject).to receive(:frontend?).and_return(false)
+      end
+
+      it_behaves_like 'a tar based backend restore'
+
+      context 'when a db dump is present' do
+        before do
+          allow(subject).to receive(:restore_db_dump?).and_return(true)
+          allow(subject)
+            .to receive(:start_service).with(:postgresql).and_return(true)
+          allow(subject).to receive(:import_db).and_return(true)
+        end
+
+        it_behaves_like 'a tar based backend restore with db dump'
+      end
+
+      context 'when a db dump is not present' do
+        before do
+          allow(subject).to receive(:restore_db_dump?).and_return(false)
+        end
+
+        it_behaves_like 'a tar based backend restore without db dump'
+      end
+    end
+
+    context 'on a standalone' do
+      before do
+        allow(subject).to receive(:frontend?).and_return(false)
+      end
+
+      it_behaves_like 'a tar based backend restore'
+
+      context 'when a db dump is present' do
+        before do
+          allow(subject).to receive(:restore_db_dump?).and_return(true)
+        end
+
+        it_behaves_like 'a tar based backend restore with db dump'
+      end
+
+      context 'when a db dump is not present' do
+        before do
+          allow(subject).to receive(:restore_db_dump?).and_return(false)
+        end
+
+        it_behaves_like 'a tar based backend restore without db dump'
+      end
+    end
+  end
+
+  describe '.manifest' do
+    let(:json) { "{\"some\":\"json\"}" }
+    let(:manifest_json) { File.join(restore_dir, 'manifest.json') }
+
+    it 'parses the manifest from the restore dir' do
+      allow(subject).to receive(:ensure_file!).and_return(true)
+      allow(File).to receive(:read).with(manifest_json).and_return(json)
+      expect(subject.manifest).to eq('some' => 'json')
+    end
+
+    it 'raises an error if the manifest is invalid' do
+      expect { subject.manifest }
+        .to raise_error(
+          ChefBackup::Strategy::TarRestore::InvalidManifest,
+          "#{File.join(restore_dir, 'manifest.json')} not found"
+        )
+    end
+  end
+
+  describe '.restore_data' do
+    before do
+      ChefBackup::Config['restore_dir'] = restore_dir
+      allow(subject).to receive(:manifest).and_return(manifest)
+      allow(subject).to receive(:shell_out!).and_return(true)
+      allow(File).to receive(:directory?).and_return(true)
+    end
+
+    context 'with config data' do
+      it 'rsyncs the config from the restore dir to the data_dir' do
+        source = File.expand_path(
+          File.join(restore_dir, manifest['configs']['opscode']['data_dir']))
+        destination = manifest['configs']['opscode']['data_dir']
+        cmd = "rsync -chaz --delete #{source}/ #{destination}"
+
+        expect(subject).to receive(:shell_out!).with(cmd)
+        subject.restore_data(:configs, 'opscode')
+      end
+    end
+
+    context 'with service data' do
+      it 'rsyncs the service from the restore dir to the data_dir' do
+        source = File.expand_path(
+          File.join(restore_dir, manifest['services']['rabbitmq']['data_dir']))
+        destination = manifest['services']['rabbitmq']['data_dir']
+        cmd = "rsync -chaz --delete #{source}/ #{destination}"
+
+        expect(subject).to receive(:shell_out!).with(cmd)
+        subject.restore_data(:services, 'rabbitmq')
+      end
+    end
+  end
+
+  describe '.import_db' do
+    before do
+      allow(subject).to receive(:manifest).and_return(manifest)
+      allow(subject).to receive(:shell_out!).and_return(true)
+      allow(subject).to receive(:running_config).and_return(running_config)
+      allow(subject)
+        .to receive(:start_service).with('postgresql').and_return(true)
+    end
+
+    context 'without a db dump' do
+      it 'raises an exception' do
+        expect { subject.import_db }
+          .to raise_error(ChefBackup::Exceptions::InvalidDatabaseDump)
+      end
+    end
+
+    context 'with a db dump' do
+      let(:db_sql) do
+        File.join(restore_dir, "chef_backup-#{manifest['backup_time']}.sql")
+      end
+
+      let(:import_cmd) do
+        ['/opt/opscode/embedded/bin/chpst -u opscode-pgsql',
+         '/opt/opscode/embedded/bin/psql -U opscode-pgsql',
+         "-d opscode_chef < #{db_sql}"
+        ].join(' ')
+      end
+
+      before do
+        allow(subject)
+          .to receive(:ensure_file!)
+          .with(db_sql,
+                ChefBackup::Exceptions::InvalidDatabaseDump,
+                "#{db_sql} not found")
+          .and_return(true)
+      end
+
+      it 'imports the database' do
+        expect(subject).to receive(:shell_out!).with(import_cmd)
+        subject.import_db
+      end
+    end
+  end
+
+  describe '.touch_sentinel' do
+    let(:file) { double('File', write: true) }
+    let(:file_dir) { '/var/opt/opscode' }
+    let(:file_path) { File.join(file_dir, 'bootstrapped') }
+
+    before do
+      allow(FileUtils).to receive(:mkdir_p).with(file_dir).and_return(true)
+      allow(File).to receive(:open).with(file_path, 'w').and_yield(file)
+    end
+
+    it 'touches the bootstrap sentinel file' do
+      expect(file).to receive(:write).with('bootstrapped!')
+      subject.touch_sentinel
+    end
+  end
+end