chef_backup 0.0.1 → 0.2.0

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

@@ -1,327 +0,0 @@
-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 'when config_only is true' do
-      before do
-        private_chef('backup' => { 'config_only' => true })
-      end
-
-      it_behaves_like 'a tar based backup'
-      it_behaves_like 'a tar based frontend'
-    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 standalone' 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(:pg_options) { ["PGOPTIONS=#{ChefBackup::Helpers::DEFAULT_PG_OPTIONS}"] }
-    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, env: pg_options).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, env: pg_options)
-          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 add_ha_info).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 'when config_only is true' do
-      before do
-        private_chef('role' => 'standalone', 'backup' => { 'config_only' => true })
-        data_mock = double('DataMap')
-        allow(subject).to receive(:data_map).and_return(data_mock)
-      end
-
-      it 'populates the data map with config and upgrade directories only' do
-        configs.each do |config|
-          expect(subject.data_map)
-            .to receive(:add_config)
-            .with(config, "/etc/#{config}")
-        end
-
-        expect(subject.data_map)
-          .to receive(:add_service)
-          .with('upgrades', '/var/opt/opscode/upgrades')
-
-        subject.populate_data_map
-      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
-
-  describe '.pg_dump?' do
-    it 'returns true' do
-      expect(subject.pg_dump?).to eq(true)
-    end
-
-    context 'when db dump is disabled' do
-      before { private_chef('backup' => { 'always_dump_db' => false }) }
-
-      it 'returns false' do
-        expect(subject.pg_dump?).to eq(false)
-      end
-    end
-  end
-end

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

@@ -1,84 +0,0 @@
-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

@@ -1,255 +0,0 @@
-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 restart_add_ons
-      ).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)
-      allow(subject).to receive(:marketplace?).and_return(false)
-    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
-
-      context 'on a marketplace all-in-one' do
-        before do
-          allow(subject).to receive(:marketplace?).and_return(true)
-          allow(subject).to receive(:reconfigure_marketplace?).and_return(true)
-        end
-
-        it 'sets up chef-marketplace' do
-          expect(subject).to receive(:reconfigure_marketplace).once
-          subject.restore
-        end
-
-        it_behaves_like 'a tar based backend restore'
-      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
-    let(:pg_options) { ["PGOPTIONS=#{ChefBackup::Helpers::DEFAULT_PG_OPTIONS}"] }
-
-    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, env: pg_options)
-        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

data/spec/unit/strategy_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe ChefBackup::Strategy do
-  before do
-    # Backup Tester
-    class ChefBackup::Strategy::TestBackup
-      def initialize(_p = {})
-      end
-    end
-
-    # Restore Tester
-    class ChefBackup::Strategy::TestRestore
-      def initialize(_p = {})
-      end
-    end
-  end
-
-  after do
-    described_class.send(:remove_const, :TestBackup)
-    described_class.send(:remove_const, :TestRestore)
-  end
-
-  describe '.backup' do
-    it 'it returns a backup strategy' do
-      expect(described_class.backup('test'))
-        .to be_an(ChefBackup::Strategy::TestBackup)
-    end
-  end
-
-  describe '.restore' do
-    it 'it returns a restore strategy' do
-      expect(described_class.restore('test', '/some/backup.tgz'))
-        .to be_an(ChefBackup::Strategy::TestRestore)
-    end
-  end
-end