vcloud-core 0.11.0 → 0.12.0

data/CHANGELOG.md

@@ -1,6 +1,15 @@
+## 0.12.0 (2014-10-03)
+
+Features:
+
+  - Adds custom fields support to vApps. Thanks @geriBatai
+  - Adds IndependentDisk entity class, for creation and discovery of Independent Disks. Thanks @mikepea
+  - Adds methods to attach and detach IndependentDisk objects to/from an existing VM. Thanks @mikepea
+  - Add Vapp.get_by_child_vm_id method, to find a vApp by its child VM id. Thanks @mikepea
+
 ## 0.11.0 (2014-09-11)
 
-Changes:
+Features:
 
   - As deprecated in 0.7.0, it is now impossible to specify a plaintext
     password in a FOG_RC file. Please use tokens via vcloud-login as per
@@ -10,7 +19,7 @@ Changes:
 
 API changes:
 
-  - removes the temporary files used for transitioning vCloud Tools Tester to use the new API.
+  - Removes the temporary files used for transitioning vCloud Tools Tester to use the new API.
 
 ## 0.9.0 (2014-08-08)
 

data/CONTRIBUTING.md

@@ -2,6 +2,10 @@
 
 We really welcome contributions.
 
+## Issues list
+
+Issues we know about are [listed here](https://github.com/gds-operations/vcloud-core/issues). We have a [`newcomer-friendly label`](https://github.com/gds-operations/vcloud-core/labels/newcomer-friendly) for issues that we feel would be a good place to start, because they do not touch a lot of other vCloud Tools code and do not require an environment to work on. This label is just a suggestion.
+
 ## A quick guide on how to contribute
 
 1. Clone the repo:

data/README.md

@@ -103,6 +103,28 @@ If you want to be sure you are pinning to 5.1, or use 5.5, you can set the API v
 
 `vcloud_director_api_version: 5.1`
 
+## Working with Independent Disks
+
+vCloud Core now supports the management of Independent Disks -- block devices
+stored and managed separately from the VMs they are attached to. We have
+noticed that this bring some limitations/caveats into play that API users
+should be aware of:
+
+* It is not possible to move the VM from one Storage Profile to another with
+  Vm#update_storage_profile if an Independent Disk is attached. This appears to
+  be a limitation in vCloud Director itself. To work around this, detach the
+  disks before updating, and reattach afterwards.
+
+* It is not possible to add additional *local* disks via Vm#add_extra_disks
+  when Independent Disks are attached to a VM. This appears to be a limitation with
+  Fog, as the vCD UI permits it. See https://github.com/fog/fog/issues/3179
+  for progress on this issue.
+
+* Extreme care should be taken when detaching Independent Disks from a VM, as
+  vCloud Director will detach them without warning from running VMs, and hence
+  with no notification to the running OS. It is recommended to simply use them for
+  persistence across VM delete/recreate operations.
+
 ## Debugging
 
 `export EXCON_DEBUG=true` - this will print out the API requests and responses.

data/lib/vcloud/core.rb

@@ -16,6 +16,7 @@ require 'vcloud/core/login_cli'
 require 'vcloud/core/vm'
 require 'vcloud/core/vapp'
 require 'vcloud/core/vapp_template'
+require 'vcloud/core/independent_disk'
 require 'vcloud/core/org_vdc_network'
 require 'vcloud/core/query'
 require 'vcloud/core/query_cli'

data/lib/vcloud/core/fog/fog_constants.rb

@@ -8,6 +8,7 @@ module Vcloud
       module ContentTypes
         ORG = 'application/vnd.vmware.vcloud.org+xml'
         VDC = 'application/vnd.vmware.vcloud.vdc+xml'
+        VAPP = 'application/vnd.vmware.vcloud.vApp+xml'
         NETWORK = 'application/vnd.vmware.vcloud.network+xml'
         METADATA = 'application/vnd.vmware.vcloud.metadata.value+xml'
       end

data/lib/vcloud/core/fog/service_interface.rb

@@ -16,7 +16,9 @@ module Vcloud
                        :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_complete, :delete_network, :post_create_org_vdc_network,
-                       :post_configure_edge_gateway_services, :get_vdc, :post_undeploy_vapp
+                       :post_configure_edge_gateway_services, :get_vdc, :post_undeploy_vapp,
+                       :post_create_disk, :get_disk, :delete_disk, :post_attach_disk,
+                       :get_vms_disk_attached_to, :post_detach_disk, :put_product_sections
 
         #########################
         # FogFacade Inner class to represent a logic free facade over our interactions with Fog
@@ -125,6 +127,37 @@ module Vcloud
             @vcloud.process_task(task)
           end
 
+          def get_disk(id)
+            @vcloud.get_disk(id).body
+          end
+
+          def delete_disk(id)
+            task = @vcloud.delete_disk(id).body
+            @vcloud.process_task(task)
+          end
+
+          def post_create_disk(vdc_id, disk_id, size_in_bytes, options = {})
+            # Fog method is incorrectly named 'post_upload_disk', and will be fixed
+            # in a future version to match our post_create_disk method name.
+            attrs = @vcloud.post_upload_disk(vdc_id, disk_id, size_in_bytes, options).body
+            @vcloud.process_task(attrs[:Tasks][:Task])
+            get_disk(extract_id(attrs))
+          end
+
+          def post_attach_disk(vm_id, disk_id, options = {})
+            task = @vcloud.post_attach_disk(vm_id, disk_id, options).body
+            @vcloud.process_task(task)
+          end
+
+          def post_detach_disk(vm_id, disk_id)
+            task = @vcloud.post_detach_disk(vm_id, disk_id).body
+            @vcloud.process_task(task)
+          end
+
+          def get_vms_disk_attached_to(disk_id)
+            @vcloud.get_vms_disk_attached_to(disk_id).body
+          end
+
           def post_create_org_vdc_network(vdc_id, name, options)
             Vcloud::Core.logger.debug("creating #{options[:fence_mode]} OrgVdcNetwork #{name} in vDC #{vdc_id}")
             attrs = @vcloud.post_create_org_vdc_network(vdc_id, name, options).body
@@ -170,6 +203,11 @@ module Vcloud
             @vcloud.get_edge_gateway(id).body
           end
 
+          def put_product_sections(id, items)
+            task = @vcloud.put_product_sections(id, items).body
+            @vcloud.process_task(task)
+          end
+
           private
           def extract_id(link)
             link[:href].split('/').last

data/lib/vcloud/core/independent_disk.rb

@@ -0,0 +1,95 @@
+module Vcloud
+  module Core
+    class IndependentDisk
+
+      class QueryExecutionError < RuntimeError; end
+      class DiskNotFoundException < RuntimeError; end
+      class MultipleDisksFoundException < RuntimeError; end
+      class DiskAlreadyExistsException < RuntimeError; end
+
+      attr_reader :id
+
+      def initialize(id)
+        unless id =~ /^[-0-9a-f]+$/
+          raise "IndependentDisk id : #{id} is not in correct format"
+        end
+        @id = id
+      end
+
+      def self.get_by_name_and_vdc_name(name, vdc_name)
+        q = Vcloud::Core::QueryRunner.new
+        query_results = q.run('disk', :filter => "name==#{name};vdcName==#{vdc_name}")
+        unless query_results
+          raise QueryExecutionError,
+            "Error finding IndependentDisk by name '#{name}' & vdc '#{vdc_name}'"
+        end
+        raise DiskNotFoundException,
+          "IndependentDisk '#{name}' not found in vDC '#{vdc_name}'" if query_results.size == 0
+        if query_results.size > 1
+          raise MultipleDisksFoundException,
+            "Multiple IndependentDisks matching '#{name}' found in vDC '#{vdc_name}. " +
+                "Create disks via IndependentDisk.new(disk_id) instead."
+        end
+        return self.new(query_results.first[:href].split('/').last)
+      end
+
+      def self.create(vdc, name, size)
+        vdc_name = vdc.name
+        begin
+          self.get_by_name_and_vdc_name(name, vdc_name)
+        rescue DiskNotFoundException
+          ok_to_create = true
+        end
+
+        unless ok_to_create
+          raise DiskAlreadyExistsException,
+            "Cannot create Independent Disk '#{name}' in vDC '#{vdc_name}' - a disk with " +
+            "that name is already present"
+        end
+
+        size_in_bytes = convert_size_to_bytes(size)
+        body = Vcloud::Core::Fog::ServiceInterface.new.post_create_disk(vdc.id, name, size_in_bytes)
+        return self.new(body[:href].split('/').last)
+      end
+
+      def vcloud_attributes
+        Vcloud::Core::Fog::ServiceInterface.new.get_disk(id)
+      end
+
+      def name
+        vcloud_attributes[:name]
+      end
+
+      def href
+        vcloud_attributes[:href]
+      end
+
+      def attached_vms
+        body = Vcloud::Core::Fog::ServiceInterface.new.get_vms_disk_attached_to(id)
+        vms = body.fetch(:VmReference)
+        vms.map do |vm|
+          id = vm.fetch(:href).split('/').last
+          parent_vapp = Vcloud::Core::Vapp.get_by_child_vm_id(id)
+          Vcloud::Core::Vm.new(id, parent_vapp)
+        end
+      end
+
+      def self.convert_size_to_bytes(size)
+        if size.to_s =~ /^(\d+)mb$/i
+          Integer($1) * (10**6)
+        elsif size.to_s =~ /^(\d+)gb$/i
+          Integer($1) * (10**9)
+        elsif size.to_s =~ /^(\d+)mib$/i
+          Integer($1) * (2**20)
+        elsif size.to_s =~ /^(\d+)gib$/i
+          Integer($1) * (2**30)
+        elsif size.to_s =~ /^(\d+)$/i
+          Integer($1)
+        else
+          raise ArgumentError, "Cannot convert size string '#{size}' into a number of bytes"
+        end
+      end
+
+    end
+  end
+end

data/lib/vcloud/core/vapp.rb

@@ -26,6 +26,18 @@ module Vcloud
         end
       end
 
+      def self.get_by_child_vm_id(vm_id)
+        raise ArgumentError, "Must supply a valid Vm id" unless vm_id =~ /^vm-[-0-9a-f]+$/
+        vm_body = Vcloud::Core::Fog::ServiceInterface.new.get_vapp(vm_id)
+        parent_vapp_link = vm_body.fetch(:Link).detect do |link|
+          link[:rel] == Fog::RELATION::PARENT && link[:type] == Fog::ContentTypes::VAPP
+        end
+        unless parent_vapp_link
+          raise RuntimeError, "Could not find parent vApp for VM '#{vm_id}'"
+        end
+        return self.new(parent_vapp_link.fetch(:href).split('/').last)
+      end
+
       def vcloud_attributes
         Vcloud::Core::Fog::ServiceInterface.new.get_vapp(id)
       end
@@ -76,6 +88,26 @@ module Vcloud
         self.new(attrs[:href].split('/').last) if attrs and attrs.key?(:href)
       end
 
+      def update_custom_fields(custom_fields)
+        return if custom_fields.nil?
+        fields = custom_fields.collect do |field|
+          user_configurable = field[:user_configurable] || true
+          type              = field[:type] || 'string'
+          password          = field[:password] || false
+
+          {
+            :id                => field[:name],
+            :value             => field[:value],
+            :user_configurable => user_configurable,
+            :type              => type,
+            :password          => password
+          }
+        end
+
+        Vcloud::Core.logger.debug("adding custom fields #{fields.inspect} to vapp #{@id}")
+        Vcloud::Core::Fog::ServiceInterface.new.put_product_sections(@id, fields)
+      end
+
       def power_on
         raise "Cannot power on a missing vApp." unless id
         return true if running?

data/lib/vcloud/core/version.rb

@@ -1,5 +1,5 @@
 module Vcloud
   module Core
-    VERSION = '0.11.0'
+    VERSION = '0.12.0'
   end
 end

data/lib/vcloud/core/vm.rb

@@ -69,6 +69,20 @@ module Vcloud
         end
       end
 
+      def attach_independent_disks(disk_list)
+        disk_list = Array(disk_list) # ensure we have an array
+        disk_list.each do |disk|
+          Vcloud::Core::Fog::ServiceInterface.new.post_attach_disk(id, disk.id)
+        end
+      end
+
+      def detach_independent_disks(disk_list)
+        disk_list = Array(disk_list) # ensure we have an array
+        disk_list.each do |disk|
+          Vcloud::Core::Fog::ServiceInterface.new.post_detach_disk(id, disk.id)
+        end
+      end
+
       def add_extra_disks(extra_disks)
         vm = Vcloud::Core::Fog::ModelInterface.new.get_vm_by_href(href)
         if extra_disks

data/spec/integration/core/independent_disk_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe Vcloud::Core::IndependentDisk do
+
+  let(:uuid_matcher) { "[-0-9a-f]+" }
+
+  before(:all) do
+    config_file = File.join(File.dirname(__FILE__), "../vcloud_tools_testing_config.yaml")
+    required_user_params = [
+      "vdc_1_name",
+    ]
+
+    @test_params = Vcloud::Tools::Tester::TestSetup.new(config_file, required_user_params).test_params
+    @disk_name_prefix = "vcloud-core-independent-disk-tests"
+    quantity_of_test_case_disks = 1
+    @vdc_name = @test_params.vdc_1_name
+    @vdc = Vcloud::Core::Vdc.get_by_name(@vdc_name)
+    @test_disk_size = 12000000 # bytes
+    @test_case_disks = IntegrationHelper.create_test_case_independent_disks(
+      quantity_of_test_case_disks,
+      @vdc_name,
+      @test_disk_size,
+      @disk_name_prefix
+    )
+    @test_disk = @test_case_disks.first
+  end
+
+  subject(:fixture_disk) { @test_disk }
+
+  context "before the integration tests run" do
+
+    it "ensures we have a valid IndependentDisk fixture, for subsequent tests to run against" do
+      expect(fixture_disk).to be_instance_of(Vcloud::Core::IndependentDisk)
+    end
+
+  end
+
+  describe "#vcloud_attributes" do
+
+    it "has a :href element containing the expected Independent Disk id" do
+      expect(fixture_disk.vcloud_attributes[:href].split('/').last).to eq(fixture_disk.id)
+    end
+
+  end
+
+  describe "#id" do
+
+    it "returns the a valid Independent Disk id" do
+      expect(fixture_disk.id).to match(/^#{uuid_matcher}$/)
+    end
+
+  end
+
+  describe "#name" do
+
+    it "returns the name of the Independent Disk" do
+      expect(fixture_disk.name).to include(@disk_name_prefix)
+    end
+
+  end
+
+  describe "#get_by_name_and_vdc_name" do
+
+    it "can find our fixture Independent Disk by its name & vdcName" do
+      retrieved_disk = Vcloud::Core::IndependentDisk.get_by_name_and_vdc_name(
+        fixture_disk.name, @vdc_name)
+      expect(retrieved_disk.id).to eq(fixture_disk.id)
+    end
+
+    it "raises an error if it cannot find the named Independent Disk" do
+      bogus_disk_name = "bogus-disk-name-wefoiuhwef"
+      expect {
+        Vcloud::Core::IndependentDisk.get_by_name_and_vdc_name(
+          bogus_disk_name, @vdc_name)
+      }.to raise_error(RuntimeError,
+        "IndependentDisk '#{bogus_disk_name}' not found in vDC '#{@vdc_name}'"
+      )
+    end
+
+  end
+
+  describe "#create" do
+
+    let(:disk_name) { "#{@disk_name_prefix}-instantiate-test-disk" }
+
+    it "can create a Independent Disk" do
+      new_disk = Vcloud::Core::IndependentDisk.create(
+        @vdc,
+        disk_name,
+        10000000,
+      )
+      @test_case_disks << new_disk
+      expect(new_disk.name).to eq(disk_name)
+    end
+
+    it "raises a DiskAlreadyExistsException if we try to create a disk with the same " +
+         "name in the same vDC" do
+      expect { Vcloud::Core::IndependentDisk.create(
+        @vdc,
+        disk_name,
+        10000000)
+      }.to raise_error(Vcloud::Core::IndependentDisk::DiskAlreadyExistsException)
+    end
+
+  end
+
+  after(:all) do
+    IntegrationHelper.delete_independent_disks(@test_case_disks)
+  end
+
+
+end

data/spec/integration/core/vm_spec.rb

@@ -30,6 +30,12 @@ describe Vcloud::Core::Vm do
       @network_names,
       "vcloud-core-vm-tests"
     )
+    @test_case_independent_disk_list = IntegrationHelper.create_test_case_independent_disks(
+      1,
+      @test_params.vdc_1_name,
+      "100MB",
+      "vcloud-core-vm-test-disk"
+    )
     @vapp = @test_case_vapps.first
     vapp_vms = @vapp.vms.map do |vm|
       vm_id = vm[:href].split('/').last
@@ -46,6 +52,7 @@ describe Vcloud::Core::Vm do
 
   end
 
+
   context "#update_memory_size_in_mb" do
 
     it "can increase the memory size by 512MB" do
@@ -231,26 +238,86 @@ describe Vcloud::Core::Vm do
 
   end
 
-  context "#update_storage_profile" do
+  context "#attach_independent_disks" do
+    it "can attach our fixture disk" do
+      disk = @test_case_independent_disk_list.first
+      expect(disk.attached_vms).to be_empty
+      @vm.attach_independent_disks(@test_case_independent_disk_list)
+      expect(disk.attached_vms.first.id).to eq(@vm.id)
+    end
+  end
+
+  # NB: It is suspected that this behaviour is caused by the Fog Model, not
+  #     vCloud Director itself. Issue raised on fog/fog to investigate/fix:
+  #     https://github.com/fog/fog/issues/3179
+  context "local disks cannot be added whilst an independent disk is attached" do
+
+    it "raises an error if we now try to add an extra local disk" do
+      extra_disks = [ { size: '10240' } ]
+      expect { @vm.add_extra_disks(extra_disks) }.
+        to raise_error(
+          Fog::Compute::VcloudDirector::BadRequest,
+          "The attached disks on VM \"#{@vm.name}\" cannot be modified."
+        )
+    end
+
+  end
+
+  describe "cannot update the storage profile of a VM with an independent disk attached" do
+    context "#update_storage_profile" do
+
+      it "throws an error when trying to update the storage profile of a VM with an " +
+         "independent disk attached" do
+        available_storage_profiles = Vcloud::Core::QueryRunner.new.run(
+          'orgVdcStorageProfile',
+          filter: "vdcName==#{@test_params.vdc_1_name}"
+        )
+        if available_storage_profiles.size == 1
+          pending("There is only one StorageProfile in vDC #{@test_params.vdc_1_name}: cannot test.")
+        end
+        expect{ @vm.update_storage_profile(@test_params.storage_profile) }.
+          to raise_error(Fog::Compute::VcloudDirector::TaskError)
+      end
+    end
+  end
+
+  describe "detach the independent disk causing the storage profile problem" do
+    context "#detach_independent_disks" do
+      it "can detach independent disks from the VM" do
+        disk = @test_case_independent_disk_list.first
+        expect(disk.attached_vms.first.id).to eq(@vm.id)
+        @vm.detach_independent_disks(@test_case_independent_disk_list)
+        expect(disk.attached_vms).to be_empty
+      end
+    end
+  end
 
-    it "can update the storage profile of a VM" do
-      available_storage_profiles = Vcloud::Core::QueryRunner.new.run(
-        'orgVdcStorageProfile',
-        filter: "vdcName==#{@test_params.vdc_1_name}"
-      )
-      if available_storage_profiles.size == 1
-        pending("There is only one StorageProfile in vDC #{@test_params.vdc_1_name}: cannot test.")
+  describe "can now update the storage profile" do
+
+    context "#update_storage_profile" do
+
+      it "can update the storage profile of a VM" do
+        available_storage_profiles = Vcloud::Core::QueryRunner.new.run(
+          'orgVdcStorageProfile',
+          filter: "vdcName==#{@test_params.vdc_1_name}"
+        )
+        if available_storage_profiles.size == 1
+          pending("There is only one StorageProfile in vDC #{@test_params.vdc_1_name}: cannot test.")
+        end
+        original_storage_profile_name = @vm.vcloud_attributes[:StorageProfile][:name]
+        expect(original_storage_profile_name).to eq(@test_params.default_storage_profile_name)
+        @vm.update_storage_profile(@test_params.storage_profile)
+        expect(@vm.vcloud_attributes[:StorageProfile][:name]).to eq(@test_params.storage_profile)
       end
-      original_storage_profile_name = @vm.vcloud_attributes[:StorageProfile][:name]
-      expect(original_storage_profile_name).to eq(@test_params.default_storage_profile_name)
-      @vm.update_storage_profile(@test_params.storage_profile)
-      expect(@vm.vcloud_attributes[:StorageProfile][:name]).to eq(@test_params.storage_profile)
+
     end
 
   end
 
+
   after(:all) do
     IntegrationHelper.delete_vapps(@test_case_vapps)
+    IntegrationHelper.delete_independent_disks(@test_case_independent_disk_list)
   end
 
   def get_vm_hard_disks(fog_model_vm)

data/spec/support/integration_helper.rb

@@ -32,6 +32,32 @@ module IntegrationHelper
     end
   end
 
+  def self.create_test_case_independent_disks(number_of_disks,
+                                  vdc_name,
+                                  size,
+                                  prefix = "vcloud-core-tests"
+                                 )
+    timestamp_in_s = Time.new.to_i
+    base_disk_name = "#{prefix}-#{timestamp_in_s}-"
+    disk_list = []
+    vdc = Vcloud::Core::Vdc.get_by_name(vdc_name)
+    number_of_disks.times do |index|
+      disk_list << Vcloud::Core::IndependentDisk.create(
+        vdc,
+        base_disk_name + index.to_s,
+        size,
+      )
+    end
+    disk_list
+  end
+
+  def self.delete_independent_disks(disk_list)
+    fsi = Vcloud::Core::Fog::ServiceInterface.new()
+    disk_list.each do |disk|
+      fsi.delete_disk(disk.id)
+    end
+  end
+
   def self.reset_edge_gateway(edge_gateway)
     configuration = {
         :FirewallService =>

data/spec/support/stub_fog_interface.rb

@@ -1,4 +1,5 @@
 require 'ostruct'
+require 'securerandom'
 
 class StubFogInterface
 
@@ -50,6 +51,14 @@ class StubFogInterface
     }
   end
 
+  def post_create_disk(_vdc_id, name, size)
+    {
+      :name => name,
+      :href => "https://api.example.com/disk/#{SecureRandom.uuid}",
+      :size => size,
+    }
+  end
+
   def get_vapp_by_vdc_and_name
     { }
   end

data/spec/vcloud/core/independent_disk_spec.rb

@@ -0,0 +1,239 @@
+require 'spec_helper'
+
+describe Vcloud::Core::IndependentDisk do
+  before(:each) do
+    @disk_id = '12345678-1234-1234-1234-112112112112'
+    @disk_name = 'test-disk-1'
+    @vdc_name = 'test-vdc-1'
+    @mock_fog_interface = StubFogInterface.new
+    allow(Vcloud::Core::Fog::ServiceInterface).to receive(:new).and_return(@mock_fog_interface)
+  end
+
+  context "Class public interface" do
+    it { expect(Vcloud::Core::IndependentDisk).to respond_to(:get_by_name_and_vdc_name) }
+  end
+
+  context "Instance public interface" do
+    subject { Vcloud::Core::IndependentDisk.new(@disk_id) }
+    it { should respond_to(:id) }
+    it { should respond_to(:vcloud_attributes) }
+    it { should respond_to(:name) }
+    it { should respond_to(:href) }
+    it { should respond_to(:attached_vms) }
+  end
+
+  context "#initialize" do
+
+    it "should be constructable from just an id reference" do
+      obj = Vcloud::Core::IndependentDisk.new(@disk_id)
+      expect(obj.class).to be(Vcloud::Core::IndependentDisk)
+    end
+
+    it "should store the id specified" do
+      obj = Vcloud::Core::IndependentDisk.new(@disk_id)
+      expect(obj.id).to eq(@disk_id)
+    end
+
+    it "should raise error if id is not in correct format" do
+      bogus_id = 'foo-12314124-ede5-4d07-bad5-000000111111'
+      expect{
+        Vcloud::Core::IndependentDisk.new(bogus_id)
+      }.to raise_error("IndependentDisk id : #{bogus_id} is not in correct format" )
+    end
+
+  end
+
+  context "#get_by_name_and_vdc_name" do
+
+    it "should return a Disk object if disk is found" do
+      q_results = [
+        { :name => @disk_name, :href => @disk_id }
+      ]
+      mock_query = double(:query)
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+      expect(mock_query).to receive(:run).with(
+        'disk',
+        :filter => "name==#{@disk_name};vdcName==#{@vdc_name}"
+      ).and_return(q_results)
+      obj = Vcloud::Core::IndependentDisk.get_by_name_and_vdc_name(@disk_name, @vdc_name)
+      expect(obj.class).to be(Vcloud::Core::IndependentDisk)
+    end
+
+    it "should raise an error if no Independent Disk with that name exists" do
+      q_results = [ ]
+      mock_query = double(:query_runner)
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+      expect(mock_query).to receive(:run).with(
+        'disk',
+        :filter => "name==#{@disk_name};vdcName==#{@vdc_name}"
+      ).and_return(q_results)
+      expect {
+        Vcloud::Core::IndependentDisk.get_by_name_and_vdc_name(@disk_name, @vdc_name)
+      }.to raise_exception(Vcloud::Core::IndependentDisk::DiskNotFoundException)
+    end
+
+    it "should raise an error if multiple Independent Disks with " +
+       "that name exists (NB: prescribes unique disk names!)" do
+      q_results = [
+        { :name => @disk_name, :href => @disk_id },
+        { :name => @disk_name, :href => '12341234-1234-1234-1234-123456789012' },
+      ]
+      mock_query = double(:query)
+      expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+      expect(mock_query).to receive(:run).with(
+        'disk',
+        :filter => "name==#{@disk_name};vdcName==#{@vdc_name}"
+      ).and_return(q_results)
+      expect {
+        Vcloud::Core::IndependentDisk.get_by_name_and_vdc_name(@disk_name, @vdc_name)
+      }.to raise_exception(RuntimeError)
+    end
+
+  end
+
+  describe "#convert_size_to_bytes" do
+
+    it "accepts integers, passing through as bytes" do
+      expect(Vcloud::Core::IndependentDisk.convert_size_to_bytes(100_000_000)).to eq(100_000_000)
+    end
+
+    it "accepts suffixless strings, passing through as bytes" do
+      expect(Vcloud::Core::IndependentDisk.convert_size_to_bytes('100000000')).to eq(100_000_000)
+    end
+
+    it "converts 100MB to 100_000_000 bytes" do
+      expect(Vcloud::Core::IndependentDisk.convert_size_to_bytes('100MB')).to eq(100_000_000)
+    end
+
+    it "converts 10MiB to 104_857_600 bytes" do
+      expect(Vcloud::Core::IndependentDisk.convert_size_to_bytes('100MiB')).to eq(104_857_600)
+    end
+
+    it "converts 10GB to 100_000_000_000 bytes" do
+      expect(Vcloud::Core::IndependentDisk.convert_size_to_bytes('100GB')).to eq(100_000_000_000)
+    end
+
+    it "converts 10GiB to 100_000_000_000 bytes" do
+      expect(Vcloud::Core::IndependentDisk.convert_size_to_bytes('100GiB')).to eq(107_374_182_400)
+    end
+
+    it "raises an ArgumentError if numeric component is not an integer" do
+      expect{Vcloud::Core::IndependentDisk.convert_size_to_bytes('10.5GB')}.
+        to raise_error(ArgumentError)
+    end
+
+    it "raises an ArgumentError if it does not understand the input" do
+      expect{Vcloud::Core::IndependentDisk.convert_size_to_bytes('10wibbles')}.
+        to raise_error(ArgumentError)
+    end
+
+  end
+
+  describe "#create" do
+
+    let(:vdc) { double(:vdc, :id => "12341234-1234-1234-1234-123412341234", :name => @vdc_name)}
+
+    context "when there is no disk already present with that name" do
+
+      before(:each) do
+        mock_query = double(:query_runner)
+        expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+        expect(mock_query).to receive(:run).with(
+          'disk',
+          :filter => "name==new-disk-1;vdcName==#{@vdc_name}"
+        ).and_return([])
+      end
+
+      it "returns an IndependentDisk object if successful" do
+        size_in_bytes = 1000_000_000
+        obj = Vcloud::Core::IndependentDisk.create(vdc, "new-disk-1", size_in_bytes)
+        expect(obj.class).to be(Vcloud::Core::IndependentDisk)
+      end
+
+      it "handles size parameter suffixes (MB, GB, ...)" do
+        size = "100MB"
+        expect(@mock_fog_interface).to receive(:post_create_disk).with(
+          vdc.id, "new-disk-1", 100_000_000
+        ).and_return({ :href => "/#{12341234-1234-1234-1234-123412341234}" })
+        obj = Vcloud::Core::IndependentDisk.create(vdc, "new-disk-1", size)
+        expect(obj.class).to be(Vcloud::Core::IndependentDisk)
+      end
+
+      it "handles size parameter given as an Integer (in bytes)" do
+        size = 100_000_000_000
+        expect(@mock_fog_interface).to receive(:post_create_disk).with(
+          vdc.id, "new-disk-1", 100_000_000_000
+        ).and_return({ :href => "/#{12341234-1234-1234-1234-123412341234}" })
+        obj = Vcloud::Core::IndependentDisk.create(vdc, "new-disk-1", size)
+        expect(obj.class).to be(Vcloud::Core::IndependentDisk)
+      end
+
+    end
+
+    context "when there is a disk present in the vDC with the same name"  do
+
+      it "raises an error" do
+        mock_query = double(:query_runner)
+        q_results = [ { :name => @disk_name, :href => @disk_id } ]
+        expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+        expect(mock_query).to receive(:run).with(
+          'disk',
+          :filter => "name==#{@disk_name};vdcName==#{@vdc_name}"
+        ).and_return(q_results)
+        expect{ Vcloud::Core::IndependentDisk.create(vdc, @disk_name, 100_000) }.
+          to raise_error(Vcloud::Core::IndependentDisk::DiskAlreadyExistsException)
+      end
+
+    end
+
+  end
+
+  context "attributes" do
+
+    before(:each) {
+      @stub_attrs = {
+        :name => @disk_name,
+        :href => "https://api.vcloud-director.example.com/api/disk/#{@disk_id}",
+        :Link => [{
+          :rel => 'up',
+          :type => 'application/vnd.vmware.vcloud.vdc+xml',
+          :href => 'https://api.vcloud-director.example.com/api/vdc/074aea1e-a5e9-4dd1-a028-40db8c98d237'
+        }]
+      }
+      allow_any_instance_of(StubFogInterface).to receive(:get_disk).and_return(@stub_attrs)
+      @disk = Vcloud::Core::IndependentDisk.new(@disk_id)
+    }
+
+    it { expect(@disk.name).to eq(@disk_name) }
+    it { expect(@disk.id).to eq(@disk_id) }
+
+  end
+
+  context "#attached_vms" do
+
+    subject { Vcloud::Core::IndependentDisk.new(@disk_id) }
+
+    it "returns an empty list if there are no attached vms" do
+      expect(@mock_fog_interface).to receive(:get_vms_disk_attached_to).
+        with(subject.id).and_return({:VmReference=>[]})
+      expect(subject.attached_vms).to eq([])
+    end
+
+    it "returns a list of Core::Vm objects that are attached" do
+      expect(Vcloud::Core::Vapp).to receive(:get_by_child_vm_id).exactly(2).times.and_return({
+        :href => "/vapp-12341234-1234-1234-1234-123412340000"
+      })
+      expect(@mock_fog_interface).to receive(:get_vms_disk_attached_to).
+        with(subject.id).and_return({:VmReference=>[
+          { :href => '/vm-12341234-1234-1234-1234-123412340001' },
+          { :href => '/vm-12341234-1234-1234-1234-123412340002' },
+        ]})
+      vms = subject.attached_vms
+      expect(vms[0].id).to eq('vm-12341234-1234-1234-1234-123412340001')
+      expect(vms[1].id).to eq('vm-12341234-1234-1234-1234-123412340002')
+    end
+
+  end
+
+end
+

data/spec/vcloud/core/vapp_spec.rb

@@ -175,6 +175,34 @@ module Vcloud
 
       end
 
+      context "#get_by_child_vm_id" do
+
+        it "should raise an ArgumentError if an invalid VM id is supplied" do
+          vm_id = 'vapp-12341234-1234-1234-1234-123412341234'
+          expect {Vapp.get_by_child_vm_id(vm_id)}.to raise_error(ArgumentError)
+        end
+
+        it "should return a vApp object if we supply an existing VM id" do
+          vm_id = "vm-12341234-1234-1234-1234-123412340001"
+          vapp_id = "vapp-12341234-1234-1234-1234-123412349999"
+          expect(@mock_fog_interface).to receive(:get_vapp).with(vm_id).and_return({
+            :Link => [
+              { :rel => 'down',
+                :type => "application/vnd.vmware.vcloud.metadata+xml",
+                :href => "/api/vApp/#{vm_id}/metadata"
+              },
+              { :rel => 'up',
+                :type => "application/vnd.vmware.vcloud.vApp+xml",
+                :href => "/api/vApp/#{vapp_id}"
+              }
+            ]
+          })
+          obj = Vapp.get_by_child_vm_id(vm_id)
+          expect(obj.id).to eq(vapp_id)
+        end
+
+      end
+
     end
   end
 end

data/spec/vcloud/core/vm_spec.rb

@@ -56,6 +56,8 @@ module Vcloud
         it { should respond_to(:update_metadata) }
         it { should respond_to(:update_storage_profile) }
         it { should respond_to(:add_extra_disks) }
+        it { should respond_to(:attach_independent_disks) }
+        it { should respond_to(:detach_independent_disks) }
         it { should respond_to(:configure_network_interfaces) }
         it { should respond_to(:configure_guest_customization_section) }
       end
@@ -327,6 +329,48 @@ module Vcloud
 
       end
 
+      context "#attach_independent_disks" do
+
+        let(:disk1) { double(:disk, :name => 'test-disk-1',
+                         :id => '12341234-1234-1234-1234-12345678900')
+        }
+        let(:disk2) { double(:disk, :name => 'test-disk-2',
+                         :id => '12341234-1234-1234-1234-12345678901')
+        }
+        let(:disk3) { double(:disk, :name => 'test-disk-3',
+                         :id => '12341234-1234-1234-1234-12345678902')
+        }
+
+        it "handles attaching an array of Independent Disk objects" do
+          vm = Vm.new(@vm_id, @mock_vapp)
+          disk_array = [disk1, disk2, disk3]
+          expect(@fog_interface).to receive(:post_attach_disk).exactly(disk_array.size).times
+          vm.attach_independent_disks(disk_array)
+        end
+
+      end
+
+      context "#detach_independent_disks" do
+
+        let(:disk1) { double(:disk, :name => 'test-disk-1',
+                         :id => '12341234-1234-1234-1234-12345678900')
+        }
+        let(:disk2) { double(:disk, :name => 'test-disk-2',
+                         :id => '12341234-1234-1234-1234-12345678901')
+        }
+        let(:disk3) { double(:disk, :name => 'test-disk-3',
+                         :id => '12341234-1234-1234-1234-12345678902')
+        }
+
+        it "handles detaching an array of Independent Disk objects" do
+          vm = Vm.new(@vm_id, @mock_vapp)
+          disk_array = [disk1, disk2, disk3]
+          expect(@fog_interface).to receive(:post_detach_disk).exactly(disk_array.size).times
+          vm.detach_independent_disks(disk_array)
+        end
+
+      end
+
     end
   end
 end

data/vcloud-core.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = '>= 1.9.3'
 
-  s.add_runtime_dependency 'fog', '>= 1.22.0'
+  s.add_runtime_dependency 'fog', '>= 1.23.0'
   s.add_runtime_dependency 'mustache'
   s.add_runtime_dependency 'highline'
   s.add_development_dependency 'gem_publisher', '1.2.0'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vcloud-core
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-11 00:00:00.000000000 Z
+date: 2014-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog
-  requirement: &5442080 !ruby/object:Gem::Requirement
+  requirement: &8805340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.22.0
+        version: 1.23.0
   type: :runtime
   prerelease: false
-  version_requirements: *5442080
+  version_requirements: *8805340
 - !ruby/object:Gem::Dependency
   name: mustache
-  requirement: &5461800 !ruby/object:Gem::Requirement
+  requirement: &8804180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *5461800
+  version_requirements: *8804180
 - !ruby/object:Gem::Dependency
   name: highline
-  requirement: &5459000 !ruby/object:Gem::Requirement
+  requirement: &8803000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *5459000
+  version_requirements: *8803000
 - !ruby/object:Gem::Dependency
   name: gem_publisher
-  requirement: &5455320 !ruby/object:Gem::Requirement
+  requirement: &8821020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -54,10 +54,10 @@ dependencies:
         version: 1.2.0
   type: :development
   prerelease: false
-  version_requirements: *5455320
+  version_requirements: *8821020
 - !ruby/object:Gem::Dependency
   name: pry
-  requirement: &5473200 !ruby/object:Gem::Requirement
+  requirement: &8820120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *5473200
+  version_requirements: *8820120
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &5471980 !ruby/object:Gem::Requirement
+  requirement: &8819460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *5471980
+  version_requirements: *8819460
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &5469500 !ruby/object:Gem::Requirement
+  requirement: &8818720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -87,10 +87,10 @@ dependencies:
         version: 2.14.1
   type: :development
   prerelease: false
-  version_requirements: *5469500
+  version_requirements: *8818720
 - !ruby/object:Gem::Dependency
   name: rubocop
-  requirement: &5496580 !ruby/object:Gem::Requirement
+  requirement: &8813100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -98,10 +98,10 @@ dependencies:
         version: 0.23.0
   type: :development
   prerelease: false
-  version_requirements: *5496580
+  version_requirements: *8813100
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &5495720 !ruby/object:Gem::Requirement
+  requirement: &8897220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -109,10 +109,10 @@ dependencies:
         version: 0.7.1
   type: :development
   prerelease: false
-  version_requirements: *5495720
+  version_requirements: *8897220
 - !ruby/object:Gem::Dependency
   name: vcloud-tools-tester
-  requirement: &5493500 !ruby/object:Gem::Requirement
+  requirement: &8895540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -120,7 +120,7 @@ dependencies:
         version: 0.2.0
   type: :development
   prerelease: false
-  version_requirements: *5493500
+  version_requirements: *8895540
 description: Core tools for interacting with VMware vCloud Director. Includes VCloud
   Query, a light wrapper round the vCloud Query API.
 email:
@@ -156,6 +156,7 @@ files:
 - lib/vcloud/core/fog/login.rb
 - lib/vcloud/core/fog/model_interface.rb
 - lib/vcloud/core/fog/service_interface.rb
+- lib/vcloud/core/independent_disk.rb
 - lib/vcloud/core/login_cli.rb
 - lib/vcloud/core/metadata_helper.rb
 - lib/vcloud/core/org_vdc_network.rb
@@ -170,6 +171,7 @@ files:
 - spec/integration/README.md
 - spec/integration/core/edge_gateway_spec.rb
 - spec/integration/core/fog/login_spec.rb
+- spec/integration/core/independent_disk_spec.rb
 - spec/integration/core/query_runner_spec.rb
 - spec/integration/core/vapp_spec.rb
 - spec/integration/core/vdc_spec.rb
@@ -194,6 +196,7 @@ files:
 - spec/vcloud/core/fog/login_spec.rb
 - spec/vcloud/core/fog/service_interface_spec.rb
 - spec/vcloud/core/fog_spec.rb
+- spec/vcloud/core/independent_disk_spec.rb
 - spec/vcloud/core/login_cli_spec.rb
 - spec/vcloud/core/metadata_helper_spec.rb
 - spec/vcloud/core/org_vdc_network_spec.rb
@@ -226,7 +229,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 728476648198716353
+      hash: -425281742654841245
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.11
@@ -237,6 +240,7 @@ test_files:
 - spec/integration/README.md
 - spec/integration/core/edge_gateway_spec.rb
 - spec/integration/core/fog/login_spec.rb
+- spec/integration/core/independent_disk_spec.rb
 - spec/integration/core/query_runner_spec.rb
 - spec/integration/core/vapp_spec.rb
 - spec/integration/core/vdc_spec.rb
@@ -261,6 +265,7 @@ test_files:
 - spec/vcloud/core/fog/login_spec.rb
 - spec/vcloud/core/fog/service_interface_spec.rb
 - spec/vcloud/core/fog_spec.rb
+- spec/vcloud/core/independent_disk_spec.rb
 - spec/vcloud/core/login_cli_spec.rb
 - spec/vcloud/core/metadata_helper_spec.rb
 - spec/vcloud/core/org_vdc_network_spec.rb