class OpenNebula::Pool

The Pool class represents a generic OpenNebula Pool in XML format and provides the basic functionality to handle the Pool elements

Constants

INFO_ALL
INFO_GROUP

Constants for info queries (include/RequestManagerPoolInfoFilter.h)

INFO_MINE
PAGINATED_POOLS

Public Class Methods

new(pool,element,client) click to toggle source
pool

String XML name of the root element

element

String XML name of the Pool elements

client

Client represents a XML-RPC connection

Calls superclass method
# File lib/opennebula/pool.rb, line 34
def initialize(pool,element,client)
    super(nil)

    @pool_name    = pool.upcase
    @element_name = element.upcase

    @client = client
end

Public Instance Methods

each(&block) click to toggle source

Iterates over every PoolElement in the Pool and calls the block with a a PoolElement obtained calling the factory method

block

Block

# File lib/opennebula/pool.rb, line 151
def each(&block)
    each_element(block) if @xml
end
Also aliased as: each_with_xpath
each_with_xpath(&block)
Alias for: each
get_hash(size=nil) click to toggle source

Gets a hash from a pool

size

nil => default page size < 2 => not paginated >=2 => page size

The default page size can be changed with the environment variable ONE_POOL_PAGE_SIZE. Any value > 2 will set a page size, a non numeric value disables pagination.

# File lib/opennebula/pool.rb, line 172
def get_hash(size=nil)
    allow_paginated = PAGINATED_POOLS.include?(@pool_name)

    if OpenNebula.pool_page_size && allow_paginated &&
            ( ( size && size >= 2 ) || !size )
        size = OpenNebula.pool_page_size if !size
        hash=info_paginated(size)

        return hash if OpenNebula.is_error?(hash)
        { @pool_name => { @element_name => hash } }
    else
        rc=info
        return rc if OpenNebula.is_error?(rc)
        to_hash
    end
end
info_paginated(size) click to toggle source

Gets a pool in hash form using pagination

size

Integer size of each page

# File lib/opennebula/pool.rb, line 192
def info_paginated(size)
    array=Array.new
    current=0

    parser=ParsePoolSax.new(@pool_name, @element_name)

    while true
        a=@client.call("#{@pool_name.delete('_').downcase}.info",
            @user_id, current, -size, -1)
        return a if OpenNebula.is_error?(a)

        a_array=parser.parse(a)

        array += a_array
        current += size
        break if !a || a_array.length<size
    end

    array.compact!
    array=nil if array.length == 0

    array
end
to_str() click to toggle source

DO NOT USE - ONLY REXML BACKEND

# File lib/opennebula/pool.rb, line 156
def to_str
    str = ""
    REXML::Formatters::Pretty.new(1).write(@xml,str)

    return str
end

Protected Instance Methods

factory(element_xml) click to toggle source

Default Factory Method for the Pools. The factory method returns an suitable PoolElement object. Each Pool MUST implement the corresponding factory method

element_xml

XML XML element describing the pool element

return

a PoolElement object

# File lib/opennebula/pool.rb, line 48
def factory(element_xml)
    OpenNebula::PoolElement.new(element_xml,client)
end
info(xml_method) click to toggle source

Gets the pool without any filter. Host, Group and User Pools

xml_method:: _String_ the name of the XML-RPC method
# File lib/opennebula/pool.rb, line 58
def info(xml_method)
    return xmlrpc_info(xml_method)
end
Also aliased as: info!
info!(xml_method)
Alias for: info
info_all(xml_method, *args) click to toggle source
# File lib/opennebula/pool.rb, line 64
def info_all(xml_method, *args)
    return xmlrpc_info(xml_method,INFO_ALL,-1,-1, *args)
end
info_filter(xml_method, who, start_id, end_id, *args) click to toggle source
# File lib/opennebula/pool.rb, line 76
def info_filter(xml_method, who, start_id, end_id, *args)
    return xmlrpc_info(xml_method,who, start_id, end_id, *args)
end
info_group(xml_method, *args) click to toggle source
# File lib/opennebula/pool.rb, line 72
def info_group(xml_method, *args)
    return xmlrpc_info(xml_method,INFO_GROUP,-1,-1, *args)
end
info_mine(xml_method, *args) click to toggle source
# File lib/opennebula/pool.rb, line 68
def info_mine(xml_method, *args)
    return xmlrpc_info(xml_method,INFO_MINE,-1,-1, *args)
end
monitoring(xml_method, root_elem, timestamp_elem, xpath_expressions, *args) click to toggle source

Retrieves the monitoring data for all the Objects in the pool

@param [String] xml_method xml-rcp method @param [String] root_elem Root for each individual PoolElement @param [String] timestamp_elem Name of the XML element with the last

monitorization timestamp

@param [Array<String>] xpath_expressions Elements to retrieve. @param args arguemnts for the xml_method call

@return [Hash<String, <Hash<String, Array<Array<int>>>>>,

OpenNebula::Error] The first level hash uses the Object ID as keys,
and as value a Hash with the requested xpath expressions,
and an Array of 'timestamp, value'.
# File lib/opennebula/pool.rb, line 93
def monitoring(xml_method, root_elem, timestamp_elem, xpath_expressions,
    *args)

    rc = @client.call(xml_method, *args)

    if ( OpenNebula.is_error?(rc) )
        return rc
    end

    xmldoc = XMLElement.new
    xmldoc.initialize_xml(rc, 'MONITORING_DATA')

    hash = {}

    # Get all existing Object IDs
    ids = xmldoc.retrieve_elements("#{root_elem}/ID")

    if ids.nil?
        return hash
    else
        ids.uniq!
    end

    ids.each { |id|
        hash[id] = OpenNebula.process_monitoring(
            xmldoc, root_elem, timestamp_elem, id, xpath_expressions)

    }

    return hash
end

Private Instance Methods

xmlrpc_info(xml_method,*args) click to toggle source

Calls to the corresponding info method to retreive the pool representation in XML format

xml_method

String the name of the XML-RPC method

args

Array with additional arguments for the info call

return

nil in case of success or an Error object

# File lib/opennebula/pool.rb, line 131
def xmlrpc_info(xml_method,*args)
    rc = @client.call(xml_method,*args)

    if !OpenNebula.is_error?(rc)
        initialize_xml(rc,@pool_name)
        rc   = nil
    end

    return rc
end