class OVIRT::Client

Attributes

api_entrypoint[R]
ca_cert_file[R]
ca_cert_store[R]
ca_no_verify[R]
cluster_id[R]
credentials[R]
datacenter_id[R]
filtered_api[R]
jsessionid[R]
persistent_auth[R]

Public Class Methods

new(username, password, api_entrypoint, options={}, backward_compatibility_cluster=nil, backward_compatibility_filtered=nil ) click to toggle source

Construct a new ovirt client class. mandatory parameters

username, password, api_entrypoint  - for example 'me@internal', 'secret', 'https://example.com/api'

optional parameters

datacenter_id, cluster_id and filtered_api can be sent in this order for backward
compatibility, or as a hash in the 4th parameter.
datacenter_id - setting the datacenter at initialization will add a default scope to any subsequent call
                to the client to the specified datacenter.
cluster_id    - setting the cluster at initialization will add a default scope to any subsequent call
                to the client to the specified cluster.
filtered_api  - when set to false (default) will use ovirt administrator api, else it will use the user
                api mode.
# File lib/rbovirt.rb, line 67
def initialize(username, password, api_entrypoint, options={}, backward_compatibility_cluster=nil, backward_compatibility_filtered=nil )
  if !options.is_a?(Hash)
    # backward compatibility optional parameters
    options = {:datacenter_id => options,
               :cluster_id => backward_compatibility_cluster,
               :filtered_api => backward_compatibility_filtered}
  end
  @api_entrypoint  = api_entrypoint
  @credentials     = { :username => username, :password => password }
  @datacenter_id   = options[:datacenter_id]
  @cluster_id      = options[:cluster_id]
  @filtered_api    = options[:filtered_api]
  @ca_cert_file    = options[:ca_cert_file]
  @ca_cert_store   = options[:ca_cert_store]
  @ca_no_verify    = options[:ca_no_verify]
  @persistent_auth = options[:persistent_auth]
  @jsessionid      = options[:jsessionid]
end

Private Class Methods

parse_response(response) click to toggle source
# File lib/rbovirt.rb, line 188
def self.parse_response(response)
  Nokogiri::XML(response)
end

Public Instance Methods

activate_volume(vm_id, vol_id) click to toggle source
# File lib/client/vm_api.rb, line 123
def activate_volume(vm_id, vol_id)
  http_post("/vms/%s/disks/%s/activate" % [vm_id, vol_id], '<action/>') unless volume_active?(vm_id, vol_id)
end
add_interface(vm_id, opts={}) click to toggle source
# File lib/client/vm_api.rb, line 76
def add_interface(vm_id, opts={})
  http_post("/vms/%s/nics" % vm_id, OVIRT::Interface.to_xml( opts))
end
add_vm_to_affinity_group(affinity_group_id, vm_id, opts={}) click to toggle source
# File lib/client/affinity_group_api.rb, line 33
def add_vm_to_affinity_group(affinity_group_id, vm_id, opts={})
  cluster_id = opts[:cluster_id] || current_cluster.id
  http_post("/clusters/%s/affinitygroups/%s/vms" % [cluster_id, affinity_group_id], "<vm id='%s'/>" % vm_id)
end
add_volume(vm_id, opts={}) click to toggle source
# File lib/client/vm_api.rb, line 97
def add_volume(vm_id, opts={})
  search = opts[:search] || ("datacenter=%s" % current_datacenter.name)
  opts[:storage_domain_id] = opts[:storage_domain] || storagedomains(:role => 'data', :search => search).first.id
  # If no size is given, default to a volume size of 8GB
  opts[:size] = 8 * 1024 * 1024 * 1024 unless opts[:size]
  opts[:type] = 'data' unless opts[:type]
  opts[:bootable] = 'true' unless opts[:bootable]
  opts[:interface] = 'virtio' unless opts[:interface]
  opts[:format] = 'cow' unless opts[:format]
  opts[:sparse] = 'true' unless opts[:sparse]
  http_post("/vms/%s/disks" % vm_id, OVIRT::Volume.to_xml(opts))
end
affinity_group(affinity_group_id, opts={}) click to toggle source
# File lib/client/affinity_group_api.rb, line 3
def affinity_group(affinity_group_id, opts={})
  cluster_id = opts[:cluster_id] || current_cluster.id
  ag_xml = http_get("/clusters/%s/affinitygroups/%s" % [cluster_id, affinity_group_id], http_headers)
  OVIRT::AffinityGroup.new(self, ag_xml.root)
end
affinity_group_vms(affinity_group_id, opts={}) click to toggle source
# File lib/client/affinity_group_api.rb, line 16
def affinity_group_vms(affinity_group_id, opts={})
  cluster_id = opts[:cluster_id] || current_cluster.id
  http_get("/clusters/%s/affinitygroups/%s/vms" % [cluster_id, affinity_group_id], http_headers).xpath('/vms/vm').collect do |vm_ref|
    OVIRT::VM.new(self, http_get("/vms/%s" % vm_ref.attribute('id').value, http_headers).root)
  end
end
affinity_groups(opts={}) click to toggle source
# File lib/client/affinity_group_api.rb, line 9
def affinity_groups(opts={})
  cluster_id = opts[:cluster_id] || current_cluster.id
  http_get("/clusters/%s/affinitygroups" % cluster_id, http_headers).xpath('/affinity_groups/affinity_group').collect do |ag|
    OVIRT::AffinityGroup.new(self, ag)
  end
end
api_version() click to toggle source
# File lib/rbovirt.rb, line 86
def api_version
  return @api_version unless @api_version.nil?
  xml = http_get("/")/'/api/product_info/version'
  major = (xml/'version').first[:major]
  minor = (xml/'version').first[:minor]
  build = (xml/'version').first[:build]
  revision = (xml/'version').first[:revision]
  @api_version = "#{major}.#{minor}.#{build}.#{revision}"
end
api_version?(major, minor=nil) click to toggle source
# File lib/rbovirt.rb, line 96
def api_version?(major, minor=nil)
  (api_version.split('.')[0] == major) && (minor.nil? ? true : api_version.split('.')[1] == minor)
end
approve_host(host_id, opts={}) click to toggle source
# File lib/client/host_api.rb, line 16
def approve_host(host_id, opts={})
    http_post("/hosts/%s/approve" % host_id, "<action></action>")
end
attach_volume(vm_id, vol_id, activate=true) click to toggle source
# File lib/client/vm_api.rb, line 131
def attach_volume(vm_id, vol_id, activate=true)
  http_post("/vms/%s/disks" % vm_id, "<disk id='%s'/>" % vol_id)
  activate_volume(vm_id, vol_id) if activate
end
cluster(cluster_id) click to toggle source
# File lib/client/cluster_api.rb, line 24
def cluster(cluster_id)
  headers = {:accept => "application/xml; detail=datacenters"}
  cluster_xml = http_get("/clusters/%s" % cluster_id, headers)
  OVIRT::Cluster.new(self, cluster_xml.root)
end
cluster_version(cluster_id) click to toggle source
# File lib/client/cluster_api.rb, line 3
def cluster_version(cluster_id)
  c = cluster(cluster_id)
  return c.version.split('.')[0].to_i, c.version.split('.')[1].to_i
end
cluster_version?(cluster_id, major) click to toggle source
# File lib/client/cluster_api.rb, line 8
def cluster_version?(cluster_id, major)
  c = cluster(cluster_id)
  c.version.split('.')[0] == major
end
clusters(opts={}) click to toggle source
# File lib/client/cluster_api.rb, line 13
def clusters(opts={})
  headers = {:accept => "application/xml; detail=datacenters"}
  path = "/clusters"
  path += search_url(opts) unless filtered_api
  http_get(path, headers).xpath('/clusters/cluster').collect do |cl|
    cluster = OVIRT::Cluster.new(self, cl)
    #the following line is needed as a work-around a bug in RHEV 3.0 rest-api
    cluster if filtered_api || (cluster.datacenter.id == current_datacenter.id)
  end.compact
end
create_affinity_group(opts={}) click to toggle source
# File lib/client/affinity_group_api.rb, line 23
def create_affinity_group(opts={})
  cluster_id = opts[:cluster_id] || current_cluster.id
  OVIRT::AffinityGroup.new(self, http_post("/clusters/%s/affinitygroups" % cluster_id, OVIRT::AffinityGroup.to_xml(opts)).root)
end
create_template(opts) click to toggle source
# File lib/client/template_api.rb, line 17
def create_template(opts)
  template = http_post("/templates", Template.to_xml(opts))
  OVIRT::Template::new(self, template.root)
end
create_vm(opts) click to toggle source
# File lib/client/vm_api.rb, line 36
def create_vm(opts)
  cluster_major_ver, cluster_minor_ver = cluster_version(self.cluster_id)

  if opts[:user_data] and not opts[:user_data].empty?
    if api_version?('3') and cluster_major_ver >= 3
      if cluster_minor_ver >= 3
        opts[:user_data_method] = :payload_v3_3
      elsif cluster_minor_ver >= 1
        opts[:user_data_method] = :payload
      elsif floppy_hook?
        opts[:user_data_method] = :custom_property
      else
        raise "Required VDSM hook 'floppyinject' not supported by RHEV-M"
      end
    else
      raise BackendVersionUnsupportedException.new
    end
  end

  process_vm_opts(opts)

  opts[:cluster_name] ||= clusters.first.name unless opts[:cluster]
  OVIRT::VM::new(self, http_post("/vms",OVIRT::VM.to_xml(opts)).root)
end
datacenter(datacenter_id) click to toggle source
# File lib/client/datacenter_api.rb, line 3
def datacenter(datacenter_id)
    begin
      datacenter = http_get("/datacenters/%s" % datacenter_id)
      OVIRT::DataCenter::new(self, datacenter.root)
    rescue
      handle_fault $!
    end
  end
datacenters(opts={}) click to toggle source
# File lib/client/datacenter_api.rb, line 12
def datacenters(opts={})
  search = opts[:search] ||""
  datacenters = http_get("/datacenters?search=%s" % CGI.escape(search))
  datacenters.xpath('/data_centers/data_center').collect do |dc|
    OVIRT::DataCenter::new(self, dc)
  end
end
deactivate_volume(vm_id, vol_id) click to toggle source
# File lib/client/vm_api.rb, line 127
def deactivate_volume(vm_id, vol_id)
  http_post("/vms/%s/disks/%s/deactivate" % [vm_id, vol_id], '<action/>') if volume_active?(vm_id, vol_id)
end
delete_vm_from_affinity_group(affinity_group_id, vm_id, opts={}) click to toggle source
# File lib/client/affinity_group_api.rb, line 38
def delete_vm_from_affinity_group(affinity_group_id, vm_id, opts={})
  cluster_id = opts[:cluster_id] || current_cluster.id
  http_delete("/clusters/%s/affinitygroups/%s/vms/%s" % [cluster_id, affinity_group_id, vm_id])
end
destroy_affinity_group(affinity_group_id, opts={}) click to toggle source
# File lib/client/affinity_group_api.rb, line 28
def destroy_affinity_group(affinity_group_id, opts={})
  cluster_id = opts[:cluster_id] || current_cluster.id
  http_delete("/clusters/%s/affinitygroups/%s" % [cluster_id, affinity_group_id])
end
destroy_interface(vm_id, interface_id) click to toggle source
# File lib/client/vm_api.rb, line 72
def destroy_interface(vm_id, interface_id)
  http_delete("/vms/%s/nics/%s" % [vm_id, interface_id])
end
destroy_template(id) click to toggle source
# File lib/client/template_api.rb, line 22
def destroy_template(id)
  http_delete("/templates/%s" % id)
end
destroy_vm(id) click to toggle source
# File lib/client/vm_api.rb, line 158
def destroy_vm(id)
  http_delete("/vms/%s" % id)
end
destroy_volume(vm_id, vol_id) click to toggle source
# File lib/client/vm_api.rb, line 110
def destroy_volume(vm_id, vol_id)
  http_delete("/vms/%s/disks/%s" % [vm_id, vol_id])
end
detach_volume(vm_id, vol_id) click to toggle source
# File lib/client/vm_api.rb, line 136
def detach_volume(vm_id, vol_id)
  deactivate_volume(vm_id, vol_id)
  http_delete("/vms/%s/disks/%s" % [vm_id, vol_id], '<action><detach>true</detach></action>')
end
disk(disk_id) click to toggle source
# File lib/client/disk_api.rb, line 10
def disk(disk_id)
  disk_xml = http_get("/disks/%s" % disk_id)
  OVIRT::Volume.new(self, disk_xml.root)
end
diskprofile(dp_id) click to toggle source
# File lib/client/disk_profile_api.rb, line 3
def diskprofile(dp_id)
  dp = http_get("/diskprofiles/%s" % dp_id)
  OVIRT::DiskProfile::new(self, dp.root)
end
diskprofiles(opts={}) click to toggle source
# File lib/client/disk_profile_api.rb, line 8
def diskprofiles(opts={})
  path = "/diskprofiles"
  path += search_url(opts) unless filtered_api
  http_get(path).xpath('/disk_profiles/disk_profile').collect do |dp|
    OVIRT::DiskProfile::new(self,dp)
  end.compact
end
disks(opts={}) click to toggle source
# File lib/client/disk_api.rb, line 3
def disks(opts={})
  path = "/disks" + search_url(opts)
  http_get(path).xpath('/disks/disk').collect do |d|
    OVIRT::Volume.new(self, d)
  end
end
floppy_hook?() click to toggle source
# File lib/rbovirt.rb, line 100
def floppy_hook?
  xml = http_get("/capabilities")
  !(xml/"version/custom_properties/custom_property[@name='floppyinject']").empty?
end
host(host_id, opts={}) click to toggle source
# File lib/client/host_api.rb, line 3
def host(host_id, opts={})
  xml_response = http_get("/hosts/%s" % host_id)
  OVIRT::Host::new(self, xml_response.root)
end
hosts(opts={}) click to toggle source
# File lib/client/host_api.rb, line 8
def hosts(opts={})
  path = "/hosts"
  path += search_url(opts) unless filtered_api
  http_get(path).xpath('/hosts/host').collect do |h|
    OVIRT::Host::new(self, h)
  end
end
instance_type(instance_type_id) click to toggle source
# File lib/client/instance_type_api.rb, line 3
def instance_type(instance_type_id)
    begin
      instance_type = http_get("/instancetypes/%s" % instance_type_id)
      OVIRT::InstanceType::new(self, instance_type.root)
    rescue
      handle_fault $!
    end
  end
instance_types(opts={}) click to toggle source
# File lib/client/instance_type_api.rb, line 12
def instance_types(opts={})
  search = opts[:search] ||""
  instance_types = http_get("/instancetypes?search=%s" % CGI.escape(search))
  instance_types.xpath('/instance_types/instance_type').collect do |it|
    OVIRT::InstanceType::new(self, it)
  end
end
networks(opts) click to toggle source
# File lib/client/cluster_api.rb, line 30
def networks(opts)
  cluster_id = opts[:cluster_id] || current_cluster.id
  http_get("/clusters/%s/networks" % cluster_id, http_headers).xpath('/networks/network').collect do |cl|
    OVIRT::Network.new(self, cl)
  end
end
operating_systems() click to toggle source
# File lib/client/operating_system_api.rb, line 3
def operating_systems
  operating_systems = http_get('/operatingsystems')
  operating_systems.xpath('/operating_systems/operating_system').collect do |os|
    OVIRT::OperatingSystem::new(self, os)
  end
end
process_vm_opts(opts) click to toggle source
# File lib/client/vm_api.rb, line 21
def process_vm_opts(opts)
  if (opts[:template] or opts[:template_name]) and (opts[:storagedomain] or opts[:storagedomain_name])
    template_id = opts[:template] || templates.select{|t| t.name == opts[:template_name]}.first.id
    template_disks = template_volumes(template_id)
    storagedomain_id = opts[:storagedomain] || storagedomains.select{|s| s.name == opts[:storagedomain_name]}.first.id

    # Make sure the 'clone' option is set if any of the disks defined by
    # the template is stored on a different storage domain than requested
    opts[:clone] = true unless opts[:clone] == true || template_disks.empty? || template_disks.all? { |d| d.storage_domain == storagedomain_id }

    # Create disks map
    opts[:disks] = template_disks.collect { |d| {:id => d.id, :storagedomain => storagedomain_id} }
  end
end
quota(quota_id, opts={}) click to toggle source
# File lib/client/quota_api.rb, line 3
def quota(quota_id, opts={})
  q = http_get("/datacenters/%s/quotas/%s" % [current_datacenter.id, quota_id])
  OVIRT::Quota::new(self, q.root)
end
quotas(opts={}) click to toggle source
# File lib/client/quota_api.rb, line 8
def quotas(opts={})
  http_get("/datacenters/%s/quotas" % CGI.escape(current_datacenter.id)).xpath('/quotas/quota').collect do |q|
    OVIRT::Quota::new(self, q)
  end.compact
end
reinstall_host(host_id, override_iptables=false, opts={}) click to toggle source
# File lib/client/host_api.rb, line 20
def reinstall_host(host_id, override_iptables=false, opts={})
    http_post("/hosts/%s/install" % host_id,
              "<action>
                <ssh>
                 <authentication_method>PublicKey</authentication_method>
                </ssh>
                <host>
                 <override_iptables>" + override_iptables.to_s + "</override_iptables>
                </host>
               </action>"
             )
end
set_ticket(vm_id, options={}) click to toggle source
# File lib/client/vm_api.rb, line 162
def set_ticket(vm_id, options={})
  ticket = OVIRT::VM.ticket(options)
  xml_response = http_post("/vms/%s/ticket" % vm_id, ticket)
  (xml_response/'action/ticket/value').first.text
end
storagedomain(sd_id) click to toggle source
# File lib/client/storage_domain_api.rb, line 3
def storagedomain(sd_id)
  sd = http_get("/storagedomains/%s" % sd_id)
  OVIRT::StorageDomain::new(self, sd.root)
end
storagedomains(opts={}) click to toggle source
# File lib/client/storage_domain_api.rb, line 8
def storagedomains(opts={})
  path = "/storagedomains"
  path += search_url(opts) unless filtered_api
  http_get(path).xpath('/storage_domains/storage_domain').collect do |sd|
    storage_domain = OVIRT::StorageDomain::new(self, sd)
    #filter by role is not supported by the search language. The work around is to list all, then filter.
    (opts[:role].nil? || storage_domain.role == opts[:role]) ? storage_domain : nil
  end.compact
end
template(template_id, opts={}) click to toggle source
# File lib/client/template_api.rb, line 11
def template(template_id, opts={})
  results = http_get("/templates/%s" % template_id)
  template = OVIRT::Template::new(self, results.root)
  template
end
template_interfaces(template_id) click to toggle source
# File lib/client/template_api.rb, line 26
def template_interfaces template_id
  http_get("/templates/%s/nics" % template_id, http_headers).xpath('/nics/nic').collect do |nic|
    OVIRT::Interface::new(self, nic)
  end
end
template_volumes(template_id) click to toggle source
# File lib/client/template_api.rb, line 32
def template_volumes template_id
  http_get("/templates/%s/disks" % template_id, http_headers).xpath('/disks/disk').collect do |disk|
    OVIRT::Volume::new(self, disk)
  end
end
templates(opts={}) click to toggle source
# File lib/client/template_api.rb, line 3
def templates(opts={})
  path = "/templates"
  path += search_url(opts) unless filtered_api
  http_get(path).xpath('/templates/template').collect do |t|
    OVIRT::Template::new(self, t)
  end.compact
end
update_interface(vm_id, interface_id, opts={}) click to toggle source
# File lib/client/vm_api.rb, line 80
def update_interface(vm_id, interface_id, opts={})
  http_put("/vms/%s/nics/%s" % [vm_id, interface_id], OVIRT::Interface.to_xml( opts))
end
update_vm(opts) click to toggle source
# File lib/client/vm_api.rb, line 168
def update_vm(opts)
  opts[:cluster_name] ||= clusters.first.name
  result_xml = http_put("/vms/%s" % opts[:id], OVIRT::VM.to_xml(opts))
  OVIRT::VM::new(self, result_xml.root)
end
update_volume(vm_id, vol_id, opts={}) click to toggle source
# File lib/client/vm_api.rb, line 114
def update_volume(vm_id, vol_id, opts={})
  http_put("/vms/%s/disks/%s" % [vm_id, vol_id], OVIRT::Volume.to_xml(opts))
end
vm(vm_id, opts={}) click to toggle source
# File lib/client/vm_api.rb, line 3
def vm(vm_id, opts={})
  headers = {:accept => "application/xml; detail=disks; detail=nics; detail=hosts"}
  OVIRT::VM::new(self,  http_get("/vms/%s" % vm_id, headers).root)
end
vm_action(id, action, opts={}) click to toggle source
# File lib/client/vm_api.rb, line 141
def vm_action(id, action, opts={})
  xml_response = http_post("/vms/%s/%s" % [id, action],'<action/>', opts)
  return (xml_response/'action/status').first.text.strip.upcase=="COMPLETE"
end
vm_interfaces(vm_id) click to toggle source
# File lib/client/vm_api.rb, line 61
def vm_interfaces vm_id
  begin
    http_get("/vms/%s/nics" % vm_id, http_headers).xpath('/nics/nic').collect do |nic|
      OVIRT::Interface::new(self, nic)
    end
  rescue => e # Catch case were vm_id is destroyed.
    raise e unless e.message =~ /Entity not found/
    []
  end
end
vm_start_with_cloudinit(id, opts={}) click to toggle source
# File lib/client/vm_api.rb, line 146
def vm_start_with_cloudinit(id, opts={})
  # Get the api and cluster version on which the VM is provisioned.
  # This is required for VM::cloudinit.
  opts.merge!(
    :cluster_version => cluster_version(vm(id).cluster.id),
    :api_version => api_version.split('.').map(&:to_i)
  )
  xml = OVIRT::VM.cloudinit(opts)
  xml_response = http_post("/vms/%s/%s" % [id, 'start'], xml, {} )
  return (xml_response/'action/status').first.text.strip.upcase=="COMPLETE"
end
vm_volumes(vm_id) click to toggle source
# File lib/client/vm_api.rb, line 84
def vm_volumes vm_id
  begin
    volumes = http_get("/vms/%s/disks" % vm_id, http_headers).xpath('/disks/disk').collect do |disk|
      OVIRT::Volume::new(self, disk)
    end
  rescue => e # Catch case were vm_id is destroyed.
    raise e unless e.message =~ /Entity not found/
    volumes = []
  end
  #this is a workaround to a bug that the list is not sorted by default.
  volumes.sort{ |l, r| l.name <=> r.name }
end
vms(opts={}) click to toggle source
# File lib/client/vm_api.rb, line 8
def vms(opts={})
  if opts[:without_details]
    headers = {:accept => "application/xml"}
  else
    headers = {:accept => "application/xml; detail=disks; detail=nics; detail=hosts"}
  end
  path = "/vms"
  path += search_url(opts) unless filtered_api
  http_get(path, headers).xpath('/vms/vm').collect do |vm|
    OVIRT::VM::new(self, vm)
  end
end
volume_active?(vm_id, vol_id) click to toggle source
# File lib/client/vm_api.rb, line 118
def volume_active?(vm_id, vol_id)
  http_response = http_get("/vms/%s/disks/%s" % [vm_id, vol_id, http_headers])
  http_response.xpath("/disk/active").first.text.upcase == "TRUE"
end

Private Instance Methods

auth_header() click to toggle source
# File lib/rbovirt.rb, line 157
def auth_header
  # This is the method for strict_encode64:
  encoded_credentials = ["#{@credentials[:username]}:#{@credentials[:password]}"].pack("m0").gsub(/\n/,'')
  headers = { :authorization => "Basic " + encoded_credentials }
  if persistent_auth
    headers[:prefer] = 'persistent-auth'
    headers[:cookie] = "JSESSIONID=#{jsessionid}" if jsessionid
  end
  headers
end
base_url() click to toggle source
# File lib/rbovirt.rb, line 183
def base_url
  url = URI.parse(@api_entrypoint)
  "#{url.scheme}://#{url.host}:#{url.port}"
end
current_cluster() click to toggle source
# File lib/rbovirt.rb, line 119
def current_cluster
  @current_cluster ||= self.cluster_id ? cluster(self.cluster_id) : clusters.first
end
current_datacenter() click to toggle source
# File lib/rbovirt.rb, line 115
def current_datacenter
  @current_datacenter ||= self.datacenter_id ? datacenter(self.datacenter_id) : datacenters.first
end
filter_header() click to toggle source
# File lib/rbovirt.rb, line 179
def filter_header
  filtered_api ? { :filter => "true" } : {}
end
handle_fault(f) click to toggle source
# File lib/rbovirt.rb, line 210
def handle_fault(f)
  if f.is_a?(RestClient::BadRequest) || f.is_a?(RestClient::Conflict)
    fault = (Nokogiri::XML(f.http_body)/'//fault/detail')
    fault = fault.text.gsub(/\[|\]/, '') if fault
  end
  fault ||= f.message
  raise OvirtException::new(fault)
end
handle_success(response) click to toggle source
# File lib/rbovirt.rb, line 204
def handle_success(response)
  puts "#{response}\n" if ENV['RBOVIRT_LOG_RESPONSE']
  @jsessionid ||= response.cookies['JSESSIONID']
  Nokogiri::XML(response)
end
has_datacenter?(vm) click to toggle source
# File lib/rbovirt.rb, line 192
def has_datacenter?(vm)
  (vm/'data_center').any?
end
http_delete(suburl, body=nil, headers={}) click to toggle source
# File lib/rbovirt.rb, line 147
def http_delete(suburl, body=nil, headers={})
  begin
    headers = body ? http_headers(headers) :
      {:accept => 'application/xml', :version => '3'}.merge(auth_header).merge(filter_header)
    handle_success(rest_client(suburl).delete_with_payload(body, headers))
  rescue
    handle_fault $!
  end
end
http_get(suburl, headers={}) click to toggle source
# File lib/rbovirt.rb, line 123
def http_get(suburl, headers={})
  begin
    handle_success(rest_client(suburl).get(http_headers(headers)))
  rescue
    handle_fault $!
  end
end
http_headers(headers ={}) click to toggle source
# File lib/rbovirt.rb, line 196
def http_headers(headers ={})
  filter_header.merge(auth_header).merge({
    :content_type => 'application/xml',
    :accept => 'application/xml',
    :version => '3',
  }).merge(headers)
end
http_post(suburl, body, headers={}) click to toggle source
# File lib/rbovirt.rb, line 131
def http_post(suburl, body, headers={})
  begin
    handle_success(rest_client(suburl).post(body, http_headers(headers)))
  rescue
    handle_fault $!
  end
end
http_put(suburl, body, headers={}) click to toggle source
# File lib/rbovirt.rb, line 139
def http_put(suburl, body, headers={})
  begin
    handle_success(rest_client(suburl).put(body, http_headers(headers)))
  rescue
    handle_fault $!
  end
end
rest_client(suburl) click to toggle source
# File lib/rbovirt.rb, line 168
def rest_client(suburl)
  if (URI.parse(@api_entrypoint)).scheme == 'https'
    options = {}
    options[:verify_ssl] = ca_no_verify ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
    options[:ssl_cert_store] = ca_cert_store if ca_cert_store
    options[:ssl_ca_file] = ca_cert_file if ca_cert_file
  end
  options[:timeout] = ENV['RBOVIRT_REST_TIMEOUT'].to_i if ENV['RBOVIRT_REST_TIMEOUT']
  RestClient::Resource.new(@api_entrypoint, options)[suburl]
end
search_url(opts) click to toggle source
# File lib/rbovirt.rb, line 107
def search_url opts
  search = opts[:search] || ''
  search += " datacenter=\"%s\"" % current_datacenter.name
  search += " page #{opts[:page]}" if opts[:page]
  max = opts[:max] ? ";max=#{opts[:max]}" : ''
  "#{max}?search=#{CGI.escape(search)}"
end