lib/fog/vcloud/compute.rb
require 'fog/vcloud/core'
module Fog
module Vcloud
class Collection < Fog::Collection
def load(objects)
objects = [ objects ] if objects.is_a?(Hash)
super
end
def check_href!(opts = {})
self.href = service.default_vdc_href unless href
unless href
if opts.is_a?(String)
t = Hash.new
t[:parent] = opts
opts = t
end
msg = ":href missing, call with a :href pointing to #{if opts[:message]
opts[:message]
elsif opts[:parent]
"the #{opts[:parent]} whose #{self.class.to_s.split('::').last.downcase} you want to enumerate"
else
"the resource"
end}"
raise Fog::Errors::Error.new(msg)
end
end
end
end
end
module Fog
module Vcloud
class Model < Fog::Model
attr_accessor :loaded
alias_method :loaded?, :loaded
def reload
instance = super
@loaded = true
instance
end
def load_unless_loaded!
unless @loaded
reload
end
end
def link_up
load_unless_loaded!
self.links.find{|l| l[:rel] == 'up' }
end
def self.has_up(item)
class_eval <<-EOS, __FILE__,__LINE__
def #{item}
load_unless_loaded!
service.get_#{item}(link_up[:href])
end
EOS
end
end
end
end
module Fog
module Vcloud
class Compute < Fog::Service
BASE_PATH = '/api'
DEFAULT_VERSION = '1.5'
SUPPORTED_VERSIONS = [ '1.5', '1.0' ]
PORT = 443
SCHEME = 'https'
attr_writer :default_organization_uri
requires :vcloud_username, :vcloud_password, :vcloud_host
recognizes :vcloud_port, :vcloud_scheme, :vcloud_path, :vcloud_default_vdc, :vcloud_version, :vcloud_base_path
recognizes :provider # remove post deprecation
model_path 'fog/vcloud/models/compute'
model :catalog
collection :catalogs
model :catalog_item
model :catalog_items
model :ip
collection :ips
model :network
collection :networks
model :server
collection :servers
model :task
collection :tasks
model :vapp
collection :vapps
model :vdc
collection :vdcs
model :organization
collection :organizations
model :tag
collection :tags
request_path 'fog/vcloud/requests/compute'
request :clone_vapp
request :configure_network
request :configure_network_ip
request :configure_vapp
request :configure_vm_memory
request :configure_vm_cpus
request :configure_org_network
request :configure_vm_name_description
request :configure_vm_disks
request :configure_vm_password
request :configure_vm_network
request :delete_vapp
request :get_catalog_item
request :get_customization_options
request :get_network_ip
request :get_network_ips
request :get_network_extensions
request :get_task_list
request :get_vapp_template
request :get_vm_disks
request :get_vm_memory
request :instantiate_vapp_template
request :login
request :power_off
request :power_on
request :power_reset
request :power_shutdown
request :undeploy
request :get_metadata
request :delete_metadata
request :configure_metadata
request :configure_vm_customization_script
class Mock
def initialize(options={})
Fog::Mock.not_implemented
end
end
class Real
class << self
def basic_request(*args)
self.class_eval <<-EOS, __FILE__,__LINE__
def #{args[0]}(uri)
request(
{
:expects => #{args[1] || 200},
:method => '#{args[2] || 'GET'}',
:headers => #{args[3] ? args[3].inspect : '{}'},
:body => '#{args[4] ? args[4] : ''}',
:parse => true,
:uri => uri
}
)
end
EOS
end
def unauthenticated_basic_request(*args)
self.class_eval <<-EOS, __FILE__,__LINE__
def #{args[0]}(uri)
unauthenticated_request({
:expects => #{args[1] || 200},
:method => '#{args[2] || 'GET'}',
:headers => #{args[3] ? args[3].inspect : '{}'},
:parse => true,
:uri => uri })
end
EOS
end
end
attr_reader :version
def initialize(options = {})
require 'builder'
@connections = {}
@connection_options = options[:connection_options] || {}
@persistent = options[:persistent]
@username = options[:vcloud_username]
@password = options[:vcloud_password]
@host = options[:vcloud_host]
@base_path = options[:vcloud_base_path] || Fog::Vcloud::Compute::BASE_PATH
@version = options[:vcloud_version] || Fog::Vcloud::Compute::DEFAULT_VERSION
@path = options[:vcloud_path] || "#{@base_path}/v#{@version}"
@port = options[:vcloud_port] || Fog::Vcloud::Compute::PORT
@scheme = options[:vcloud_scheme] || Fog::Vcloud::Compute::SCHEME
@vdc_href = options[:vcloud_default_vdc]
end
def reload
@connections.each_value { |k,v| v.reset if v }
end
def default_organization_uri
@default_organization_uri ||= organizations.first.href
@default_organization_uri
end
def default_vdc_href
if @vdc_href.nil?
unless @login_results
do_login
end
org = organizations.first
vdc = get_organization(org.href).links.find { |item| item[:type] == 'application/vnd.vmware.vcloud.vdc+xml'}
@vdc_href = vdc[:href]
end
@vdc_href
end
# login handles the auth, but we just need the Set-Cookie
# header from that call.
def do_login
@login_results = login
@cookie = @login_results.headers['Set-Cookie'] || @login_results.headers['set-cookie']
end
def ensure_unparsed(uri)
if uri.is_a?(String)
uri
else
uri.to_s
end
end
def xmlns
if version == '1.0'
{ "xmlns" => "http://www.vmware.com/vcloud/v1",
"xmlns:ovf" => "http://schemas.dmtf.org/ovf/envelope/1",
"xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance",
"xmlns:xsd" => "http://www.w3.org/2001/XMLSchema" }
else
{ 'xmlns' => "http://www.vmware.com/vcloud/v1.5",
"xmlns:ovf" => "http://schemas.dmtf.org/ovf/envelope/1",
"xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance",
"xmlns:xsd" => "http://www.w3.org/2001/XMLSchema" }
end
end
# If the cookie isn't set, do a get_organizations call to set it
# and try the request.
# If we get an Unauthorized error, we assume the token expired, re-auth and try again
def request(params)
unless @cookie
do_login
end
begin
do_request(params)
rescue Excon::Errors::Unauthorized
do_login
do_request(params)
end
end
def basic_request_params(uri,*args)
{
:expects => args[0] || 200,
:method => args[1] || 'GET',
:headers => args[2] ? args[2].inspect : {},
:body => args[3] ? args[3] : '',
:parse => true,
:uri => uri
}
end
def base_path_url
"#{@scheme}://#{@host}:#{@port}#{@base_path}"
end
private
def ensure_parsed(uri)
if uri.is_a?(String)
URI.parse(uri)
else
uri
end
end
# Don't need to set the cookie for these or retry them if the cookie timed out
def unauthenticated_request(params)
do_request(params)
end
def base_url
"#{@scheme}://#{@host}:#{@port}#{@path}"
end
# Use this to set the Authorization header for login
def authorization_header
"Basic #{Base64.encode64("#{@username}:#{@password}").delete("\r\n")}"
end
# Actually do the request
def do_request(params)
# Convert the uri to a URI if it's a string.
if params[:uri].is_a?(String)
params[:uri] = URI.parse(params[:uri])
end
host_url = "#{params[:uri].scheme}://#{params[:uri].host}#{params[:uri].port ? ":#{params[:uri].port}" : ''}"
# Hash connections on the host_url ... There's nothing to say we won't get URI's that go to
# different hosts.
@connections[host_url] ||= Fog::XML::Connection.new(host_url, @persistent, @connection_options)
# Set headers to an empty hash if none are set.
headers = params[:headers] || {}
headers['Accept'] = 'application/*+xml;version=1.5' if version == '1.5'
# Add our auth cookie to the headers
if @cookie
headers.merge!('Cookie' => @cookie)
end
# Make the request
response = @connections[host_url].request({
:body => params[:body] || '',
:expects => params[:expects] || 200,
:headers => headers,
:method => params[:method] || 'GET',
:path => params[:uri].path
})
# Parse the response body into a hash
unless response.body.empty?
if params[:parse]
document = Fog::ToHashDocument.new
parser = Nokogiri::XML::SAX::PushParser.new(document)
parser << response.body
parser.finish
response.body = document.body
end
end
response
end
end
def self.item_requests(*types)
types.each{|t| item_request(t) }
end
def self.item_request(type)
Fog::Vcloud::Compute::Real.class_eval <<-EOS, __FILE__,__LINE__
def get_#{type}(uri)
Fog::Vcloud::Compute::#{type.to_s.capitalize}.new(
self.request(basic_request_params(uri)).body.merge(
:service => self,
:collection => Fog::Vcloud::Compute::#{type.to_s.capitalize}s.new(
:service => self
)
)
)
end
EOS
end
item_requests :organization, :vdc, :network, :vapp, :server, :catalog, :task
end
end
end