vcloud-core 0.0.1

data/lib/vcloud/core/query.rb

@@ -0,0 +1,142 @@
+require 'csv'
+
+module Vcloud
+  class Query
+
+    attr_reader :type
+    attr_reader :options
+
+    def initialize(type=nil, options={})
+      @type = type
+      @options = options
+      @options[:output_format] ||= 'tsv'
+      Fog.mock! if ENV['FOG_MOCK'] || options[:mock]
+      @fsi = Vcloud::Fog::ServiceInterface.new
+    end
+
+    def filter
+      options[:filter]
+    end
+
+    def output_format
+      options[:output_format]
+    end
+
+    def fields
+      options[:fields]
+    end
+
+    def run()
+
+      puts "options:" if @options[:debug]
+      pp @options if @options[:debug]
+
+      if @type.nil?
+        output_potential_query_types
+      else
+        output_query_results
+      end
+    end
+
+    def get_all_results
+      results = []
+      (1..get_num_pages).each do |page|
+        results += get_results_page(page) || []
+      end
+      results
+    end
+
+    private
+
+    def get_num_pages
+      body = @fsi.get_execute_query(type=@type, @options)
+      last_page = body[:lastPage] || 1
+      raise "Invalid lastPage (#{last_page}) in query results" unless last_page.is_a? Integer
+      return last_page.to_i
+    end
+
+    def get_results_page(page)
+      raise "Must supply a page number" if page.nil?
+
+      begin
+        body = @fsi.get_execute_query(type=@type, @options.merge({:page=>page}))
+        pp body if @options[:debug]
+      rescue ::Fog::Compute::VcloudDirector::BadRequest, ::Fog::Compute::VcloudDirector::Forbidden => e
+        raise "Access denied: #{e.message}"
+      end
+
+      records = body.keys.detect {|key| key.to_s =~ /Record|Reference$/}
+      body[records] = [body[records]] if body[records].is_a?(Hash)
+      return nil if body[records].nil? || body[records].empty?
+      body[records]
+
+    end
+
+    def output_query_results
+      results = get_all_results
+      output_header(results)
+      output_results(results)
+    end
+
+    def output_potential_query_types
+
+      query_list = @fsi.get_execute_query
+      queries = {}
+      type_width = 0
+      query_list[:Link].select do |link|
+        link[:rel] == 'down'
+      end.map do |link|
+        href = Nokogiri::XML.fragment(link[:href])
+        query = CGI.parse(URI.parse(href.text).query)
+        [query['type'].first, query['format'].first]
+      end.each do |type, format|
+        queries[type] ||= []
+        queries[type] << format
+        type_width = [type_width, type.size].max
+      end
+      queries.keys.sort.each do |type|
+        puts "%-#{type_width}s %s" % [type, queries[type].sort.join(',')]
+      end
+
+    end
+
+    def output_header(results)
+      return if results.size == 0
+      case @options[:output_format]
+      when 'csv'
+        csv_string = CSV.generate do |csv|
+          csv << results.first.keys
+        end
+        puts csv_string
+      when 'tsv'
+        puts results.first.keys.join("\t")
+      end
+    end
+
+    def output_results(results)
+      return if results.size == 0
+
+      case @options[:output_format]
+      when 'yaml'
+        puts YAML.dump(results)
+      when 'csv'
+        csv_string = CSV.generate do |csv|
+          results.each do |record|
+            csv << record.values
+          end
+        end
+        puts csv_string
+      when 'tsv'
+        puts results.first.keys.join("\t") if @options[:page] == 1
+        results.each do |record|
+          puts record.values.join("\t")
+        end
+      else
+        raise "Unsupported output format #{@options[:output_format]}"
+      end
+
+    end
+
+  end
+end
+

data/lib/vcloud/core/vapp.rb

@@ -0,0 +1,118 @@
+module Vcloud
+  module Core
+    class Vapp
+      extend ComputeMetadata
+
+      attr_reader :id
+
+      def initialize(id)
+        unless id =~ /^#{self.class.id_prefix}-[-0-9a-f]+$/
+          raise "#{self.class.id_prefix} id : #{id} is not in correct format"
+        end
+        @id = id
+      end
+
+      def self.get_by_name(name)
+        q = Query.new('vApp', :filter => "name==#{name}")
+        unless res = q.get_all_results
+          raise "Error finding vApp by name #{name}"
+        end
+        case res.size
+        when 0
+          raise "vApp #{name} not found"
+        when 1
+          return self.new(res.first[:href].split('/').last)
+        else
+          raise "found multiple vApp entities with name #{name}!"
+        end
+      end
+
+      def vcloud_attributes
+        Vcloud::Fog::ServiceInterface.new.get_vapp(id)
+      end
+
+      module STATUS
+        RUNNING = 4
+      end
+
+      def name
+        vcloud_attributes[:name]
+      end
+
+      def href
+        vcloud_attributes[:href]
+      end
+
+      def vdc_id
+        link = vcloud_attributes[:Link].detect { |l| l[:rel] == Fog::RELATION::PARENT && l[:type] == Fog::ContentTypes::VDC }
+        link ? link[:href].split('/').last : raise('a vapp without parent vdc found')
+      end
+
+      def fog_vms
+        vcloud_attributes[:Children][:Vm]
+      end
+
+      def networks
+        vcloud_attributes[:'ovf:NetworkSection'][:'ovf:Network']
+      end
+
+      def self.get_by_name_and_vdc_name(name, vdc_name)
+        fog_interface = Vcloud::Fog::ServiceInterface.new
+        attrs = fog_interface.get_vapp_by_name_and_vdc_name(name, vdc_name)
+        self.new(attrs[:href].split('/').last) if attrs && attrs.key?(:href)
+      end
+
+      def self.instantiate(name, network_names, template_id, vdc_name)
+        Vcloud::Core.logger.info("Instantiating new vApp #{name} in vDC '#{vdc_name}'")
+        fog_interface = Vcloud::Fog::ServiceInterface.new
+        networks = get_networks(network_names, vdc_name)
+
+        attrs = fog_interface.post_instantiate_vapp_template(
+            fog_interface.vdc(vdc_name),
+            template_id,
+            name,
+            InstantiationParams: build_network_config(networks)
+        )
+        self.new(attrs[:href].split('/').last) if attrs and attrs.key?(:href)
+      end
+
+      def power_on
+        raise "Cannot power on a missing vApp." unless id
+        return true if running?
+        Vcloud::Fog::ServiceInterface.new.power_on_vapp(id)
+        running?
+      end
+
+      private
+      def running?
+        raise "Cannot call running? on a missing vApp." unless id
+        vapp = Vcloud::Fog::ServiceInterface.new.get_vapp(id)
+        vapp[:status].to_i == STATUS::RUNNING ? true : false
+      end
+
+      def self.build_network_config(networks)
+        return {} unless networks
+        instantiation = { NetworkConfigSection: {NetworkConfig: []} }
+        networks.compact.each do |network|
+          instantiation[:NetworkConfigSection][:NetworkConfig] << {
+              networkName: network[:name],
+              Configuration: {
+                  ParentNetwork: {href: network[:href]},
+                  FenceMode: 'bridged',
+              }
+          }
+        end
+        instantiation
+      end
+
+      def self.id_prefix
+        'vapp'
+      end
+
+      def self.get_networks(network_names, vdc_name)
+        fsi = Vcloud::Fog::ServiceInterface.new
+        fsi.find_networks(network_names, vdc_name) if network_names
+      end
+    end
+  end
+end

data/lib/vcloud/core/vapp_template.rb

@@ -0,0 +1,39 @@
+module Vcloud
+  module Core
+    class VappTemplate
+
+      attr_reader :id
+
+      def initialize(id)
+        unless id =~ /^#{self.class.id_prefix}-[-0-9a-f]+$/
+          raise "#{self.class.id_prefix} id : #{id} is not in correct format"
+        end
+        @id = id
+      end
+
+      def vcloud_attributes
+        Vcloud::Fog::ServiceInterface.new.get_vapp_template(id)
+      end
+
+      def href
+        vcloud_attributes[:href]
+      end
+
+      def name
+        vcloud_attributes[:name]
+      end
+
+      def self.get catalog_name, catalog_item_name
+        raise "provide catalog and catalog item name to load vappTemplate" unless catalog_name && catalog_item_name
+        body = Vcloud::Fog::ServiceInterface.new.template(catalog_name, catalog_item_name)
+        raise 'Could not find template vApp' unless body && body.key?(:href)
+        self.new(body[:href].split('/').last)
+      end
+
+      def self.id_prefix
+        'vappTemplate'
+      end
+
+    end
+  end
+end

data/lib/vcloud/core/vdc.rb

@@ -0,0 +1,37 @@
+module Vcloud
+  module Core
+    class Vdc
+
+      attr_reader :id
+
+      def initialize(id)
+        unless id =~ /^[-0-9a-f]+$/
+          raise "vdc id : #{id} is not in correct format"
+        end
+        @id = id
+      end
+
+      def self.get_by_name(name)
+        q = Query.new('orgVdc', :filter => "name==#{name}")
+        unless res = q.get_all_results
+          raise "Error finding vDC by name #{name}"
+        end
+        raise "vDc #{name} not found" unless res.size == 1
+        return self.new(res.first[:href].split('/').last)
+      end
+
+      def vcloud_attributes
+        Vcloud::Fog::ServiceInterface.new.get_vdc(id)
+      end
+
+      def name
+        vcloud_attributes[:name]
+      end
+
+      def href
+        vcloud_attributes[:href]
+      end
+
+    end
+  end
+end

data/lib/vcloud/core/version.rb

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

data/lib/vcloud/core/vm.rb

@@ -0,0 +1,162 @@
+module Vcloud
+  module Core
+    class Vm
+      extend ComputeMetadata
+
+      attr_reader :id
+
+      def initialize(id, vapp)
+        unless id =~ /^#{self.class.id_prefix}-[-0-9a-f]+$/
+          raise "#{self.class.id_prefix} id : #{id} is not in correct format"
+        end
+        @id = id
+        @vapp = vapp
+      end
+
+      def vcloud_attributes
+        Vcloud::Fog::ServiceInterface.new.get_vapp(id)
+      end
+
+      def update_memory_size_in_mb(new_memory)
+        return if new_memory.nil?
+        return if new_memory.to_i < 64
+        unless memory.to_i == new_memory.to_i
+          Vcloud::Fog::ServiceInterface.new.put_memory(id, new_memory)
+        end
+      end
+
+      def memory
+        memory_item = virtual_hardware_section.detect { |i| i[:'rasd:ResourceType'] == '4' }
+        memory_item[:'rasd:VirtualQuantity']
+      end
+
+      def cpu
+        cpu_item = virtual_hardware_section.detect { |i| i[:'rasd:ResourceType'] == '3' }
+        cpu_item[:'rasd:VirtualQuantity']
+      end
+
+      def name
+        vcloud_attributes[:name]
+      end
+
+      def href
+        vcloud_attributes[:href]
+      end
+
+      def update_name(new_name)
+        fsi = Vcloud::Fog::ServiceInterface.new
+        fsi.put_vm(id, new_name) unless name == new_name
+      end
+
+      def vapp_name
+        @vapp.name
+      end
+
+      def update_cpu_count(new_cpu_count)
+        return if new_cpu_count.nil?
+        return if new_cpu_count.to_i == 0
+        unless cpu.to_i == new_cpu_count.to_i
+          Vcloud::Fog::ServiceInterface.new.put_cpu(id, new_cpu_count)
+        end
+      end
+
+      def update_metadata(metadata)
+        return if metadata.nil?
+        fsi = Vcloud::Fog::ServiceInterface.new
+        metadata.each do |k, v|
+          fsi.put_vapp_metadata_value(@vapp.id, k, v)
+          fsi.put_vapp_metadata_value(id, k, v)
+        end
+      end
+
+      def add_extra_disks(extra_disks)
+        vm = Vcloud::Fog::ModelInterface.new.get_vm_by_href(href)
+        if extra_disks
+          extra_disks.each do |extra_disk|
+            Vcloud::Core.logger.info("adding a disk of size #{extra_disk[:size]}MB into VM #{id}")
+            vm.disks.create(extra_disk[:size])
+          end
+        end
+      end
+
+      def configure_network_interfaces(networks_config)
+        return unless networks_config
+        section = {PrimaryNetworkConnectionIndex: 0}
+        section[:NetworkConnection] = networks_config.compact.each_with_index.map do |network, i|
+          connection = {
+              network: network[:name],
+              needsCustomization: true,
+              NetworkConnectionIndex: i,
+              IsConnected: true
+          }
+          ip_address = network[:ip_address]
+          connection[:IpAddress] = ip_address unless ip_address.nil?
+          connection[:IpAddressAllocationMode] = ip_address ? 'MANUAL' : 'DHCP'
+          connection
+        end
+        Vcloud::Fog::ServiceInterface.new.put_network_connection_system_section_vapp(id, section)
+      end
+
+      def configure_guest_customization_section(name, bootstrap_config, extra_disks)
+        if bootstrap_config.nil? or bootstrap_config[:script_path].nil?
+          interpolated_preamble = ''
+        else
+          preamble_vars = bootstrap_config[:vars].merge(:extra_disks => extra_disks)
+          interpolated_preamble = generate_preamble(
+              bootstrap_config[:script_path],
+              bootstrap_config[:script_post_processor],
+              preamble_vars,
+          )
+        end
+        Vcloud::Fog::ServiceInterface.new.put_guest_customization_section(id, name, interpolated_preamble)
+      end
+
+      def generate_preamble(script_path, script_post_processor, vars)
+        vapp_name = @vapp.name
+        script = ERB.new(File.read(File.expand_path(script_path)), nil, '>-')
+        .result(binding)
+        if script_post_processor
+          script = Open3.capture2(File.expand_path(script_post_processor),
+                                  stdin_data: script).first
+        end
+        script
+      end
+
+      def update_storage_profile storage_profile
+        storage_profile_href = get_storage_profile_href_by_name(storage_profile, @vapp.name)
+        Vcloud::Fog::ServiceInterface.new.put_vm(id, name, {
+          :StorageProfile => {
+            name: storage_profile,
+            href: storage_profile_href
+          }
+        })
+      end
+
+      private
+      def virtual_hardware_section
+        vcloud_attributes[:'ovf:VirtualHardwareSection'][:'ovf:Item']
+      end
+
+      def get_storage_profile_href_by_name(storage_profile_name, vapp_name)
+        q = Query.new('vApp', :filter => "name==#{vapp_name}")
+        vdc_results = q.get_all_results
+        vdc_name = vdc_results.first[:vdcName]
+
+        q = Query.new('orgVdcStorageProfile', :filter => "name==#{storage_profile_name};vdcName==#{vdc_name}")
+        sp_results = q.get_all_results
+
+        if sp_results.empty? or !sp_results.first.has_key?(:href)
+          raise "storage profile not found"
+        else
+          return sp_results.first[:href]
+        end
+      end
+
+      def self.id_prefix
+        'vm'
+      end
+
+    end
+
+  end
+end