bosh-stemcell 1.5.0.pre.1113

data/spec/bosh/stemcell/builder_options_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+require 'bosh/stemcell/builder_options'
+require 'bosh/stemcell/infrastructure'
+require 'bosh/stemcell/operating_system'
+
+module Bosh::Stemcell
+  describe BuilderOptions do
+    subject(:stemcell_builder_options) { described_class.new(env, options) }
+    let(:env) { {} }
+    let(:options) do
+      {
+        tarball: 'fake/release.tgz',
+        stemcell_version: '007',
+        infrastructure: infrastructure,
+        operating_system: operating_system
+      }
+    end
+
+    let(:infrastructure) { Infrastructure.for('aws') }
+    let(:operating_system) { OperatingSystem.for('ubuntu') }
+    let(:expected_source_root) { File.expand_path('../../../../..', __FILE__) }
+    let(:archive_filename) { instance_double('Bosh::Stemcell::ArchiveFilename', to_s: 'FAKE_STEMCELL.tgz') }
+
+    before do
+      ArchiveFilename.stub(:new).
+        with('007', infrastructure, operating_system, 'bosh-stemcell', false).and_return(archive_filename)
+    end
+
+    describe '#initialize' do
+      context 'when :tarball is not set' do
+        before { options.delete(:tarball) }
+
+        it 'dies' do
+          expect { stemcell_builder_options }.to raise_error('key not found: :tarball')
+        end
+      end
+
+      context 'when :stemcell_version is not set' do
+        before { options.delete(:stemcell_version) }
+
+        it 'dies' do
+          expect { stemcell_builder_options }.to raise_error('key not found: :stemcell_version')
+        end
+      end
+
+      context 'when :infrastructure is not set' do
+        before { options.delete(:infrastructure) }
+
+        it 'dies' do
+          expect { stemcell_builder_options }.to raise_error('key not found: :infrastructure')
+        end
+      end
+
+      context 'when :operating_system is not set' do
+        before { options.delete(:operating_system) }
+
+        it 'dies' do
+          expect { stemcell_builder_options }.to raise_error('key not found: :operating_system')
+        end
+      end
+    end
+
+    describe '#default' do
+      let(:default_disk_size) { 2048 }
+      let(:rake_args) { {} }
+
+      it 'sets stemcell_tgz' do
+        result = stemcell_builder_options.default
+        expect(result['stemcell_tgz']).to eq(archive_filename.to_s)
+      end
+
+      it 'sets stemcell_image_name' do
+        result = stemcell_builder_options.default
+        expected_image_name = "#{infrastructure.name}-#{infrastructure.hypervisor}-#{operating_system.name}.raw"
+        expect(result['stemcell_image_name']).to eq(expected_image_name)
+      end
+
+      it 'sets stemcell_version' do
+        result = stemcell_builder_options.default
+        expect(result['stemcell_version']).to eq('007')
+      end
+
+      # rubocop:disable MethodLength
+      def self.it_sets_correct_environment_variables
+        describe 'setting enviroment variables' do
+          let(:env) do
+            {
+              'UBUNTU_ISO' => 'fake_ubuntu_iso',
+              'UBUNTU_MIRROR' => 'fake_ubuntu_mirror',
+              'RUBY_BIN' => 'fake_ruby_bin',
+            }
+          end
+
+          it 'sets default values for options based in hash' do
+            expected_release_micro_manifest_path =
+              File.join(expected_source_root, "release/micro/#{infrastructure.name}.yml")
+
+            result = stemcell_builder_options.default
+
+            expect(result['stemcell_name']).to eq(
+              "bosh-#{infrastructure.name}-#{infrastructure.hypervisor}-#{operating_system.name}")
+            expect(result['stemcell_operating_system']).to eq(operating_system.name)
+            expect(result['stemcell_infrastructure']).to eq(infrastructure.name)
+            expect(result['stemcell_hypervisor']).to eq(infrastructure.hypervisor)
+            expect(result['bosh_protocol_version']).to eq('1')
+            expect(result['UBUNTU_ISO']).to eq('fake_ubuntu_iso')
+            expect(result['UBUNTU_MIRROR']).to eq('fake_ubuntu_mirror')
+            expect(result['ruby_bin']).to eq('fake_ruby_bin')
+            expect(result['bosh_release_src_dir']).to eq(File.join(expected_source_root, '/release/src/bosh'))
+            expect(result['bosh_agent_src_dir']).to eq(File.join(expected_source_root, 'bosh_agent'))
+            expect(result['image_create_disk_size']).to eq(default_disk_size)
+            expect(result['bosh_micro_enabled']).to eq('yes')
+            expect(result['bosh_micro_package_compiler_path']).to eq(
+              File.join(expected_source_root, 'bosh-release'))
+            expect(result['bosh_micro_manifest_yml_path']).to eq(expected_release_micro_manifest_path)
+            expect(result['bosh_micro_release_tgz_path']).to eq('fake/release.tgz')
+          end
+
+          context 'when RUBY_BIN is not set' do
+            before { env.delete('RUBY_BIN') }
+
+            before do
+              RbConfig::CONFIG.stub(:[]).with('bindir').and_return('/a/path/to/')
+              RbConfig::CONFIG.stub(:[]).with('ruby_install_name').and_return('ruby')
+            end
+
+            it 'uses the RbConfig values' do
+              result = stemcell_builder_options.default
+
+              expect(result['ruby_bin']).to eq('/a/path/to/ruby')
+            end
+          end
+
+          context 'when disk_size is not passed' do
+            it 'defaults to default disk size for infrastructure' do
+              result = stemcell_builder_options.default
+
+              expect(result['image_create_disk_size']).to eq(default_disk_size)
+            end
+          end
+
+          context 'when disk_size is passed' do
+            before { options.merge!(disk_size: 1234) }
+
+            it 'allows user to override default disk_size' do
+              result = stemcell_builder_options.default
+
+              expect(result['image_create_disk_size']).to eq(1234)
+            end
+          end
+        end
+      end
+      # rubocop:enable MethodLength
+
+      describe 'infrastructure variation' do
+        context 'when infrastruture is aws' do
+          let(:infrastructure) { Infrastructure.for('aws') }
+
+          it_sets_correct_environment_variables
+
+          it 'has no "image_vsphere_ovf_ovftool_path" key' do
+            expect(stemcell_builder_options.default).not_to have_key('image_vsphere_ovf_ovftool_path')
+          end
+        end
+
+        context 'when infrastruture is vsphere' do
+          let(:infrastructure) { Infrastructure.for('vsphere') }
+
+          it_sets_correct_environment_variables
+
+          it 'has an "image_vsphere_ovf_ovftool_path" key' do
+            result = stemcell_builder_options.default
+
+            expect(result['image_vsphere_ovf_ovftool_path']).to be_nil
+          end
+
+          context 'if you have OVFTOOL set in the environment' do
+            let(:env) { { 'OVFTOOL' => 'fake_ovf_tool_path' } }
+
+            it 'sets image_vsphere_ovf_ovftool_path' do
+              result = stemcell_builder_options.default
+
+              expect(result['image_vsphere_ovf_ovftool_path']).to eq('fake_ovf_tool_path')
+            end
+          end
+        end
+
+        context 'when infrastructure is openstack' do
+          let(:infrastructure) { Infrastructure.for('openstack') }
+          let(:default_disk_size) { 10240 }
+
+          it_sets_correct_environment_variables
+
+          it 'has no "image_vsphere_ovf_ovftool_path" key' do
+            expect(stemcell_builder_options.default).not_to have_key('image_vsphere_ovf_ovftool_path')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/bosh/stemcell/disk_image_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+require 'bosh/stemcell/disk_image'
+
+module Bosh::Stemcell
+  describe DiskImage do
+    let(:shell) { instance_double('Bosh::Core::Shell', run: nil) }
+
+    let(:kpartx_map_output) { 'add map FAKE_LOOP1p1 (252:3): 0 3997984 linear /dev/loop1 63' }
+    let(:options) do
+      {
+        image_file_path: '/path/to/FAKE_IMAGE',
+        image_mount_point: '/fake/mnt'
+      }
+    end
+
+    subject(:disk_image) { DiskImage.new(options) }
+
+    before do
+      Bosh::Core::Shell.stub(:new).and_return(shell)
+    end
+
+    describe '#initialize' do
+      it 'requires an image_file_path' do
+        options.delete(:image_file_path)
+        expect { DiskImage.new(options) }.to raise_error /key not found: :image_file_path/
+      end
+
+      it 'requires an mount_point' do
+        options.delete(:image_mount_point)
+
+        dir_mock = class_double('Dir').as_stubbed_const
+        dir_mock.should_receive(:mktmpdir).and_return('/fake/tmpdir')
+
+        expect(DiskImage.new(options).image_mount_point).to eq('/fake/tmpdir')
+      end
+    end
+
+    describe '#mount' do
+      it 'maps the file to a loop device' do
+        losetup_commad = 'sudo losetup --show --find /path/to/FAKE_IMAGE'
+        shell.stub(:run).with(losetup_commad, output_command: false).and_return('/dev/loop0')
+        shell.should_receive(:run).with('sudo kpartx -av /dev/loop0',
+                                        output_command: false).and_return(kpartx_map_output)
+
+        disk_image.mount
+      end
+
+      it 'mounts the loop device' do
+        losetup_commad = 'sudo losetup --show --find /path/to/FAKE_IMAGE'
+        shell.stub(:run).with(losetup_commad, output_command: false).and_return('/dev/loop0')
+        shell.stub(:run).with('sudo kpartx -av /dev/loop0', output_command: false).and_return(kpartx_map_output)
+
+        shell.should_receive(:run).with('sudo mount /dev/mapper/FAKE_LOOP1p1 /fake/mnt', output_command: false)
+
+        disk_image.mount
+      end
+
+      context 'when the device does not exist' do
+        let(:mount_command) do
+          'sudo mount /dev/mapper/FAKE_LOOP1p1 /fake/mnt'
+        end
+
+        let(:mount_error) do
+          "Failed: '#{mount_command}' from /fake/mnt/blah/blah/bosh-stemcell, with exit status 8192\n\n"
+        end
+
+        before do
+          disk_image.stub(:sleep)
+        end
+
+        it 'runs mount a second time after sleeping long enough for the device node to be created' do
+          losetup_commad = 'sudo losetup --show --find /path/to/FAKE_IMAGE'
+          shell.stub(:run).with(losetup_commad, output_command: false).and_return('/dev/loop0')
+          shell.stub(:run).with('sudo kpartx -av /dev/loop0', output_command: false).and_return(kpartx_map_output)
+          shell.should_receive(:run).with(mount_command, output_command: false).ordered.and_raise(mount_error)
+          disk_image.should_receive(:sleep).with(0.5)
+          shell.should_receive(:run).with(mount_command, output_command: false).ordered
+
+          disk_image.mount
+        end
+
+        context 'when the second mount command fails' do
+          it 'raises an error' do
+            losetup_commad = 'sudo losetup --show --find /path/to/FAKE_IMAGE'
+            shell.stub(:run).with(losetup_commad, output_command: false).and_return('/dev/loop0')
+            shell.stub(:run).with('sudo kpartx -av /dev/loop0', output_command: false).and_return(kpartx_map_output)
+            shell.should_receive(:run).with(mount_command, output_command: false).ordered.twice.and_raise(mount_error)
+
+            expect { disk_image.mount }.to raise_error(mount_error)
+          end
+        end
+      end
+
+      context 'when the mount command fails' do
+        it 'runs mount a second time' do
+          losetup_commad = 'sudo losetup --show --find /path/to/FAKE_IMAGE'
+          shell.stub(:run).with(losetup_commad, output_command: false).and_return('/dev/loop0')
+          shell.stub(:run).with('sudo kpartx -av /dev/loop0', output_command: false).and_return(kpartx_map_output)
+          shell.should_receive(:run).
+            with('sudo mount /dev/mapper/FAKE_LOOP1p1 /fake/mnt', output_command: false).ordered.
+            and_raise(RuntimeError, 'UNEXEPECTED')
+
+          expect { disk_image.mount }.to raise_error(RuntimeError, 'UNEXEPECTED')
+        end
+      end
+    end
+
+    describe '#unmount' do
+      before do
+        disk_image.stub(device: '/dev/loop0') # pretend we've mounted
+      end
+
+      it 'unmounts the loop device and then unmaps the file' do
+        shell.should_receive(:run).with('sudo umount /fake/mnt', output_command: false).ordered
+        shell.should_receive(:run).with('sudo kpartx -dv /dev/loop0', output_command: false).ordered
+        shell.should_receive(:run).with('sudo losetup -dv /dev/loop0', output_command: false).ordered
+
+        disk_image.unmount
+      end
+
+      it 'unmaps the file even if unmounting the device fails' do
+        shell.should_receive(:run).with('sudo umount /fake/mnt', output_command: false).and_raise
+        shell.should_receive(:run).with('sudo kpartx -dv /dev/loop0', output_command: false).ordered
+        shell.should_receive(:run).with('sudo losetup -dv /dev/loop0', output_command: false).ordered
+
+        expect { disk_image.unmount }.to raise_error
+      end
+    end
+
+    describe '#while_mounted' do
+      it 'mounts the disk, calls the provided block, and unmounts' do
+        fake_thing = double('FakeThing')
+        losetup_commad = 'sudo losetup --show --find /path/to/FAKE_IMAGE'
+        shell.stub(:run).with(losetup_commad, output_command: false).and_return('/dev/loop0')
+        shell.stub(:run).with('sudo kpartx -av /dev/loop0', output_command: false).and_return(kpartx_map_output)
+        shell.should_receive(:run).with('sudo mount /dev/mapper/FAKE_LOOP1p1 /fake/mnt', output_command: false)
+        fake_thing.should_receive(:fake_call).with(disk_image).ordered
+        shell.should_receive(:run).with('sudo umount /fake/mnt', output_command: false).ordered
+        shell.should_receive(:run).with('sudo kpartx -dv /dev/loop0', output_command: false).ordered
+        shell.should_receive(:run).with('sudo losetup -dv /dev/loop0', output_command: false).ordered
+
+        disk_image.while_mounted do |image|
+          fake_thing.fake_call(image)
+        end
+      end
+
+      context 'when the block raises and error' do
+        it 'mounts the disk, calls the provided block, and unmounts' do
+          losetup_commad = 'sudo losetup --show --find /path/to/FAKE_IMAGE'
+          shell.stub(:run).with(losetup_commad, output_command: false).and_return('/dev/loop0')
+          shell.stub(:run).with('sudo kpartx -av /dev/loop0', output_command: false).and_return(kpartx_map_output)
+          shell.should_receive(:run).with('sudo mount /dev/mapper/FAKE_LOOP1p1 /fake/mnt', output_command: false)
+
+          shell.should_receive(:run).with('sudo umount /fake/mnt', output_command: false).ordered
+          shell.should_receive(:run).with('sudo kpartx -dv /dev/loop0', output_command: false).ordered
+          shell.should_receive(:run).with('sudo losetup -dv /dev/loop0', output_command: false).ordered
+
+          expect { disk_image.while_mounted { |_| raise } }.to raise_error
+        end
+      end
+    end
+  end
+end

data/spec/bosh/stemcell/infrastructure_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'bosh/stemcell/infrastructure'
+
+module Bosh::Stemcell
+  describe Infrastructure do
+    describe '.for' do
+      it 'returns the correct infrastrcture' do
+        expect(Infrastructure.for('openstack')).to be_an(Infrastructure::OpenStack)
+        expect(Infrastructure.for('aws')).to be_an(Infrastructure::Aws)
+        expect(Infrastructure.for('vsphere')).to be_a(Infrastructure::Vsphere)
+      end
+
+      it 'raises for unknown instructures' do
+        expect {
+          Infrastructure.for('BAD_INFRASTRUCTURE')
+        }.to raise_error(ArgumentError, /invalid infrastructure: BAD_INFRASTRUCTURE/)
+      end
+    end
+  end
+
+  describe Infrastructure::Base do
+    it 'requires a name to be specified' do
+      expect {
+        Infrastructure::Base.new
+      }.to raise_error /key not found: :name/
+    end
+
+    it 'requires a hypervisor' do
+      expect {
+        Infrastructure::Base.new(name: 'foo', default_disk_size: 1024)
+      }.to raise_error /key not found: :hypervisor/
+    end
+
+    it 'requires a default_disk_size' do
+      expect {
+        Infrastructure::Base.new(name: 'foo', hypervisor: 'xen')
+      }.to raise_error /key not found: :default_disk_size/
+    end
+
+    it 'defaults to not supporting light stemcells' do
+      infrastructure = Infrastructure::Base.new(name: 'foo', hypervisor: 'bar', default_disk_size: 1024)
+      expect(infrastructure).not_to be_light
+    end
+  end
+
+  describe Infrastructure::Aws do
+    its(:name)              { should eq('aws') }
+    its(:hypervisor)        { should eq('xen') }
+    its(:default_disk_size) { should eq(2048) }
+    it { should be_light }
+  end
+
+  describe Infrastructure::OpenStack do
+    its(:name)              { should eq('openstack') }
+    its(:hypervisor)        { should eq('kvm') }
+    its(:default_disk_size) { should eq(10240) }
+    it { should_not be_light }
+  end
+
+  describe Infrastructure::Vsphere do
+    its(:name)              { should eq('vsphere') }
+    its(:hypervisor)        { should eq('esxi') }
+    its(:default_disk_size) { should eq(2048) }
+    it { should_not be_light }
+  end
+end

data/spec/bosh/stemcell/operating_system_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'bosh/stemcell/operating_system'
+
+module Bosh::Stemcell
+  describe OperatingSystem do
+    describe '.for' do
+      it 'returns the correct infrastrcture' do
+        expect(OperatingSystem.for('centos')).to be_a(OperatingSystem::Centos)
+        expect(OperatingSystem.for('ubuntu')).to be_a(OperatingSystem::Ubuntu)
+      end
+
+      it 'raises for unknown operating system' do
+        expect {
+          OperatingSystem.for('BAD_OPERATING_SYSTEM')
+        }.to raise_error(ArgumentError, /invalid operating system: BAD_OPERATING_SYSTEM/)
+      end
+    end
+  end
+
+  describe OperatingSystem::Base do
+    describe '#initialize' do
+      it 'requires :name to be specified' do
+        expect {
+          OperatingSystem::Base.new
+        }.to raise_error /key not found: :name/
+      end
+    end
+
+    describe '#name' do
+      subject { OperatingSystem::Base.new(name: 'CLOUDY_PONY_OS') }
+
+      its(:name) { should eq('CLOUDY_PONY_OS') }
+    end
+  end
+
+  describe OperatingSystem::Centos do
+    subject { OperatingSystem::Centos.new }
+
+    its(:name) { should eq('centos') }
+  end
+
+  describe OperatingSystem::Ubuntu do
+    subject { OperatingSystem::Ubuntu.new }
+
+    its(:name) { should eq('ubuntu') }
+  end
+end