vcloud-core 0.0.1

data/lib/vcloud/fog.rb

@@ -0,0 +1,5 @@
+require 'fog'
+require 'vcloud/fog/content_types'
+require 'vcloud/fog/relation'
+require 'vcloud/fog/service_interface'
+require 'vcloud/fog/model_interface'

data/lib/vcloud/fog/content_types.rb

@@ -0,0 +1,20 @@
+module Vcloud
+  module Fog
+    module ContentTypes
+      CATALOG = 'application/vnd.vmware.vcloud.catalog+xml'
+      ORG = 'application/vnd.vmware.vcloud.org+xml'
+      VDC = 'application/vnd.vmware.vcloud.vdc+xml'
+      CATALOG_ITEM = 'application/vnd.vmware.vcloud.catalogItem+xml'
+      NETWORK = 'application/vnd.vmware.vcloud.network+xml'
+      METADATA = 'application/vnd.vmware.vcloud.metadata.value+xml'
+    end
+
+    module MetadataValueType
+      String = 'MetadataStringValue'
+      Number = 'MetadataNumberValue'
+      DateTime = 'MetadataDateTimeValue'
+      Boolean = 'MetadataBooleanValue'
+    end
+
+  end
+end

data/lib/vcloud/fog/model_interface.rb

@@ -0,0 +1,33 @@
+module Vcloud
+  module Fog
+    class ModelInterface
+      def initialize
+        @vcloud = ::Fog::Compute::VcloudDirector.new
+      end
+
+      def org_name
+        @vcloud.org_name
+      end
+
+      def current_organization
+        @vcloud.organizations.get_by_name org_name
+      end
+
+      def current_vdc vdc_id
+        current_organization.vdcs.detect { |v| v.id == vdc_id }
+      end
+
+      def get_vm_by_href href
+        vm = @vcloud.get_vms_in_lease_from_query(
+            {
+                :filter => "href==#{href}"
+            }).body[:VMRecord].first
+        return nil unless vm
+        vdc = current_vdc(vm[:vdc].split('/').last)
+        vapp = vdc.vapps.get_by_name(vm[:containerName])
+        vapp.vms.first
+      end
+
+    end
+  end
+end

data/lib/vcloud/fog/relation.rb

@@ -0,0 +1,8 @@
+module Vcloud
+  module Fog
+    module RELATION
+      PARENT = 'up'
+      CHILD = 'down'
+    end
+  end
+end

data/lib/vcloud/fog/service_interface.rb

@@ -0,0 +1,257 @@
+require 'forwardable'
+
+module Vcloud
+  module Fog
+    class ServiceInterface
+      extend Forwardable
+
+      def_delegators :@fog, :get_vapp, :organizations, :org_name, :delete_vapp, :vcloud_token, :end_point,
+                     :get_execute_query, :get_vapp_metadata, :power_off_vapp, :shutdown_vapp, :session,
+                     :post_instantiate_vapp_template, :put_memory, :put_cpu, :power_on_vapp, :put_vapp_metadata_value,
+                     :put_vm, :get_edge_gateway, :get_network, :delete_network, :post_create_org_vdc_network
+
+      #########################
+      # FogFacade Inner class to represent a logic free facade over our interactions with Fog
+
+      class FogFacade
+        def initialize
+          @vcloud = ::Fog::Compute::VcloudDirector.new
+        end
+
+        def get_vdc(name)
+          @vcloud.get_vdc(name).body
+        end
+
+        def get_organization (name)
+          @vcloud.get_organization(name).body
+        end
+
+        def session
+          @vcloud.get_current_session.body
+        end
+
+        def get_vapps_in_lease_from_query(options)
+          @vcloud.get_vapps_in_lease_from_query(options).body
+        end
+
+        def get_catalog_item(id)
+          @vcloud.get_catalog_item(id).body
+        end
+
+        def post_instantiate_vapp_template(vdc, template, name, params)
+          Vcloud::Core.logger.info("instantiating #{name} vapp in #{vdc[:name]}")
+          vapp = @vcloud.post_instantiate_vapp_template(extract_id(vdc), template, name, params).body
+          @vcloud.process_task(vapp[:Tasks][:Task])
+          @vcloud.get_vapp(extract_id(vapp)).body
+        end
+
+        def put_memory(vm_id, memory)
+          Vcloud::Core.logger.info("putting #{memory}MB memory into VM #{vm_id}")
+          task = @vcloud.put_memory(vm_id, memory).body
+          @vcloud.process_task(task)
+        end
+
+        def get_vapp(id)
+          @vcloud.get_vapp(id).body
+        end
+
+        def put_network_connection_system_section_vapp(vm_id, section)
+          task = @vcloud.put_network_connection_system_section_vapp(vm_id, section).body
+          @vcloud.process_task(task)
+        end
+
+        def put_cpu(vm_id, cpu)
+          Vcloud::Core.logger.info("putting #{cpu} CPU(s) into VM #{vm_id}")
+          task = @vcloud.put_cpu(vm_id, cpu).body
+          @vcloud.process_task(task)
+        end
+
+        def put_vm(id, name, options={})
+          Vcloud::Core.logger.info("updating name : #{name}, :options => #{options} in vm : #{id}")
+          task = @vcloud.put_vm(id, name, options).body
+          @vcloud.process_task(task)
+        end
+
+        def vcloud_token
+          @vcloud.vcloud_token
+        end
+
+        def end_point
+          @vcloud.end_point
+        end
+
+        def put_guest_customization_section_vapp(vm_id, customization_req)
+          task = @vcloud.put_guest_customization_section_vapp(vm_id, customization_req).body
+          @vcloud.process_task(task)
+        end
+
+        def get_execute_query(type=nil, options={})
+          @vcloud.get_execute_query(type, options).body
+        end
+
+        def get_vapp_metadata(id)
+          @vcloud.get_vapp_metadata(id).body
+        end
+
+
+        def organizations
+          @vcloud.organizations
+        end
+
+        def org_name
+          @vcloud.org_name
+        end
+
+        def delete_vapp(vapp_id)
+          task = @vcloud.delete_vapp(vapp_id).body
+          @vcloud.process_task(task)
+        end
+
+        def get_network(id)
+          @vcloud.get_network(id).body
+        end
+
+        def delete_network(id)
+          task = @vcloud.delete_network(id).body
+          @vcloud.process_task(task)
+        end
+
+        def post_create_org_vdc_network(vdc_id, name, options)
+          Vcloud::Core.logger.info("creating #{options[:fence_mode]} OrgVdcNetwork #{name} in vDC #{vdc_id}")
+          attrs = @vcloud.post_create_org_vdc_network(vdc_id, name, options).body
+          @vcloud.process_task(attrs[:Tasks][:Task])
+          get_network(extract_id(attrs))
+        end
+
+        def power_off_vapp(vapp_id)
+          task = @vcloud.post_power_off_vapp(vapp_id).body
+          @vcloud.process_task(task)
+        end
+
+        def power_on_vapp(vapp_id)
+          Vcloud::Core.logger.info("Powering on vApp #{vapp_id}")
+          task = @vcloud.post_power_on_vapp(vapp_id).body
+          @vcloud.process_task(task)
+        end
+
+        def shutdown_vapp(vapp_id)
+          task = @vcloud.post_shutdown_vapp(vapp_id).body
+          @vcloud.process_task(task)
+        end
+
+        def get_catalog(id)
+          @vcloud.get_catalog(id).body
+        end
+
+        def put_vapp_metadata_value(id, k, v)
+          Vcloud::Core.logger.info("putting metadata pair '#{k}'=>'#{v}' to #{id}")
+          # need to convert key to_s since Fog 0.17 borks on symbol key
+          task = @vcloud.put_vapp_metadata_item_metadata(id, k.to_s, v).body
+          @vcloud.process_task(task)
+        end
+
+        def get_edge_gateway(id)
+          @vcloud.get_edge_gateway(id).body
+        end
+
+        private
+        def extract_id(link)
+          link[:href].split('/').last
+        end
+      end
+      #
+      #########################
+
+
+
+      def initialize (fog = FogFacade.new)
+        @fog = fog
+      end
+
+      def org
+        link = session[:Link].select { |l| l[:rel] == RELATION::CHILD }.detect do |l|
+          l[:type] == ContentTypes::ORG
+        end
+        @fog.get_organization(link[:href].split('/').last)
+      end
+
+      def get_vapp_by_name_and_vdc_name name, vdc_name
+        response_body = @fog.get_vapps_in_lease_from_query({:filter => "name==#{name}"})
+        response_body[:VAppRecord].detect { |record| record[:vdcName] == vdc_name }
+      end
+
+      def catalog(name)
+        link = org[:Link].select { |l| l[:rel] == RELATION::CHILD }.detect do |l|
+          l[:type] == ContentTypes::CATALOG && l[:name] == name
+        end
+        raise "catalog #{name} cannot be found" unless link
+        @fog.get_catalog(extract_id(link))
+      end
+
+      def vdc(name)
+        link = org[:Link].select { |l| l[:rel] == RELATION::CHILD }.detect do |l|
+          l[:type] == ContentTypes::VDC && l[:name] == name
+        end
+        raise "vdc #{name} cannot be found" unless link
+        @fog.get_vdc(link[:href].split('/').last)
+
+      end
+
+      def template(catalog_name, template_name)
+        link = catalog(catalog_name)[:CatalogItems][:CatalogItem].detect do |l|
+          l[:type] == ContentTypes::CATALOG_ITEM && l[:name].match(template_name)
+        end
+        if link.nil?
+          Vcloud::Core.logger.warn("Template #{template_name} not found in catalog #{catalog_name}")
+          return nil
+        end
+        catalog_item = @fog.get_catalog_item(extract_id(link))
+        catalog_item[:Entity]
+      end
+
+
+      def put_network_connection_system_section_vapp(vm_id, section)
+        begin
+          Vcloud::Core.logger.info("adding NIC into VM #{vm_id}")
+          @fog.put_network_connection_system_section_vapp(vm_id, section)
+        rescue
+          Vcloud::Core.logger.info("failed to put_network_connection_system_section_vapp for vm : #{vm_id} ")
+          Vcloud::Core.logger.info("requested network section : #{section.inspect}")
+          raise
+        end
+      end
+
+      def find_networks(network_names, vdc_name)
+        network_names.collect do |network|
+          vdc(vdc_name)[:AvailableNetworks][:Network].detect do |l|
+            l[:type] == ContentTypes::NETWORK && l[:name] == network
+          end
+        end
+      end
+
+      def put_guest_customization_section(vm_id, vm_name, script)
+        begin
+          Vcloud::Core.logger.info("configuring guest customization section for vm : #{vm_id}")
+          customization_req = {
+            :Enabled             => true,
+            :CustomizationScript => script,
+            :ComputerName        => vm_name
+          }
+          @fog.put_guest_customization_section_vapp(vm_id, customization_req)
+        rescue
+          Vcloud::Core.logger.info("=== interpolated preamble:")
+          Vcloud::Core.logger.info(script)
+          raise
+        end
+      end
+
+      private
+      def extract_id(link)
+        link[:href].split('/').last
+      end
+
+    end
+
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'simplecov'
+
+SimpleCov.profiles.define 'gem' do
+  add_filter '/spec/'
+  add_filter '/features/'
+  add_filter '/vendor/'
+
+  add_group 'Libraries', '/lib/'
+end
+
+SimpleCov.start 'gem'
+
+require 'bundler/setup'
+require 'vcloud/core'
+require 'support/stub_fog_interface.rb'
+
+
+SimpleCov.at_exit do
+  SimpleCov.result.format!
+  # do not change the coverage percentage, instead add more unit tests to fix coverage failures.
+  if SimpleCov.result.covered_percent < 71
+    print "ERROR::BAD_COVERAGE\n"
+    print "Coverage is less than acceptable limit(71%). Please add more tests to improve the coverage"
+    exit(1)
+  end
+end

data/spec/support/stub_fog_interface.rb

@@ -0,0 +1,59 @@
+require 'ostruct'
+
+class StubFogInterface
+
+  def name
+    'Test vDC 1'
+  end
+
+  def vdc_object_by_name(vdc_name)
+    vdc = OpenStruct.new
+    vdc.name = 'test-vdc-1'
+    vdc
+  end
+
+  def template
+    { :href => '/vappTemplate-12345678-90ab-cdef-0123-4567890abcde' }
+  end
+
+  def find_networks(network_names, vdc_name)
+    [{
+      :name => 'org-vdc-1-net-1',
+      :href => '/org-vdc-1-net-1-id',
+    }]
+  end
+
+  def get_vapp(id)
+    { :name => 'test-vapp-1' }
+  end
+
+  def get_edge_gateway(id)
+    { 
+      :name => 'test-edgegw-1',
+      :href => "/#{id}",
+    }
+  end
+
+  def vdc(name)
+    { }
+  end
+
+  def post_instantiate_vapp_template(vdc, template, name, params)
+    {
+      :href => '/test-vapp-1-id',
+      :Children => {
+        :Vm => ['bogus vm data']
+      }
+    }
+  end
+
+  def get_vapp_by_vdc_and_name
+    { }
+  end
+
+  def template(catalog_name, name)
+    { :href => '/vappTemplate-12345678-90ab-cdef-0123-4567890abcde' }
+  end
+
+
+end

data/spec/vcloud/core/edge_gateway_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+module Vcloud
+  module Core
+    describe EdgeGateway do
+
+      before(:each) do
+        @edgegw_id = '12345678-1234-1234-1234-000000111454'
+        @mock_fog_interface = StubFogInterface.new
+        Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
+      end
+
+      context "Class public interface" do
+        it { EdgeGateway.should respond_to(:get_ids_by_name) }
+        it { EdgeGateway.should respond_to(:get_by_name) }
+      end
+
+      context "Instance public interface" do
+        subject { EdgeGateway.new(@edgegw_id) }
+        it { should respond_to(:id) }
+        it { should respond_to(:name) }
+        it { should respond_to(:href) }
+      end
+
+      context "#initialize" do
+
+        it "should be constructable from just an id reference" do
+          obj = EdgeGateway.new(@edgegw_id)
+          expect(obj.class).to be(Vcloud::Core::EdgeGateway)
+        end
+
+        it "should store the id specified" do
+          obj = EdgeGateway.new(@edgegw_id)
+          expect(obj.id) == @edgegw_id
+        end
+
+        it "should raise error if id is not in correct format" do
+          bogus_id = '123123-bogus-id-123445'
+          expect{ EdgeGateway.new(bogus_id) }.to raise_error("EdgeGateway id : #{bogus_id} is not in correct format" )
+        end
+
+      end
+
+      context "#get_by_name" do
+
+        it "should return a EdgeGateway object if name exists" do
+          q_results = [
+            { :name => 'edgegw-test-1', :href => "/#{@edgegw_id}" }
+          ]
+          mock_query = double(:query, :get_all_results => q_results)
+          Vcloud::Query.should_receive(:new).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(mock_query)
+          @obj = EdgeGateway.get_by_name('edgegw-test-1')
+          expect(@obj.class).to be(Vcloud::Core::EdgeGateway)
+        end
+
+        it "should return an object with the correct id if name exists" do
+          q_results = [
+            { :name => 'edgegw-test-1', :href => "/#{@edgegw_id}" }
+          ]
+          mock_query = double(:query, :get_all_results => q_results)
+          Vcloud::Query.should_receive(:new).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(mock_query)
+          @obj = EdgeGateway.get_by_name('edgegw-test-1')
+          expect(@obj.id) == @edgegw_id
+        end
+
+        it "should raise an error if no edgegw with that name exists" do
+          q_results = [ ]
+          mock_query = double(:query, :get_all_results => q_results)
+          Vcloud::Query.should_receive(:new).with('edgeGateway', :filter => "name==edgegw-test-1").and_return(mock_query)
+          expect{ EdgeGateway.get_by_name('edgegw-test-1') }.to raise_exception(RuntimeError, "edgeGateway edgegw-test-1 not found")
+        end
+
+      end
+
+    end
+
+  end
+
+end