vcloud-launcher 0.1.0 → 0.2.0

data/spec/vcloud/launcher/launch_spec.rb

@@ -68,7 +68,113 @@ describe Vcloud::Launcher::Launch do
       expect(Vcloud::Core.logger).to receive(:level=).with(Logger::INFO)
       subject.set_logging_level({})
     end
-
   end
 
+  describe "configuration validation" do
+    let(:config_file) { 'foo' }
+
+    before(:each) do
+      Vcloud::Core::ConfigLoader.any_instance.stub(:load_config).and_return(config)
+
+      allow(Vcloud::Launcher::VappOrchestrator).
+        to receive(:provision).and_return(double(:vapp, :power_on => true))
+    end
+
+    subject { Vcloud::Launcher::Launch.new }
+
+    context "when bootstrap configuration is supplied" do
+      context "script_path is missing" do
+        let(:config) do
+          { vapps: [
+              {
+                name: "test_vapp_name",
+                vdc_name: "Test VDC",
+                catalog_name: "default",
+                vapp_template_name: "ubuntu-precise",
+                bootstrap: {
+                  vars: { foo: 'bar' }
+                }
+              }
+            ]
+          }
+        end
+
+        it "raises MissingConfigurationError" do
+          expect{ subject.run(config_file) }.
+            to raise_error(Vcloud::Launcher::Launch::MissingConfigurationError)
+        end
+      end
+
+      context "script_path does not exist" do
+        let(:config) do
+          { vapps: [
+              {
+                name: "test_vapp_name",
+                vdc_name: "Test VDC",
+                catalog_name: "default",
+                vapp_template_name: "ubuntu-precise",
+                bootstrap: {
+                  script_path: 'nonexistent_preamble.sh.erb',
+                  vars: { foo: 'bar' }
+                }
+              }
+            ]
+          }
+        end
+
+        it "raises MissingPreambleError" do
+          expect{ subject.run(config_file) }.
+            to raise_error(Vcloud::Launcher::Launch::MissingPreambleError)
+        end
+      end
+
+      context "script_path is specified, without vars" do
+        # Avoid triggering exceptions on missing preamble file.
+        before do
+          File.stub(:exist?).and_return(true)
+          allow(Vcloud::Core.logger).to receive(:info)
+        end
+
+        let(:config) do
+          { vapps: [
+              {
+                name: "test_vapp_name",
+                vdc_name: "Test VDC",
+                catalog_name: "default",
+                vapp_template_name: "ubuntu-precise",
+                bootstrap: {
+                  script_path: 'nonexistent_preamble.sh.erb'
+                }
+              }
+            ]
+          }
+        end
+
+        it "logs an informative message" do
+          # A rather overly specific test to find the message of
+          # interest amongst other log messages.
+          expect(Vcloud::Core.logger).to receive(:info).with(/without variables to template/)
+          subject.run(config_file)
+        end
+      end
+    end
+
+    context "when bootstrap configuration is absent" do
+      let(:config) do
+        { vapps: [
+            {
+              name: "test_vapp_name",
+              vdc_name: "Test VDC",
+              catalog_name: "default",
+              vapp_template_name: "ubuntu-precise"
+            }
+          ]
+        }
+      end
+
+      it "should not raise an error" do
+        expect{ subject.run(config_file) }.not_to raise_error
+      end
+    end
+  end
 end

data/spec/vcloud/launcher/preamble_spec.rb

@@ -0,0 +1,214 @@
+require 'spec_helper'
+
+module Vcloud
+  module Launcher
+    describe Preamble do
+      subject { Vcloud::Launcher::Preamble }
+
+      let(:vm_name) { 'test-vm' }
+      let(:minimal_vm_config) do
+        { bootstrap: {
+            script_path: 'hello_world.erb',
+            vars: { bob: 'Hello', mary: 'Hola' }
+          }
+        }
+      end
+      let(:minimal_template) do
+        <<-'EOF'
+        vars:
+        bob: <%= vars[:bob] -%>.
+        mary: <%= vars[:mary] %>.
+        EOF
+      end
+      let(:minimal_template_output) do
+        <<-EOF
+        vars:
+        bob: Hello.
+        mary: Hola.
+        EOF
+      end
+      let(:minimal_template_lines) { 3 }
+
+      let(:complete_vm_config) do
+        { bootstrap: {
+            script_path: 'hello_world.erb',
+            script_post_processor: '/usr/bin/wc -l',
+            vars: { bob: 'Hello', mary: 'Hola' }
+          },
+          extra_disks: [
+            { size:  5120, fs_file: '/opt/test_disk1' },
+            { size: 10240, fs_file: '/opt/test_disk2' },
+          ]
+        }
+      end
+
+      describe 'public interface' do
+        describe 'instance methods' do
+          subject { Vcloud::Launcher::Preamble.new(vm_name, minimal_vm_config) }
+
+          it { should respond_to(:generate) }
+          it { should respond_to(:interpolated_preamble) }
+
+          it { should respond_to(:preamble_vars) }
+          it { should respond_to(:script_path) }
+        end
+      end
+
+      describe '#new' do
+        it "accepts complete configuration without error" do
+          expect { subject.new(vm_name, minimal_vm_config) }.not_to raise_error
+        end
+
+        context "when the preamble template is missing" do
+          let(:vm_config) do
+            { bootstrap: {
+                script_post_processor: 'remove_hello.rb',
+                vars: { bob: 'hello', mary: 'hola' }
+              }
+            }
+          end
+
+          it "raises a MissingTemplateError" do
+            expect { subject.new(vm_name, vm_config) }.
+              to raise_error( Vcloud::Launcher::Preamble::MissingTemplateError)
+          end
+        end
+
+        context "when bootstrap configuration is empty" do
+          it "raises a MissingConfigurationError" do
+            expect { subject.new(vm_name, {}) }.
+              to raise_error(Vcloud::Launcher::Preamble::MissingConfigurationError)
+          end
+        end
+
+        context "when vars are absent" do
+          let(:vm_config) do
+            { bootstrap: {
+                script_path: 'hello_world.erb',
+                script_post_processor: 'remove_hello.rb'
+              },
+            }
+          end
+
+          it "does not raise an error (allows for post-processing only)" do
+            expect { subject.new(vm_name, vm_config ) }.not_to raise_error
+          end
+        end
+
+        context "when vars are empty" do
+          let(:vm_config) do
+            { bootstrap: {
+                script_path: 'hello_world.erb',
+                script_post_processor: 'remove_hello.rb',
+                vars: {},
+              }
+            }
+          end
+
+          it "raises a MissingConfigurationError (allows for post-processing only)" do
+            expect { subject.new(vm_name, vm_config ) }.not_to raise_error
+          end
+        end
+
+        context "extra_disks" do
+          subject { Vcloud::Launcher::Preamble.new(vm_name, complete_vm_config) }
+
+          it "merges extra_disks into preamble_vars" do
+            expect( subject.preamble_vars ).to have_key(:extra_disks)
+          end
+        end
+      end
+
+      describe ".generate" do
+        subject { Vcloud::Launcher::Preamble.new(vm_name, minimal_vm_config) }
+
+        before(:each) do
+          subject.stub(:load_erb_file).and_return(minimal_template)
+        end
+
+        it "invokes .interpolate_preamble_erb_file" do
+          subject.should_receive(:interpolate_erb_file)
+          subject.generate
+        end
+
+        context "interpolating variables" do
+          subject { Vcloud::Launcher::Preamble.new(vm_name, minimal_vm_config) }
+
+          context "environment variables" do
+            before(:each) do
+              stub_const('ENV', {'TEST_INTERPOLATED_ENVVAR' => 'test_interpolated_env'})
+              subject.stub(:load_erb_file).and_return('env_var: <%= ENV["TEST_INTERPOLATED_ENVVAR"] -%>')
+            end
+
+            it "interpolates environment variables into template" do
+              expect(subject.generate).to eq 'env_var: test_interpolated_env'
+            end
+          end
+
+          context "vars hash" do
+            before(:each) do
+              subject.stub(:load_erb_file).and_return(minimal_template)
+            end
+
+            it "interpolates vars hash into template" do
+              expect(subject.generate).to eq minimal_template_output
+            end
+          end
+
+          context "vapp_name" do
+            before(:each) do
+              subject.stub(:load_erb_file).and_return('vapp_name: <%= vapp_name -%>')
+            end
+
+            it "interpolates vapp_name into template" do
+              expect(subject.generate).to eq "vapp_name: #{vm_name}"
+            end
+          end
+        end
+
+        context "when a post processor is supplied" do
+          let(:vm_config) do
+            { bootstrap: {
+                script_path: 'hello_world.erb',
+                script_post_processor: '/usr/bin/wc -l',
+                vars: { bob: 'hello', mary: 'hola' }
+              }
+            }
+          end
+
+          let(:template) do
+            <<-EOF
+            one
+            two
+            three
+            EOF
+          end
+
+          subject { Vcloud::Launcher::Preamble.new(vm_name, vm_config) }
+
+          before(:each) do
+            subject.stub(:load_erb_file).and_return(template)
+          end
+
+          it "invokes .post_process_erb_output" do
+            subject.should_receive(:post_process_erb_output)
+            subject.generate
+          end
+
+          it "returns the post-processed interpolated template" do
+            expect(subject.generate).to match(/\s*#{minimal_template_lines}/)
+          end
+        end
+
+        describe ".interpolated_preamble" do
+          subject { Vcloud::Launcher::Preamble.new(vm_name, minimal_vm_config) }
+
+          it "returns the interpolated template" do
+            expect(subject.interpolated_preamble).to eq minimal_template_output
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/vcloud/launcher/vapp_orchestrator_spec.rb

@@ -31,25 +31,25 @@ describe Vcloud::Launcher::VappOrchestrator do
     it "should return a vapp if it already exists" do
       existing_vapp = double(:vapp, :name => 'existing-vapp-1')
 
-      Vcloud::Core::Vapp.should_receive(:get_by_name_and_vdc_name).with('test-vapp-1', 'test-vdc-1').and_return(existing_vapp)
-      Vcloud::Core.logger.should_receive(:info).with('Found existing vApp test-vapp-1 in vDC \'test-vdc-1\'. Skipping.')
+      expect(Vcloud::Core::Vapp).to receive(:get_by_name_and_vdc_name).with('test-vapp-1', 'test-vdc-1').and_return(existing_vapp)
+      expect(Vcloud::Core.logger).to receive(:info).with('Found existing vApp test-vapp-1 in vDC \'test-vdc-1\'. Skipping.')
       actual_vapp = subject.provision @config
-      actual_vapp.should_not be_nil
-      actual_vapp.should == existing_vapp
+      expect(actual_vapp).not_to be_nil
+      expect(actual_vapp).to eq(existing_vapp)
     end
 
     it "should create a vapp if it does not exist" do
       #this test highlights the problems in vapp
 
-      Vcloud::Core::Vapp.should_receive(:get_by_name_and_vdc_name).with('test-vapp-1', 'test-vdc-1').and_return(nil)
-      Vcloud::Core::VappTemplate.should_receive(:get).with('org-1-template', 'org-1-catalog').and_return(double(:vapp_template, :id => 1))
+      expect(Vcloud::Core::Vapp).to receive(:get_by_name_and_vdc_name).with('test-vapp-1', 'test-vdc-1').and_return(nil)
+      expect(Vcloud::Core::VappTemplate).to receive(:get).with('org-1-template', 'org-1-catalog').and_return(double(:vapp_template, :id => 1))
 
-      Vcloud::Core::Vapp.should_receive(:instantiate).with('test-vapp-1', ['org-vdc-1-net-1'], 1, 'test-vdc-1')
+      expect(Vcloud::Core::Vapp).to receive(:instantiate).with('test-vapp-1', ['org-vdc-1-net-1'], 1, 'test-vdc-1')
       .and_return(mock_vapp)
-      Vcloud::Launcher::VmOrchestrator.should_receive(:new).with(mock_fog_vm, mock_vapp).and_return(mock_vm_orchestrator)
+      expect(Vcloud::Launcher::VmOrchestrator).to receive(:new).with(mock_fog_vm, mock_vapp).and_return(mock_vm_orchestrator)
 
       new_vapp = subject.provision @config
-      new_vapp.should == mock_vapp
+      expect(new_vapp).to eq(mock_vapp)
     end
 
     context "deprecated config items" do
@@ -57,9 +57,9 @@ describe Vcloud::Launcher::VappOrchestrator do
         double(:vapp_template, :id => 2)
       }
       before(:each) {
-        Vcloud::Core::Vapp.stub(:get_by_name_and_vdc_name)
-        Vcloud::Core::Vapp.stub(:instantiate).and_return(mock_vapp)
-        Vcloud::Launcher::VmOrchestrator.stub(:new).and_return(mock_vm_orchestrator)
+        allow(Vcloud::Core::Vapp).to receive(:get_by_name_and_vdc_name)
+        allow(Vcloud::Core::Vapp).to receive(:instantiate).and_return(mock_vapp)
+        allow(Vcloud::Launcher::VmOrchestrator).to receive(:new).and_return(mock_vm_orchestrator)
       }
 
       it "should use catalog_item when vapp_template_name is not present" do
@@ -67,7 +67,7 @@ describe Vcloud::Launcher::VappOrchestrator do
         config.delete(:vapp_template_name)
         config[:catalog_item] = 'deprecated-template'
 
-        Vcloud::Core::VappTemplate.should_receive(:get).with('deprecated-template', 'org-1-catalog').and_return(mock_vapp_template)
+        expect(Vcloud::Core::VappTemplate).to receive(:get).with('deprecated-template', 'org-1-catalog').and_return(mock_vapp_template)
         Vcloud::Launcher::VappOrchestrator.provision(config)
       end
 
@@ -76,7 +76,7 @@ describe Vcloud::Launcher::VappOrchestrator do
         config.delete(:catalog_name)
         config[:catalog] = 'deprecated-catalog'
 
-        Vcloud::Core::VappTemplate.should_receive(:get).with('org-1-template', 'deprecated-catalog').and_return(mock_vapp_template)
+        expect(Vcloud::Core::VappTemplate).to receive(:get).with('org-1-template', 'deprecated-catalog').and_return(mock_vapp_template)
         Vcloud::Launcher::VappOrchestrator.provision(config)
       end
     end

data/spec/vcloud/launcher/vm_orchestrator_spec.rb

@@ -16,7 +16,7 @@ describe Vcloud::Launcher::VmOrchestrator do
     Vcloud::Launcher::VmOrchestrator.new(fog_vm, vapp)
   }
 
-  it "orchestrate customization" do
+  it "orchestrates customization" do
     vm_config = {
         :hardware_config => {
             :memory => 4096,
@@ -33,28 +33,23 @@ describe Vcloud::Launcher::VmOrchestrator do
         :network_connections => [
             {:name => "network1", :ip_address => "198.12.1.21"},
         ],
-        :bootstrap => {
-            :script_path => '/tmp/boostrap.erb',
-            :vars => {
-                :message => 'hello world'
-            }
-        },
         :storage_profile => {
             :name => 'basic-storage',
             :href => 'https://vcloud.example.net/api/vdcStorageProfile/000aea1e-a5e9-4dd1-a028-40db8c98d237'
         }
     }
     vm = double(:vm, :id => @vm_id, :vapp_name => 'web-app1', :vapp => vapp, :name => 'test-vm-1')
-    Vcloud::Core::Vm.should_receive(:new).with(@vm_id, vapp).and_return(vm)
+    expect(Vcloud::Core::Vm).to receive(:new).with(@vm_id, vapp).and_return(vm)
+
+    expect(vm).to receive(:update_name).with('web-app1')
+    expect(vm).to receive(:configure_network_interfaces).with(vm_config[:network_connections])
+    expect(vm).to receive(:update_storage_profile).with(vm_config[:storage_profile])
+    expect(vm).to receive(:update_cpu_count).with(2)
+    expect(vm).to receive(:update_memory_size_in_mb).with(4096)
+    expect(vm).to receive(:add_extra_disks).with(vm_config[:extra_disks])
+    expect(vm).to receive(:update_metadata).with(vm_config[:metadata])
 
-    vm.should_receive(:update_name).with('web-app1')
-    vm.should_receive(:configure_network_interfaces).with(vm_config[:network_connections])
-    vm.should_receive(:update_storage_profile).with(vm_config[:storage_profile])
-    vm.should_receive(:update_cpu_count).with(2)
-    vm.should_receive(:update_memory_size_in_mb).with(4096)
-    vm.should_receive(:add_extra_disks).with(vm_config[:extra_disks])
-    vm.should_receive(:update_metadata).with(vm_config[:metadata])
-    vm.should_receive(:configure_guest_customization_section).with('web-app1', vm_config[:bootstrap], vm_config[:extra_disks])
+    allow(vm).to receive(:configure_guest_customization_section).with('')
 
     subject.customize(vm_config)
   end
@@ -69,14 +64,106 @@ describe Vcloud::Launcher::VmOrchestrator do
         {:size => '2048', :name => 'Hard disk 3', :fs_file => 'solr', :fs_mntops => 'solr-something'}
       ]
     }
-    Vcloud::Core::Vm.should_receive(:new).with(@vm_id, vapp).and_return(vm)
-    vm.should_receive(:update_metadata).with(:shutdown => true)
-    vm.should_receive(:update_name).with('web-app1')
-    vm.should_receive(:add_extra_disks).with(vm_config[:extra_disks])
-    vm.should_receive(:configure_network_interfaces).with(vm_config[:network_connections])
-    vm.should_receive(:configure_guest_customization_section).with('web-app1', vm_config[:bootstrap], vm_config[:extra_disks])
+    expect(Vcloud::Core::Vm).to receive(:new).with(@vm_id, vapp).and_return(vm)
+    expect(vm).to receive(:update_metadata).with(:shutdown => true)
+    expect(vm).to receive(:update_name).with('web-app1')
+    expect(vm).to receive(:add_extra_disks).with(vm_config[:extra_disks])
+    expect(vm).to receive(:configure_network_interfaces).with(vm_config[:network_connections])
+
+    allow(vm).to receive(:configure_guest_customization_section)
 
     subject.customize(vm_config)
+  end
+
+  context "when customizing a VM" do
+    let(:vm_config_with_bootstrap) do
+      {
+        hardware_config: {
+          memory: 4096,
+          cpu: 2
+        },
+        network_connections: [
+          { name: "network1", ip_address: "198.12.1.21" }
+        ],
+        bootstrap: {
+          script_path: '/tmp/bootstrap.erb',
+          vars: { message: 'hello world' }
+        }
+      }
+    end
+
+    let(:vm_config_without_bootstrap) do
+      {
+        hardware_config: {
+          memory: 4096,
+          cpu: 2
+        },
+        network_connections: [
+          { name: "network1", ip_address: "198.12.1.21" }
+        ]
+      }
+    end
+
+    let(:vm) { double(:vm, id: @vm_id, vapp_name: 'web-app1', vapp: vapp, name: 'test-vm-1') }
+
+    before(:each) do
+      Vcloud::Core::Vm.stub(:new).and_return(vm)
+      allow(vm).to receive(:update_name)
+      allow(vm).to receive(:configure_network_interfaces)
+      allow(vm).to receive(:update_cpu_count)
+      allow(vm).to receive(:update_memory_size_in_mb)
+      allow(vm).to receive(:add_extra_disks)
+      allow(vm).to receive(:update_metadata)
+    end
+
+    context "when bootstrap configuration is omitted" do
+      before { allow(vm).to receive(:configure_guest_customization_section) }
+
+      it "skips preamble processing" do
+        expect(Vcloud::Launcher::Preamble).not_to receive(:new)
+        expect(Vcloud::Launcher::Preamble).not_to receive(:generate)
+
+        subject.customize(vm_config_without_bootstrap)
+      end
+
+      it "uses an empty string as the host preamble" do
+        expect(vm).to receive(:configure_guest_customization_section).with('')
+        subject.customize(vm_config_without_bootstrap)
+      end
+    end
+
+    context "when bootstrap configuration is supplied" do
+      context "Vcloud::Launcher::Preamble used to generate a preamble" do
+        it "instantiates Vcloud::Launcher::Preamble" do
+          preamble = double
+          allow(preamble).to receive(:generate)
+          allow(vm).to receive(:configure_guest_customization_section)
+
+          expect(Vcloud::Launcher::Preamble).to receive(:new).with(vm.vapp_name, vm_config_with_bootstrap).and_return(preamble)
+
+          subject.customize(vm_config_with_bootstrap)
+        end
+
+        it "uses Vcloud::Launcher::Preamble.generate to template a preamble" do
+          preamble = double
+          allow(Vcloud::Launcher::Preamble).to receive(:new).with(vm.vapp_name, vm_config_with_bootstrap).and_return(preamble)
+          allow(vm).to receive(:configure_guest_customization_section)
+
+          expect(preamble).to receive(:generate)
+
+          subject.customize(vm_config_with_bootstrap)
+        end
+
+        it "passes the generated preamble to configure_guest_customization_section" do
+          preamble = double
+          allow(Vcloud::Launcher::Preamble).to receive(:new).with(vm.vapp_name, vm_config_with_bootstrap).and_return(preamble)
+          allow(preamble).to receive(:generate).and_return('FAKE_PREAMBLE')
+
+          expect(vm).to receive(:configure_guest_customization_section).with('FAKE_PREAMBLE')
 
+          subject.customize(vm_config_with_bootstrap)
+        end
+      end
+    end
   end
 end