fog-maestrodev 1.15.0.20130829165835 → 1.15.0.20130927082724

data/lib/fog/vcloud_director/compute.rb

@@ -0,0 +1,398 @@
+require 'fog/vcloud_director'
+require 'fog/compute'
+require 'fog/vcloud_director/requests/compute/helper'
+
+class VcloudDirectorParser < Fog::Parsers::Base
+  def extract_attributes(attributes_xml)
+    attributes = {}
+    until attributes_xml.empty?
+      if attributes_xml.first.is_a?(Array)
+        until attributes_xml.first.empty?
+          attribute = attributes_xml.first.shift
+          attributes[attribute.localname.to_sym] = attribute.value
+        end
+      else
+        attribute = attributes_xml.shift
+        attributes[attribute.localname.to_sym] = attribute.value
+      end
+    end
+    attributes
+  end
+end
+
+class NonLoaded
+end
+
+module Fog
+  module Compute
+    class VcloudDirector < Fog::Service
+
+      module Defaults
+        PATH        = '/api'
+        PORT        = 443
+        SCHEME      = 'https'
+        API_VERSION = '5.1'
+      end
+
+      module Errors
+        class ServiceError < Fog::Errors::Error; end
+        class Task < ServiceError; end
+      end
+
+      requires :vcloud_director_username, :vcloud_director_password, :vcloud_director_host
+      recognizes :vcloud_director_api_version
+
+      secrets :vcloud_director_password
+
+      model_path 'fog/vcloud_director/models/compute'
+      model      :catalog
+      collection :catalogs
+      model      :organization
+      collection :organizations
+      model      :catalog_item
+      collection :catalog_items
+      model      :vdc
+      collection :vdcs
+      model      :vapp
+      collection :vapps
+      model      :task
+      collection :tasks
+      model      :vm
+      collection :vms
+      model      :vm_customization
+      collection :vm_customizations
+      model      :network
+      collection :networks
+      model      :disk
+      collection :disks
+      model      :vm_network
+      collection :vm_networks
+      model      :tag # this is called metadata in vcloud
+      collection :tags
+
+      request_path 'fog/vcloud_director/requests/compute'
+      request :get_organizations
+      request :get_organization
+      request :get_catalog
+      request :get_catalog_item
+      request :get_vdc
+      request :get_vapp_template
+      request :get_vapp
+      request :get_vms
+      request :instantiate_vapp_template
+      request :get_task
+      request :get_tasks_list
+      request :get_vm_customization
+      request :put_vm_customization
+      request :get_network
+      request :get_vm_cpu
+      request :put_vm_cpu
+      request :get_vm_memory
+      request :put_vm_memory
+      request :get_vm_disks
+      request :put_vm_disks
+      request :get_vm_network
+      request :put_vm_network
+      request :get_metadata
+      request :post_vm_metadata
+      request :put_metadata_value
+      request :delete_metadata
+      request :post_vm_poweron
+      request :post_vm_poweroff
+      request :get_request # this is used for manual testing
+      request :get_href    # this is used for manual testing
+      request :get_vms_by_metadata
+      request :get_vm
+      request :post_task_cancel
+      request :post_vapp_undeploy
+      request :delete_vapp
+      request :get_current_session
+      request :get_supported_versions
+
+      class Model < Fog::Model
+        def initialize(attrs={})
+          super(attrs)
+          lazy_load_attrs.each do |attr|
+            attributes[attr]= NonLoaded if attributes[attr].nil?
+            make_lazy_load_method(attr)
+          end
+          self.class.attributes.each {|attr| make_attr_loaded_method(attr)}
+        end
+
+        def lazy_load_attrs
+          @lazy_load_attrs ||= self.class.attributes - attributes.keys
+        end
+
+        def make_lazy_load_method(attr)
+          self.class.instance_eval do
+            define_method(attr) do
+              reload if attributes[attr] == NonLoaded and !@inspecting
+              attributes[attr]
+            end
+          end
+        end
+
+        # it adds an attr_loaded? method to know if the value has been loaded
+        # yet or not: ie description_loaded?
+        def make_attr_loaded_method(attr)
+          self.class.instance_eval do
+            define_method("#{attr}_loaded?") do
+              attributes[attr] != NonLoaded
+            end
+          end
+        end
+
+        def inspect
+          @inspecting = true
+          out = super
+          @inspecting = false
+          out
+        end
+      end
+
+      class Collection < Fog::Collection
+        def all(lazy_load=true)
+          lazy_load ? index : get_everyone
+        end
+
+        def get(item_id)
+          item = get_by_id(item_id)
+          return nil unless item
+          new(item)
+        end
+
+        def get_by_name(item_name)
+          item_found = item_list.detect {|item| item[:name] == item_name}
+          return nil unless item_found
+          get(item_found[:id])
+        end
+
+        def index
+          load(item_list)
+        end
+
+        def get_everyone
+          items = item_list.map {|item| get_by_id(item[:id])}
+          load(items)
+        end
+
+        def ensure_list(items)
+          items.is_a?(Hash) ? [items] : items
+        end
+      end
+
+      class Real
+        include Fog::Compute::Helper
+
+        attr_reader :end_point, :api_version
+
+        def initialize(options={})
+          @vcloud_director_password = options[:vcloud_director_password]
+          @vcloud_director_username = options[:vcloud_director_username]
+          @connection_options = options[:connection_options] || {}
+          @host       = options[:vcloud_director_host]
+          @path       = options[:path]        || Fog::Compute::VcloudDirector::Defaults::PATH
+          @persistent = options[:persistent]  || false
+          @port       = options[:port]        || Fog::Compute::VcloudDirector::Defaults::PORT
+          @scheme     = options[:scheme]      || Fog::Compute::VcloudDirector::Defaults::SCHEME
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
+          @end_point = "#{@scheme}://#{@host}#{@path}/"
+          @api_version = options[:vcloud_director_api_version] || Fog::Compute::VcloudDirector::Defaults::API_VERSION
+        end
+
+        def auth_token
+          login if @auth_token.nil?
+          @auth_token
+        end
+
+        def org_name
+          login if @org_name.nil?
+          @org_name
+        end
+
+        def reload
+          @cookie = nil # verify that this makes the connection to be restored, if so use Excon::Errors::Forbidden instead of Excon::Errors::Unauthorized
+          @connection.reset
+        end
+
+        def request(params)
+          unless @cookie
+            @cookie = auth_token
+          end
+          begin
+            do_request(params)
+          # this is to know if Excon::Errors::Unauthorized really happens
+          #rescue Excon::Errors::Unauthorized
+          #  @cookie = auth_token
+          #  do_request(params)
+          end
+        end
+
+        def do_request(params)
+          headers = { 'Accept' => 'application/*+xml;version=' +  @api_version }
+          if @cookie
+            headers.merge!('Cookie' => @cookie)
+          end
+          if params[:path]
+            if params[:override_path] == true
+              path = params[:path]
+            else
+              path = "#{@path}/#{params[:path]}"
+            end
+          else
+            path = "#{@path}"
+          end
+          @connection.request({
+            :body    => params[:body],
+            :expects => params[:expects],
+            :headers => headers.merge!(params[:headers] || {}),
+            :host    => @host,
+            :method  => params[:method],
+            :parser  => params[:parser],
+            :path    => path
+          })
+        rescue => @e
+          raise @e unless @e.class.to_s =~ /^Excon::Errors/
+          if @e.respond_to?(:response)
+            puts @e.response.status
+            puts CGI::unescapeHTML(@e.response.body)
+          end
+          raise @e
+        end
+
+        def process_task(response_body)
+          task = make_task_object(response_body)
+          wait_and_raise_unless_success(task)
+          true
+        end
+
+        def make_task_object(task_response)
+          task_response[:id] = task_response[:href].split('/').last
+          tasks.new(task_response)
+        end
+
+        def wait_and_raise_unless_success(task)
+          task.wait_for { non_running? }
+          raise Errors::Task.new "status: #{task.status}, error: #{task.error}" unless task.success?
+        end
+
+        def add_id_from_href!(data={})
+          data[:id] = data[:href].split('/').last
+        end
+
+        private
+
+        def login
+          headers = {
+            'Authorization' => "Basic #{Base64.encode64("#{@vcloud_director_username}:#{@vcloud_director_password}").delete("\r\n")}",
+            'Accept'        => 'application/*+xml;version=' + @api_version
+          }
+          response = @connection.request({
+            :expects => 200,
+            :headers => headers,
+            :host    => @host,
+            :method  => 'POST',
+            :parser  => Fog::ToHashDocument.new,
+            :path    => '/api/sessions'  # curl http://example.com/api/versions | grep LoginUrl
+          })
+          @auth_token = response.headers['Set-Cookie'] || response.headers['set-cookie']
+          @org_name = response.body[:org]
+        end
+      end
+
+      class Mock
+        attr_reader :end_point, :api_version
+
+        def data
+          @@data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :catalog => {
+                :name => 'Default Catalog',
+                :uuid => uuid
+              },
+              :catalog_items => [{
+                :type => 'vAppTemplate',
+                :name => 'vAppTemplate 1',
+                :uuid => uuid
+              }],
+              :networks => [{
+                :name => 'Default Network',
+                :uuid => uuid
+              }],
+              :org => {
+                :description => 'Organization for mocking',
+                :full_name => 'Mock Organization',
+                :name => org_name,
+                :uuid => uuid
+              },
+              :vdc => {
+                :description => 'vDC for mocking',
+                :name => 'MockVDC',
+                :uuid => uuid
+              }
+            }
+          end[@vcloud_director_username]
+        end
+
+        def initialize(options={})
+          @vcloud_director_password = options[:vcloud_director_password]
+          @vcloud_director_username = options[:vcloud_director_username]
+          #@connection_options = options[:connection_options] || {}
+          @host = options[:vcloud_director_host]
+          @path = options[:path] || Fog::Compute::VcloudDirector::Defaults::PATH
+          @persistent = options[:persistent] || false
+          @port = options[:port] || Fog::Compute::VcloudDirector::Defaults::PORT
+          @scheme = options[:scheme] || Fog::Compute::VcloudDirector::Defaults::SCHEME
+          #@connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
+          @end_point = "#{@scheme}://#{@host}#{@path}/"
+          @api_version = options[:vcloud_director_api_version] || Fog::Compute::VcloudDirector::Defaults::API_VERSION
+        end
+
+        def auth_token
+          @auth_token || Fog::Mock.random_base64(32)
+        end
+
+        def org_name
+          @org_name ||=
+            begin
+              username = @vcloud_director_username.split('@')
+              unless username.size == 2
+                Fog::Logger.warning('vcloud_director_username should be in the form user@org_name')
+              end
+              username.last || 'vcd_org_name'
+            end
+        end
+
+        def user_name
+          @user_name ||= @vcloud_director_username.split('@').first
+        end
+
+        def uuid
+          [8,4,4,4,12].map {|i| Fog::Mock.random_hex(i)}.join('-')
+        end
+
+        def add_id_from_href!(data={})
+          data[:id] = data[:href].split('/').last
+        end
+
+        private
+
+        def make_href(path)
+          "#{@end_point}#{path}"
+        end
+
+        def xmlns
+          'http://www.vmware.com/vcloud/v1.5'
+        end
+
+        def xmlns_xsi
+          'http://www.w3.org/2001/XMLSchema-instance'
+        end
+
+        def xsi_schema_location
+          "http://www.vmware.com/vcloud/v1.5 http://#{@host}#{@path}/v1.5/schema/master.xsd"
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud_director/generators/compute/customization.rb

@@ -0,0 +1,100 @@
+# This is the data structure it accepts, this is the output of get_vm_disks
+#
+# {"type"=>"application/vnd.vmware.vcloud.guestCustomizationSection+xml",
+#  "href"=>
+#   "https://example.com/api/vApp/vm-2bbbf556-55dc-4974-82e6-aa6e814f0b64/guestCustomizationSection/",
+#  "id"=>"vm-2bbbf556-55dc-4974-82e6-aa6e814f0b64",
+#  "enabled"=>false,
+#  "change_sid"=>false,
+#  "virtual_machine_id"=>"2bbbf556-55dc-4974-82e6-aa6e814f0b64",
+#  "join_domain_enabled"=>false,
+#  "use_org_settings"=>false,
+#  "admin_password_enabled"=>false,
+#  "admin_password_auto"=>true,
+#  "reset_password_required"=>false,
+#  "customization_script"=>"hola\nmundo",
+#  "has_customization_script"=>true,
+#  "computer_name"=>"DEVWEB-001"}
+#
+# This is what it generates
+#
+# <vcloud:GuestCustomizationSection
+#   xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"
+#   xmlns:vcloud="http://www.vmware.com/vcloud/v1.5"
+#   href="https://vcloud.example.com/api/vApp/vm-55cc91f2-7e12-48d4-ad90-6f637a51fd88/guestCustomizationSection/"
+#   ovf:required="false"
+#   type="application/vnd.vmware.vcloud.guestCustomizationSection+xml">
+#   <ovf:Info>Specifies Guest OS Customization Settings</ovf:Info>
+#   <vcloud:Enabled>true</vcloud:Enabled>
+#   <vcloud:ChangeSid>true</vcloud:ChangeSid>
+#   <vcloud:VirtualMachineId>55cc91f2-7e12-48d4-ad90-6f637a51fd88</vcloud:VirtualMachineId>
+#   <vcloud:JoinDomainEnabled>false</vcloud:JoinDomainEnabled>
+#   <vcloud:UseOrgSettings>false</vcloud:UseOrgSettings>
+#   <vcloud:AdminPasswordEnabled>true</vcloud:AdminPasswordEnabled>
+#   <vcloud:AdminPasswordAuto>true</vcloud:AdminPasswordAuto>
+#   <vcloud:ResetPasswordRequired>false</vcloud:ResetPasswordRequired>
+#   <vcloud:ComputerName>DEVWEB-001</vcloud:ComputerName>
+# </vcloud:GuestCustomizationSection>
+#
+module Fog
+  module Generators
+    module Compute
+      module VcloudDirector
+
+        class Customization
+
+          def initialize(attrs={})
+            @attrs = attrs
+          end
+
+          def generate_xml
+            output = ""
+            output << header
+            output << body(@attrs)
+            output << tail
+            output
+          end
+
+          def header
+            '<GuestCustomizationSection xmlns="http://www.vmware.com/vcloud/v1.5"
+              xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"
+              type="application/vnd.vmware.vcloud.guestCustomizationSection+xml"
+              ovf:required="false"
+              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+              xsi:schemaLocation="http://schemas.dmtf.org/ovf/envelope/1
+                http://schemas.dmtf.org/ovf/envelope/1/dsp8023_1.1.0.xsd
+                http://www.vmware.com/vcloud/v1.5
+                http://zone01.bluelock.com/api/v1.5/schema/master.xsd">'
+          end
+
+          # the order maters http://communities.vmware.com/thread/448760?start=0&tstart=0
+
+          # http://www.vmware.com/support/vcd/doc/rest-api-doc-1.5-html/types/GuestCustomizationSectionType.html
+          # CustomizationScript
+          # Script to run on guest customization. You could use xml escape sequence &#13; to make multiple lines script. The script could contain any UNICODE symbol by specifying its number in format &#xxxx; where xxxx is the number. The predefined symbols in the XML are: * & &amp; * < &lt; * > &gt; * " &quot; * ' &apos;
+
+          def body(opts={})
+            body = "
+              <ovf:Info>Specifies Guest OS Customization Settings</ovf:Info>
+              <Enabled>#{opts[:enabled]}</Enabled>
+              <ChangeSid>#{opts[:change_sid]}</ChangeSid>
+              <VirtualMachineId>#{opts[:virtual_machine_id]}</VirtualMachineId>
+              <JoinDomainEnabled>#{opts[:join_domain_enabled]}</JoinDomainEnabled>
+              <UseOrgSettings>#{opts[:use_org_settings]}</UseOrgSettings>
+              <AdminPasswordEnabled>#{opts[:admin_password_enabled]}</AdminPasswordEnabled>
+              <AdminPasswordAuto>#{opts[:admin_password_auto]}</AdminPasswordAuto>
+              <ResetPasswordRequired>#{opts[:reset_password_required]}</ResetPasswordRequired>
+              <CustomizationScript>#{CGI::escapeHTML(opts[:customization_script]).gsub(/\r/, "&#13;")}</CustomizationScript>
+              <ComputerName>#{opts[:computer_name]}</ComputerName>"
+          end
+
+          def tail
+            '</GuestCustomizationSection>'
+          end
+
+        end
+
+      end
+    end
+  end
+end