vcloud-core 0.7.0 → 0.8.0

data/.gitignore

@@ -1,5 +1,5 @@
 /Gemfile.lock
 /coverage/
-.idea
 spec/integration/vcloud_tools_testing_config.yaml
 .bundle
+.yardoc/

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 0.8.0 (2014-08-07)
+
+API changes:
+
+  - Create new `Vcloud::Core::ApiInterface` that delegates calls to the fog
+    service interface and model interface, so that gems that depend on
+    vCloud Core do not need to know about the inner workings of fog, or
+    about fog at all.
+  - Move fog classes into Core. This API change is not backwards-compatible.
+  - Mark the fog classes `@api private` to clarify that they do not form
+    part of the public API.
+
 ## 0.7.0 (2014-07-28)
 
 Features:

data/lib/vcloud/core.rb

@@ -1,5 +1,6 @@
 require 'open3'
-require 'vcloud/fog'
+require 'vcloud/core/fog'
+require 'vcloud/core/api_interface'
 
 require 'vcloud/core/version'
 

data/lib/vcloud/core/api_interface.rb

@@ -0,0 +1,35 @@
+module Vcloud
+  module Core
+
+    # Public interface to allow direct access to the API
+    # if functionality does not exist in Core
+    class ApiInterface
+
+      def initialize
+        @fog_service_interface = Vcloud::Core::Fog::ServiceInterface.new
+        @fog_model_interface = Vcloud::Core::Fog::ModelInterface.new
+      end
+
+      def get_vapp_by_name_and_vdc_name(name, vdc_name)
+        @fog_service_interface.get_vapp_by_name_and_vdc_name(name, vdc_name)
+      end
+
+      def get_vapp(id)
+        @fog_service_interface.get_vapp(id)
+      end
+
+      def delete_vapp(id)
+        @fog_service_interface.delete_vapp(id)
+      end
+
+      def delete_network(id)
+        @fog_service_interface.delete_network(id)
+      end
+
+      def current_organization
+        @fog_model_interface.current_organization
+      end
+
+    end
+  end
+end

data/lib/vcloud/core/compute_metadata.rb

@@ -3,7 +3,7 @@ module Vcloud
     module ComputeMetadata
 
         def get_metadata id
-          vcloud_compute_metadata =  Vcloud::Fog::ServiceInterface.new.get_vapp_metadata(id)
+          vcloud_compute_metadata =  Vcloud::Core::Fog::ServiceInterface.new.get_vapp_metadata(id)
           MetadataHelper.extract_metadata(vcloud_compute_metadata[:MetadataEntry])
         end
 

data/lib/vcloud/core/edge_gateway.rb

@@ -21,7 +21,7 @@ module Vcloud
       end
 
       def update_configuration(config)
-        fsi = Vcloud::Fog::ServiceInterface.new
+        fsi = Vcloud::Core::Fog::ServiceInterface.new
         fsi.post_configure_edge_gateway_services(id, config)
       end
 
@@ -42,7 +42,7 @@ module Vcloud
       end
 
       def vcloud_attributes
-        fsi = Vcloud::Fog::ServiceInterface.new
+        fsi = Vcloud::Core::Fog::ServiceInterface.new
         fsi.get_edge_gateway(id)
       end
 

data/lib/vcloud/core/fog.rb

@@ -0,0 +1,40 @@
+require 'fog'
+require 'vcloud/core/fog/fog_constants'
+require 'vcloud/core/fog/login'
+require 'vcloud/core/fog/service_interface'
+require 'vcloud/core/fog/model_interface'
+
+module Vcloud
+  module Core
+    module Fog
+      TOKEN_ENV_VAR_NAME = 'FOG_VCLOUD_TOKEN'
+      FOG_CREDS_PASS_NAME = :vcloud_director_password
+
+      def self.check_credentials
+        pass = fog_credentials_pass
+        unless pass.nil? or pass.empty?
+          warn <<EOF
+[WARNING] Storing :vcloud_director_password in your plaintext FOG_RC file is
+          insecure. Future releases of vcloud-core (and tools that depend on
+          it) will prevent you from doing this. Please use vcloud-login to
+          get a session token instead.
+EOF
+        end
+      end
+
+      def self.fog_credentials_pass
+        begin
+          pass = ::Fog.credentials[FOG_CREDS_PASS_NAME]
+        rescue ::Fog::Errors::LoadError
+          # Assume no password if Fog has been unable to load creds.
+          # Suppresses a noisy error about missing credentials.
+          pass = nil
+        end
+
+        pass
+      end
+    end
+  end
+end
+
+Vcloud::Core::Fog.check_credentials

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

@@ -0,0 +1,35 @@
+module Vcloud
+  module Core
+    module Fog
+
+      # Private helper constants for use with the vCloud API.
+      #
+      # @api private
+      module ContentTypes
+        ORG = 'application/vnd.vmware.vcloud.org+xml'
+        VDC = 'application/vnd.vmware.vcloud.vdc+xml'
+        NETWORK = 'application/vnd.vmware.vcloud.network+xml'
+        METADATA = 'application/vnd.vmware.vcloud.metadata.value+xml'
+      end
+
+      # Private helper constants for use with the vCloud API.
+      #
+      # @api private
+      module MetadataValueType
+        String = 'MetadataStringValue'
+        Number = 'MetadataNumberValue'
+        DateTime = 'MetadataDateTimeValue'
+        Boolean = 'MetadataBooleanValue'
+      end
+
+      # Private helper constants for use with the vCloud API.
+      #
+      # @api private
+      module RELATION
+        PARENT = 'up'
+        CHILD = 'down'
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require 'fog'
+
+module Vcloud
+  module Core
+    module Fog
+      module Login
+        class << self
+          def token(pass)
+            check_plaintext_pass
+            token = get_token(pass)
+
+            return token
+          end
+
+          def token_export(*args)
+            return "export #{Vcloud::Core::Fog::TOKEN_ENV_VAR_NAME}=#{token(*args)}"
+          end
+
+          private
+
+          def check_plaintext_pass
+            pass = Vcloud::Core::Fog::fog_credentials_pass
+            unless pass.nil? || pass.empty?
+              raise "Found plaintext #{Vcloud::Core::Fog::FOG_CREDS_PASS_NAME} entry. Please set it to an empty string"
+            end
+          end
+
+          def get_token(pass)
+            ENV.delete(Vcloud::Core::Fog::TOKEN_ENV_VAR_NAME)
+            vcloud = ::Fog::Compute::VcloudDirector.new({
+              Vcloud::Core::Fog::FOG_CREDS_PASS_NAME => pass,
+            })
+
+            return vcloud.vcloud_token
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Vcloud
+  module Core
+    module Fog
+
+      # Private interface to the fog model layer.
+      # You should not use this directly. Expose required
+      # functionality in {Vcloud::Core::ApiInterface}
+      #
+      # @api private
+      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
+end

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

@@ -0,0 +1,253 @@
+require 'forwardable'
+
+module Vcloud
+  module Core
+    module Fog
+
+      # Private interface to the fog service layer.
+      # You should not use this directly. Expose required
+      # functionality in {Vcloud::Core::ApiInterface}
+      #
+      # @api private
+      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_complete, :delete_network, :post_create_org_vdc_network,
+                       :post_configure_edge_gateway_services, :get_vdc, :post_undeploy_vapp
+
+        #########################
+        # 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(id)
+            @vcloud.get_vdc(id).body
+          end
+
+          def get_organization (id)
+            @vcloud.get_organization(id).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 post_instantiate_vapp_template(vdc, template, name, params)
+            Vcloud::Core.logger.debug("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.debug("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.debug("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.debug("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 post_undeploy_vapp(vapp_id)
+            task = @vcloud.post_undeploy_vapp(vapp_id).body
+            @vcloud.process_task(task)
+          end
+
+          def delete_vapp(vapp_id)
+            task = @vcloud.delete_vapp(vapp_id).body
+            @vcloud.process_task(task)
+          end
+
+          def get_network_complete(id)
+            @vcloud.get_network_complete(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.debug("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_complete(extract_id(attrs))
+          end
+
+          def post_configure_edge_gateway_services(edgegw_id, config)
+            Vcloud::Core.logger.info("Updating EdgeGateway #{edgegw_id}")
+            begin
+              task = @vcloud.post_configure_edge_gateway_services(edgegw_id, config).body
+              @vcloud.process_task(task)
+            rescue => ex
+              Vcloud::Core.logger.error("Could not update EdgeGateway #{edgegw_id} : #{ex}")
+              raise
+            end
+          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.debug("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 put_vapp_metadata_value(id, k, v)
+            Vcloud::Core.logger.debug("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 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 put_network_connection_system_section_vapp(vm_id, section)
+          begin
+            Vcloud::Core.logger.debug("adding NIC into VM #{vm_id}")
+            @fog.put_network_connection_system_section_vapp(vm_id, section)
+          rescue => ex
+            Vcloud::Core.logger.error("failed to put_network_connection_system_section_vapp for vm #{vm_id}: #{ex}")
+            Vcloud::Core.logger.debug("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.debug("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 => ex
+            Vcloud::Core.logger.error("Failed to update guest customization section: #{ex}")
+            Vcloud::Core.logger.debug("=== interpolated preamble:")
+            Vcloud::Core.logger.debug(script)
+            raise
+          end
+        end
+
+        private
+        def extract_id(link)
+          link[:href].split('/').last
+        end
+
+      end
+
+    end
+  end
+end