vcloud-launcher 0.0.1

data/features/step_definitions/vcloud-launch_steps.rb

@@ -0,0 +1,3 @@
+Then(/^the banner should document that this app takes (\d+) argument$/) do |arg1|
+   pending # express the regexp above with the code you wish you had
+end

data/features/support/env.rb

@@ -0,0 +1,16 @@
+require 'aruba/cucumber'
+require 'methadone/cucumber'
+
+ENV['PATH'] = "#{File.expand_path(File.dirname(__FILE__) + '/../../bin')}#{File::PATH_SEPARATOR}#{ENV['PATH']}"
+LIB_DIR = File.join(File.expand_path(File.dirname(__FILE__)),'..','..','lib')
+
+Before do
+  # Using "announce" causes massive warnings on 1.9.2
+  @puts = true
+  @original_rubylib = ENV['RUBYLIB']
+  ENV['RUBYLIB'] = LIB_DIR + File::PATH_SEPARATOR + ENV['RUBYLIB'].to_s
+end
+
+After do
+  ENV['RUBYLIB'] = @original_rubylib
+end

data/features/vcloud-launch.feature

@@ -0,0 +1,16 @@
+Feature: "vcloud-launch" works as a useful command-line tool
+  In order to use "vcloud-launch" from the CLI
+  I want to have it behave like a typical Unix tool
+  So I don't get surpised
+
+  Scenario: Common arguments work
+    When I get help for "vcloud-launch"
+    Then the exit status should be 0
+    And the banner should be present
+    And the banner should document that this app takes options
+    And the following options should be documented:
+      |--version|
+      |--dont-power-on|
+      |--continue-on-error|
+    And the banner should document that this app's arguments are:
+      |org_config_file|

data/jenkins.sh

@@ -0,0 +1,11 @@
+#!/bin/bash -x
+set -e
+bundle install --path "${HOME}/bundles/${JOB_NAME}"
+bundle exec rake 
+
+./scripts/generate_fog_conf_file.sh
+export FOG_RC=fog_integration_test.config
+bundle exec rake integration:all
+rm fog_integration_test.config
+
+bundle exec rake publish_gem

data/jenkins_integration_tests.sh

@@ -0,0 +1,7 @@
+#!/bin/bash -x
+set -e
+bundle install --path "${HOME}/bundles/${JOB_NAME}"
+./scripts/generate_fog_conf_file.sh
+export FOG_RC=fog_integration_test.config
+bundle exec rake integration:all
+rm fog_integration_test.config

data/lib/vcloud/launcher.rb

@@ -0,0 +1,22 @@
+require 'vcloud/fog'
+require 'vcloud/core'
+
+require 'vcloud/launcher/launch'
+require 'vcloud/launcher/vm_orchestrator'
+require 'vcloud/launcher/vapp_orchestrator'
+
+require 'vcloud/launcher/version'
+
+module Vcloud
+  module Launcher
+
+    def self.logger
+      @logger ||= Logger.new(STDOUT)
+    end
+
+    def self.clone_object object
+      Marshal.load(Marshal.dump(object))
+    end
+
+  end
+end

data/lib/vcloud/launcher/launch.rb

@@ -0,0 +1,46 @@
+module Vcloud
+  module Launcher
+    class Launch
+
+      def initialize
+        @config_loader = Vcloud::Core::ConfigLoader.new
+      end
+
+      def run(config_file = nil, cli_options = {})
+        config = @config_loader.load_config(config_file, config_schema)
+        config[:vapps].each do |vapp_config|
+          Vcloud::Launcher.logger.info("\n")
+          Vcloud::Launcher.logger.info("Provisioning vApp #{vapp_config[:name]}.")
+          begin
+            vapp = ::Vcloud::Launcher::VappOrchestrator.provision(vapp_config)
+            #methadone sends option starting with 'no' as false.
+            vapp.power_on unless cli_options["dont-power-on"]
+            Vcloud::Launcher.logger.info("Done! Provisioned vApp #{vapp_config[:name]} successfully.")
+            Vcloud::Launcher.logger.info("=" * 70)
+          rescue RuntimeError => e
+            Vcloud::Launcher.logger.error("Failure : Could not provision vApp: #{e.message}")
+            Vcloud::Launcher.logger.info("=" * 70)
+            break unless cli_options["continue-on-error"]
+          end
+
+        end
+      end
+
+      def config_schema
+        {
+          type: 'hash',
+          allowed_empty: false,
+          permit_unknown_parameters: true,
+          internals: {
+            vapps: {
+            type: 'array',
+            required: false,
+            allowed_empty: true,
+            each_element_is: ::Vcloud::Launcher::VappOrchestrator.provision_schema
+          },
+        }
+      }
+      end
+    end
+  end
+end

data/lib/vcloud/launcher/vapp_orchestrator.rb

@@ -0,0 +1,44 @@
+module Vcloud
+  module Launcher
+    class VappOrchestrator
+
+      def self.provision(vapp_config)
+        name, vdc_name = vapp_config[:name], vapp_config[:vdc_name]
+
+        if vapp = Vcloud::Core::Vapp.get_by_name_and_vdc_name(name, vdc_name)
+          Vcloud::Launcher.logger.info("Found existing vApp #{name} in vDC '#{vdc_name}'. Skipping.")
+        else
+          template = Vcloud::Core::VappTemplate.get(vapp_config[:catalog], vapp_config[:catalog_item])
+          template_id = template.id
+
+          network_names = extract_vm_networks(vapp_config)
+          vapp = Vcloud::Core::Vapp.instantiate(name, network_names, template_id, vdc_name)
+          Vcloud::Launcher::VmOrchestrator.new(vapp.fog_vms.first, vapp).customize(vapp_config[:vm]) if vapp_config[:vm]
+        end
+        vapp
+      end
+
+      def self.provision_schema
+        {
+          type: 'hash',
+          required: true,
+          allowed_empty: false,
+          internals: {
+            name:      { type: 'string', required: true, allowed_empty: false },
+            vdc_name:  { type: 'string', required: true, allowed_empty: false },
+            catalog:   { type: 'string', required: true, allowed_empty: false },
+            catalog_item: { type: 'string', required: true, allowed_empty: false },
+            vm: Vcloud::Launcher::VmOrchestrator.customize_schema,
+          }
+        }
+      end
+
+      def self.extract_vm_networks(config)
+        if (config[:vm] && config[:vm][:network_connections])
+          config[:vm][:network_connections].collect { |h| h[:name] }
+        end
+      end
+
+    end
+  end
+end

data/lib/vcloud/launcher/version.rb

@@ -0,0 +1,5 @@
+module Vcloud
+  module Launcher
+    VERSION = '0.0.1'
+  end
+end

data/lib/vcloud/launcher/vm_orchestrator.rb

@@ -0,0 +1,85 @@
+module Vcloud
+  module Launcher
+    class VmOrchestrator
+      def initialize fog_vm, vapp
+        vm_id = fog_vm[:href].split('/').last
+        @vm = Core::Vm.new(vm_id, vapp)
+      end
+
+      def customize(vm_config)
+        @vm.update_name(@vm.vapp_name)
+        @vm.configure_network_interfaces vm_config[:network_connections]
+        @vm.update_storage_profile(vm_config[:storage_profile]) if vm_config[:storage_profile]
+        if hardware_config = vm_config[:hardware_config]
+          @vm.update_cpu_count(hardware_config[:cpu])
+          @vm.update_memory_size_in_mb(hardware_config[:memory])
+        end
+        @vm.add_extra_disks(vm_config[:extra_disks])
+        @vm.update_metadata(vm_config[:metadata])
+        @vm.configure_guest_customization_section(
+            @vm.vapp_name,
+            vm_config[:bootstrap],
+            vm_config[:extra_disks]
+        )
+      end
+
+      def self.customize_schema
+        {
+          type: 'hash',
+          required: false,
+          allowed_empty: false,
+          internals: {
+            network_connections: {
+              type: 'array',
+              required: false,
+              each_element_is: {
+                type: 'hash',
+                internals: {
+                  name: { type: 'string', required: true },
+                  ip_address: { type: 'ip_address', required: false },
+                },
+              },
+            },
+            storage_profile: { type: 'string', required: false },
+            hardware_config: {
+              type: 'hash',
+              required: false,
+              internals: {
+                cpu: { type: 'string_or_number', required: false },
+                memory: { type: 'string_or_number', required: false },
+              },
+            },
+            extra_disks: {
+              type: 'array',
+              required: false,
+              allowed_empty: false,
+              each_element_is: {
+                type: 'hash',
+                internals: {
+                  name: { type: 'string', required: false },
+                  size: { type: 'string_or_number', required: false },
+                },
+              },
+            },
+            bootstrap:   {
+              type: 'hash',
+              required: false,
+              allowed_empty: false,
+              internals: {
+                script_path: { type: 'string', required: false },
+                script_post_processor: { type: 'string', required: false },
+                vars: { type: 'hash', required: false, allowed_empty: true },
+              },
+            },
+            metadata: {
+              type: 'hash',
+              required: false,
+              allowed_empty: true,
+            },
+          },
+        }
+      end
+
+    end
+  end
+end

data/scripts/basic.erb

@@ -0,0 +1,13 @@
+#!/bin/sh
+
+(
+echo "============================================================"
+echo "in ${1}:"
+echo "vapp_name: <%= vapp_name -%>"
+echo "role: <%= vars[:role] -%>"
+echo "environment: <%= vars[:environment] -%>"
+echo
+env 
+) >> /PREAMBLE_OUT
+
+

data/scripts/generate_fog_conf_file.sh

@@ -0,0 +1,6 @@
+cat <<EOF >fog_integration_test.config
+default:
+    vcloud_director_username: '$API_USERNAME'
+    vcloud_director_password: '$API_PASSWORD'
+    vcloud_director_host: '$API_HOST'
+EOF

data/spec/erb_helper.rb

@@ -0,0 +1,11 @@
+class ErbHelper
+  def self.convert_erb_template_to_yaml test_namespace, input_erb_config
+    input_erb_config = input_erb_config
+    e = ERB.new(File.open(input_erb_config).read)
+    output_yaml_config = File.join(File.dirname(input_erb_config), "output_#{Time.now.strftime('%s')}.yaml")
+    File.open(output_yaml_config, 'w') { |f|
+      f.write e.result(OpenStruct.new(test_namespace).instance_eval { binding })
+    }
+    output_yaml_config
+  end
+end

data/spec/integration/launcher/data/basic_preamble_test.erb

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+# Default preamble
+
+(
+echo "in $*"
+echo "message: <%= vars[:message] -%>"
+) >> /PREAMBLE_OUTPUT

data/spec/integration/launcher/data/happy_path.yaml.erb

@@ -0,0 +1,32 @@
+---
+vapps:
+  - name: <%= vapp_name %>
+    vdc_name: <%= vdc_name %>
+    catalog: <%= catalog %>
+    catalog_item: <%= vapp_template %>
+    vm:
+      hardware_config:
+        memory: 8192
+        cpu: 4
+      metadata:
+        is_integer: -999
+        is_string: Hello World
+        is_datetime: <%= date_metadata %>
+        is_true: true
+        is_false: false
+        integration_test_vm: true
+      extra_disks:
+      - size: '1024'
+        name: Hard disk 2
+      - size: '2048'
+        name: Hard disk 3
+      network_connections:
+      - name: <%= network1 %>
+        ip_address: <%= network1_ip %>
+      - name: <%= network2 %>
+        ip_address: <%= network2_ip %>
+      bootstrap:
+        script_path: <%= bootstrap_script %>
+        vars:
+          message: hello world
+      storage_profile: <%= storage_profile %>

data/spec/integration/launcher/data/minimum_data_setup.yaml.erb

@@ -0,0 +1,6 @@
+---
+vapps:
+  - name: <%= vapp_name %>
+    vdc_name: <%= vdc_name %>
+    catalog: <%= catalog %>
+    catalog_item: <%= vapp_template %>

data/spec/integration/launcher/data/storage_profile.yaml.erb

@@ -0,0 +1,24 @@
+---
+vapps:
+  - name: <%= vapp_name_1 %>
+    vdc_name: <%= vdc_name_1 %>
+    catalog: <%= catalog %>
+    catalog_item: <%= vapp_template %>
+    vm:
+      storage_profile: <%= storage_profile %>
+  - name: <%= vapp_name_2 %>
+    vdc_name: <%= vdc_name_2 %>
+    catalog: <%= catalog %>
+    catalog_item: <%= vapp_template %>
+    vm:
+      storage_profile: <%= storage_profile %>
+  - name: <%= vapp_name_3 %>
+    vdc_name: <%= vdc_name_1 %>
+    catalog: <%= catalog %>
+    catalog_item: <%= vapp_template %>
+  - name: <%= vapp_name_4 %>
+    vdc_name: <%= vdc_name_1 %>
+    catalog: <%= catalog %>
+    catalog_item: <%= vapp_template %>
+    vm:
+      storage_profile: <%= nonsense_storage_profile %>

data/spec/integration/launcher/storage_profile_integration_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Vcloud::Launcher::Launch do
+  context "storage profile", :take_too_long => true do
+    before(:all) do
+      @test_data = define_test_data
+      @config_yaml = ErbHelper.convert_erb_template_to_yaml(@test_data, File.join(File.dirname(__FILE__), 'data/storage_profile.yaml.erb'))
+      @fog_interface = Vcloud::Fog::ServiceInterface.new
+      Vcloud::Launcher::Launch.new.run(@config_yaml, {'dont-power-on' => true})
+
+      @vapp_query_result_1 = @fog_interface.get_vapp_by_name_and_vdc_name(@test_data[:vapp_name_1], @test_data[:vdc_name_1])
+      @vapp_id_1 = @vapp_query_result_1[:href].split('/').last
+      @vapp_1 = @fog_interface.get_vapp @vapp_id_1
+      @vm_1 = @vapp_1[:Children][:Vm].first
+
+      @vapp_query_result_2 = @fog_interface.get_vapp_by_name_and_vdc_name(@test_data[:vapp_name_2], @test_data[:vdc_name_2])
+      @vapp_id_2 = @vapp_query_result_2[:href].split('/').last
+      @vapp_2 = @fog_interface.get_vapp @vapp_id_2
+      @vm_2 = @vapp_2[:Children][:Vm].first
+
+      @vapp_query_result_3 = @fog_interface.get_vapp_by_name_and_vdc_name(@test_data[:vapp_name_3], @test_data[:vdc_name_1])
+      @vapp_id_3 = @vapp_query_result_3[:href].split('/').last
+      @vapp_3 = @fog_interface.get_vapp @vapp_id_3
+      @vm_3 = @vapp_3[:Children][:Vm].first
+
+      @vapp_query_result_4 = @fog_interface.get_vapp_by_name_and_vdc_name(@test_data[:vapp_name_4], @test_data[:vdc_name_1])
+      @vapp_id_4 = @vapp_query_result_4[:href].split('/').last
+      @vapp_4 = @fog_interface.get_vapp @vapp_id_4
+      @vm_4 = @vapp_4[:Children][:Vm].first
+    end
+
+    it "vdc 1 should have a storage profile without the href being specified" do
+        @vm_1[:StorageProfile][:name].should == @test_data[:storage_profile]
+    end
+
+    it "vdc 1's storage profile should have the expected href" do
+        @vm_1[:StorageProfile][:href].should == @test_data[:vdc_1_sp_href]
+    end
+
+    it "vdc 2 should have the same named storage profile as vdc 1" do
+        @vm_2[:StorageProfile][:name].should == @test_data[:storage_profile]
+    end
+
+    it "the storage profile in vdc 2 should have a different href to the storage profile in vdc 1" do
+        @vm_2[:StorageProfile][:href].should == @test_data[:vdc_2_sp_href]
+    end
+
+    it "when a storage profile is not specified, vm uses the default and continues" do
+        @vm_3[:StorageProfile][:name].should == @test_data[:default_storage_profile_name]
+        @vm_3[:StorageProfile][:href].should == @test_data[:default_storage_profile_href]
+    end
+
+    it "when a storage profile specified does not exist, vm uses the default" do
+        @vm_4[:StorageProfile][:name].should == @test_data[:default_storage_profile_name]
+        @vm_4[:StorageProfile][:href].should == @test_data[:default_storage_profile_href]
+    end
+
+    after(:all) do
+      unless ENV['VCLOUD_TOOLS_RSPEC_NO_DELETE_VAPP']
+        File.delete @config_yaml
+        @fog_interface.delete_vapp(@vapp_id_1).should == true
+        @fog_interface.delete_vapp(@vapp_id_2).should == true
+        @fog_interface.delete_vapp(@vapp_id_3).should == true
+        @fog_interface.delete_vapp(@vapp_id_4).should == true
+      end
+    end
+
+  end
+
+end
+
+def define_test_data
+  {
+      vapp_name_1: "vdc-1-sp-#{Time.now.strftime('%s')}",
+      vapp_name_2: "vdc-2-sp-#{Time.now.strftime('%s')}",
+      vapp_name_3: "vdc-3-sp-#{Time.now.strftime('%s')}",
+      vapp_name_4: "vdc-4-sp-#{Time.now.strftime('%s')}",
+      vdc_name_1: ENV['VDC_NAME_1'],
+      vdc_name_2: ENV['VDC_NAME_2'],
+      catalog: ENV['VCLOUD_CATALOG_NAME'],
+      vapp_template: ENV['VCLOUD_TEMPLATE_NAME'],
+      storage_profile: ENV['VCLOUD_STORAGE_PROFILE_NAME'],
+      vdc_1_sp_href: ENV['VDC_1_STORAGE_PROFILE_HREF'],
+      vdc_2_sp_href: ENV['VDC_2_STORAGE_PROFILE_HREF'],
+      default_storage_profile_name: ENV['DEFAULT_STORAGE_PROFILE_NAME'],
+      default_storage_profile_href: ENV['DEFAULT_STORAGE_PROFILE_HREF'],
+      nonsense_storage_profile: "nonsense-storage-profile-name",
+      bootstrap_script: File.join(File.dirname(__FILE__), "data/basic_preamble_test.erb"),
+  }
+end