occi 1.2.1 → 2.0.0

data/lib/OpenNebula/VirtualMachinePool.rb

@@ -0,0 +1,120 @@
+# -------------------------------------------------------------------------- #
+# Copyright 2002-2012, OpenNebula Project Leads (OpenNebula.org)             #
+#                                                                            #
+# Licensed under the Apache License, Version 2.0 (the "License"); you may    #
+# not use this file except in compliance with the License. You may obtain    #
+# a copy of the License at                                                   #
+#                                                                            #
+# http://www.apache.org/licenses/LICENSE-2.0                                 #
+#                                                                            #
+# Unless required by applicable law or agreed to in writing, software        #
+# distributed under the License is distributed on an "AS IS" BASIS,          #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
+# See the License for the specific language governing permissions and        #
+# limitations under the License.                                             #
+#--------------------------------------------------------------------------- #
+
+
+require 'OpenNebula/Pool'
+
+module OpenNebula
+    class VirtualMachinePool < Pool
+        #######################################################################
+        # Constants and Class attribute accessors
+        #######################################################################
+
+
+        VM_POOL_METHODS = {
+            :info => "vmpool.info"
+        }
+
+        # Constants for info queries (include/RequestManagerPoolInfoFilter.h)
+        INFO_NOT_DONE = -1
+        INFO_ALL_VM   = -2
+
+        #######################################################################
+        # Class constructor & Pool Methods
+        #######################################################################
+
+
+        # +client+ a Client object that represents a XML-RPC connection
+        # +user_id+ is to refer to a Pool with VirtualMachines from that user
+        def initialize(client, user_id=0)
+            super('VM_POOL','VM',client)
+
+            @user_id  = user_id
+        end
+
+        # Default Factory Method for the Pools
+        def factory(element_xml)
+            OpenNebula::VirtualMachine.new(element_xml,@client)
+        end
+
+        #######################################################################
+        # XML-RPC Methods for the Virtual Network Object
+        #######################################################################
+
+        # Retrieves all or part of the VirtualMachines in the pool.
+        # No arguments, returns the not-in-done VMs for the user 
+        # [user_id, start_id, end_id]
+        # [user_id, start_id, end_id, state]
+        def info(*args)
+            case args.size
+                when 0
+                    info_filter(VM_POOL_METHODS[:info],
+                                @user_id,
+                                -1,
+                                -1,
+                                INFO_NOT_DONE)
+                when 1
+                    info_filter(VM_POOL_METHODS[:info],
+                                args[0],
+                                -1,
+                                -1,
+                                INFO_NOT_DONE)
+                when 3
+                    info_filter(VM_POOL_METHODS[:info],
+                                args[0],
+                                args[1],
+                                args[2],
+                                INFO_NOT_DONE)
+                when 4
+                    info_filter(VM_POOL_METHODS[:info],
+                                args[0],
+                                args[1],
+                                args[2],
+                                args[3])
+            end
+        end
+
+        def info_all()
+            return info_filter(VM_POOL_METHODS[:info],
+                               INFO_ALL,
+                               -1,
+                               -1,
+                               INFO_NOT_DONE)
+        end
+
+        def info_mine()
+            return info_filter(VM_POOL_METHODS[:info],
+                               INFO_MINE,
+                               -1,
+                               -1,
+                               INFO_NOT_DONE)
+        end
+
+        def info_group()
+            return info_filter(VM_POOL_METHODS[:info],
+                               INFO_GROUP,
+                               -1,
+                               -1,
+                               INFO_NOT_DONE)
+        end
+
+        private
+
+        def info_filter(xml_method, who, start_id, end_id, state)
+            return xmlrpc_info(xml_method, who, start_id, end_id, state)
+        end
+    end
+end

data/lib/OpenNebula/VirtualNetwork.rb

@@ -0,0 +1,229 @@
+# -------------------------------------------------------------------------- #
+# Copyright 2002-2012, OpenNebula Project Leads (OpenNebula.org)             #
+#                                                                            #
+# Licensed under the Apache License, Version 2.0 (the "License"); you may    #
+# not use this file except in compliance with the License. You may obtain    #
+# a copy of the License at                                                   #
+#                                                                            #
+# http://www.apache.org/licenses/LICENSE-2.0                                 #
+#                                                                            #
+# Unless required by applicable law or agreed to in writing, software        #
+# distributed under the License is distributed on an "AS IS" BASIS,          #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
+# See the License for the specific language governing permissions and        #
+# limitations under the License.                                             #
+#--------------------------------------------------------------------------- #
+
+
+require 'OpenNebula/Pool'
+
+module OpenNebula
+    class VirtualNetwork < PoolElement
+        #######################################################################
+        # Constants and Class Methods
+        #######################################################################
+
+
+        VN_METHODS = {
+            :info       => "vn.info",
+            :allocate   => "vn.allocate",
+            :publish    => "vn.publish",
+            :delete     => "vn.delete",
+            :addleases  => "vn.addleases",
+            :rmleases   => "vn.rmleases",
+            :chown      => "vn.chown",
+            :chmod      => "vn.chmod",
+            :update     => "vn.update",
+            :hold       => "vn.hold",
+            :release    => "vn.release"
+        }
+
+        VN_TYPES=%w{RANGED FIXED}
+
+        SHORT_VN_TYPES={
+            "RANGED" => "R",
+            "FIXED"  => "F"
+        }
+
+        # Creates a VirtualNetwork description with just its identifier
+        # this method should be used to create plain VirtualNetwork objects.
+        # +id+ the id of the network
+        #
+        # Example:
+        #   vnet = VirtualNetwork.new(VirtualNetwork.build_xml(3),rpc_client)
+        #
+        def VirtualNetwork.build_xml(pe_id=nil)
+            if pe_id
+                vn_xml = "<VNET><ID>#{pe_id}</ID></VNET>"
+            else
+                vn_xml = "<VNET></VNET>"
+            end
+
+            XMLElement.build_xml(vn_xml, 'VNET')
+        end
+
+        # Class constructor
+        def initialize(xml, client)
+            super(xml,client)
+        end
+
+        #######################################################################
+        # XML-RPC Methods for the Virtual Network Object
+        #######################################################################
+
+        # Retrieves the information of the given VirtualNetwork.
+        def info()
+            super(VN_METHODS[:info], 'VNET')
+        end
+
+        # Allocates a new VirtualNetwork in OpenNebula
+        #
+        # +description+ A string containing the template of the VirtualNetwork.
+        def allocate(description)
+            super(VN_METHODS[:allocate],description)
+        end
+
+        # Replaces the template contents
+        #
+        # +new_template+ New template contents
+        def update(new_template)
+            super(VN_METHODS[:update], new_template)
+        end
+
+        # Publishes the VirtualNetwork, to be used by other users
+        def publish
+            set_publish(true)
+        end
+
+        # Unplubishes the VirtualNetwork
+        def unpublish
+            set_publish(false)
+        end
+
+        # Deletes the VirtualNetwork
+        def delete()
+            super(VN_METHODS[:delete])
+        end
+
+        # Adds a lease to the VirtualNetwork
+        def addleases(ip, mac = nil)
+            return Error.new('ID not defined') if !@pe_id
+
+            lease_template = "LEASES = [ IP = #{ip}"
+            lease_template << ", MAC = #{mac}" if mac
+            lease_template << " ]"
+
+            rc = @client.call(VN_METHODS[:addleases], @pe_id, lease_template)
+            rc = nil if !OpenNebula.is_error?(rc)
+
+            return rc
+        end
+
+        # Removes a lease from the VirtualNetwork
+        def rmleases(ip)
+            return Error.new('ID not defined') if !@pe_id
+
+            lease_template = "LEASES = [ IP = #{ip} ]"
+
+            rc = @client.call(VN_METHODS[:rmleases], @pe_id, lease_template)
+            rc = nil if !OpenNebula.is_error?(rc)
+
+            return rc
+        end
+
+        # Holds a virtual network Lease as used
+        # @param ip [String] IP to hold
+        def hold(ip)
+            return Error.new('ID not defined') if !@pe_id
+
+            lease_template = "LEASES = [ IP = #{ip} ]"
+
+            rc = @client.call(VN_METHODS[:hold], @pe_id, lease_template)
+            rc = nil if !OpenNebula.is_error?(rc)
+
+            return rc
+        end
+
+        # Releases a virtual network Lease on hold
+        # @param ip [String] IP to release
+        def release(ip)
+            return Error.new('ID not defined') if !@pe_id
+
+            lease_template = "LEASES = [ IP = #{ip} ]"
+
+            rc = @client.call(VN_METHODS[:release], @pe_id, lease_template)
+            rc = nil if !OpenNebula.is_error?(rc)
+
+            return rc
+        end
+
+        # Changes the owner/group
+        # uid:: _Integer_ the new owner id. Set to -1 to leave the current one
+        # gid:: _Integer_ the new group id. Set to -1 to leave the current one
+        # [return] nil in case of success or an Error object
+        def chown(uid, gid)
+            super(VN_METHODS[:chown], uid, gid)
+        end
+
+        # Changes the virtual network permissions.
+        #
+        # @param octet [String] Permissions octed , e.g. 640
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def chmod_octet(octet)
+            super(VN_METHODS[:chmod], octet)
+        end
+
+        # Changes the virtual network permissions.
+        # Each [Integer] argument must be 1 to allow, 0 deny, -1 do not change
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def chmod(owner_u, owner_m, owner_a, group_u, group_m, group_a, other_u,
+                other_m, other_a)
+            super(VN_METHODS[:chmod], owner_u, owner_m, owner_a, group_u,
+                group_m, group_a, other_u, other_m, other_a)
+        end
+
+        #######################################################################
+        # Helpers to get VirtualNetwork information
+        #######################################################################
+
+        # Returns the group identifier
+        # [return] _Integer_ the element's group ID
+        def gid
+            self['GID'].to_i
+        end
+
+        # Returns the type of the Virtual Network (numeric value)
+        def type
+            self['TYPE'].to_i
+        end
+
+        # Returns the type of the Virtual Network (string value)
+        def type_str
+            VN_TYPES[type]
+        end
+
+        # Returns the state of the Virtual Network (string value)
+        def short_type_str
+            SHORT_VN_TYPES[type_str]
+        end
+
+        def public?
+            if self['PERMISSIONS/GROUP_U'] == "1" || self['PERMISSIONS/OTHER_U'] == "1"
+                true
+            else
+                false
+            end
+        end
+
+    private
+        def set_publish(published)
+            group_u = published ? 1 : 0
+
+            chmod(-1, -1, -1, group_u, -1, -1, -1, -1, -1)
+        end
+
+    end
+end

data/lib/OpenNebula/VirtualNetworkPool.rb

@@ -0,0 +1,74 @@
+# -------------------------------------------------------------------------- #
+# Copyright 2002-2012, OpenNebula Project Leads (OpenNebula.org)             #
+#                                                                            #
+# Licensed under the Apache License, Version 2.0 (the "License"); you may    #
+# not use this file except in compliance with the License. You may obtain    #
+# a copy of the License at                                                   #
+#                                                                            #
+# http://www.apache.org/licenses/LICENSE-2.0                                 #
+#                                                                            #
+# Unless required by applicable law or agreed to in writing, software        #
+# distributed under the License is distributed on an "AS IS" BASIS,          #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
+# See the License for the specific language governing permissions and        #
+# limitations under the License.                                             #
+#--------------------------------------------------------------------------- #
+
+
+require 'OpenNebula/Pool'
+
+module OpenNebula
+    class VirtualNetworkPool < Pool
+        #######################################################################
+        # Constants and Class attribute accessors
+        #######################################################################
+
+
+        VN_POOL_METHODS = {
+            :info => "vnpool.info"
+        }
+
+        #######################################################################
+        # Class constructor & Pool Methods
+        #######################################################################
+
+        # +client+ a Client object that represents a XML-RPC connection
+        # +user_id+ is to refer to a Pool with VirtualNetworks from that user
+        def initialize(client, user_id=0)
+            super('VNET_POOL','VNET',client)
+
+            @user_id  = user_id
+        end
+
+        # Default Factory Method for the Pools
+        def factory(element_xml)
+            OpenNebula::VirtualNetwork.new(element_xml,@client)
+        end
+
+        #######################################################################
+        # XML-RPC Methods for the Virtual Network Object
+        #######################################################################
+
+        # Retrieves all or part of the VirtualMachines in the pool.
+        def info(*args)
+            case args.size
+                when 0
+                    info_filter(VN_POOL_METHODS[:info],@user_id,-1,-1)
+                when 3
+                    info_filter(VN_POOL_METHODS[:info],args[0],args[1],args[2])
+            end
+        end
+
+        def info_all()
+            return super(VN_POOL_METHODS[:info])
+        end
+
+        def info_mine()
+            return super(VN_POOL_METHODS[:info])
+        end
+
+        def info_group()
+            return super(VN_POOL_METHODS[:info])
+        end
+    end
+end

data/lib/OpenNebula/XMLUtils.rb

@@ -0,0 +1,337 @@
+# -------------------------------------------------------------------------- #
+# Copyright 2002-2012, OpenNebula Project Leads (OpenNebula.org)             #
+#                                                                            #
+# Licensed under the Apache License, Version 2.0 (the "License"); you may    #
+# not use this file except in compliance with the License. You may obtain    #
+# a copy of the License at                                                   #
+#                                                                            #
+# http://www.apache.org/licenses/LICENSE-2.0                                 #
+#                                                                            #
+# Unless required by applicable law or agreed to in writing, software        #
+# distributed under the License is distributed on an "AS IS" BASIS,          #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
+# See the License for the specific language governing permissions and        #
+# limitations under the License.                                             #
+#--------------------------------------------------------------------------- #
+
+
+module OpenNebula
+
+    begin
+        require 'nokogiri'
+        NOKOGIRI=true
+    rescue LoadError
+        NOKOGIRI=false
+    end
+
+    begin
+        require 'rexml/formatters/pretty'
+        REXML_FORMATTERS=true
+    rescue LoadError
+        REXML_FORMATTERS=false
+    end
+
+    # The XMLElement class provides an abstraction of the underlying
+    # XML parser engine. It provides XML-related methods for the Pool and
+    # PoolElement classes
+    class XMLElement
+
+        # xml:: _opaque xml object_ an xml object as returned by build_xml
+        def initialize(xml=nil)
+            @xml = xml
+        end
+
+        # Initialize a XML document for the element
+        # xml:: _String_ the XML document of the object
+        # root_element:: _String_ Base xml element
+        def initialize_xml(xml, root_element)
+            @xml = XMLElement.build_xml(xml, root_element)
+
+            if OpenNebula.is_error?(@xml)
+                @xml = nil
+            else
+                if NOKOGIRI
+                    if @xml.size == 0
+                        @xml = nil
+                    end
+                else
+                    if @xml.name != root_element
+                        @xml = nil
+                    end
+                end
+            end
+        end
+
+        # Builds a XML document
+        # xml:: _String_ the XML document of the object
+        # root_element:: _String_ Base xml element
+        # [return] _XML_ object for the underlying XML engine
+        def self.build_xml(xml, root_element)
+            begin
+                if NOKOGIRI
+                    doc = Nokogiri::XML(xml).xpath("/#{root_element}")
+                else
+                    doc = REXML::Document.new(xml).root
+                end
+            rescue Exception => e
+                return OpenNebula::Error.new(e.message)
+            end
+
+            return doc
+        end
+        # Extract an element from the XML description of the PoolElement.
+        # key::_String_ The name of the element
+        # [return] _String_ the value of the element
+        # Examples:
+        #   ['VID'] # gets VM id
+        #   ['HISTORY/HOSTNAME'] # get the hostname from the history
+        def [](key)
+            if NOKOGIRI
+                element=@xml.xpath(key.to_s)
+
+                if element.size == 0
+                    return nil
+                end
+            else
+                element=@xml.elements[key.to_s]
+            end
+
+            if element
+                element.text
+            end
+        end
+
+        # Gets an array of text from elemenets extracted
+        # using  the XPATH  expression passed as filter
+        def retrieve_elements(filter)
+            elements_array = Array.new
+
+            if NOKOGIRI
+                @xml.xpath(filter.to_s).each { |pelem|
+                    elements_array << pelem.text if pelem.text
+                 }
+            else
+                @xml.elements.each(filter.to_s) { |pelem|
+                    elements_array << pelem.text if pelem.text
+                }
+            end
+
+            if elements_array.size == 0
+                return nil
+            else
+                return elements_array
+            end
+
+        end
+
+        # Gets an attribute from an elemenT
+        # key:: _String_ xpath for the element
+        # name:: _String_ name of the attribute
+        def attr(key,name)
+            value = nil
+
+            if NOKOGIRI
+                element=@xml.xpath(key.to_s.upcase)
+                if element.size == 0
+                    return nil
+                end
+
+                attribute = element.attr(name)
+
+                value = attribute.text if attribute != nil
+            else
+                element=@xml.elements[key.to_s.upcase]
+
+                value = element.attributes[name] if element != nil
+            end
+
+            return value
+        end
+
+        # Iterates over every Element in the XPath and calls the block with a
+        # a XMLElement
+        # block:: _Block_
+        def each(xpath_str,&block)
+            if NOKOGIRI
+                @xml.xpath(xpath_str).each { |pelem|
+                    block.call XMLElement.new(pelem)
+                }
+            else
+                @xml.elements.each(xpath_str) { |pelem|
+                    block.call XMLElement.new(pelem)
+                }
+            end
+        end
+
+        def each_xpath(xpath_str,&block)
+            if NOKOGIRI
+                @xml.xpath(xpath_str).each { |pelem|
+                    block.call pelem.text
+                }
+            else
+                @xml.elements.each(xpath_str) { |pelem|
+                    block.call pelem.text
+                }
+            end
+        end
+
+        def name
+            @xml.name
+        end
+
+        def text
+            if NOKOGIRI
+                @xml.content
+            else
+                @xml.text
+            end
+        end
+
+        def has_elements?(xpath_str)
+            if NOKOGIRI
+                element = @xml.xpath(xpath_str.to_s.upcase)
+                return element != nil && element.children.size > 0
+            else
+                element = @xml.elements[xpath_str.to_s]
+                return element != nil && element.has_elements?
+            end
+        end
+
+        def template_str(indent=true)
+            template_like_str('TEMPLATE', indent)
+        end
+
+        def template_like_str(root_element, indent=true, xpath_exp=nil)
+            if NOKOGIRI
+                xml_template=@xml.xpath(root_element).to_s
+                rexml=REXML::Document.new(xml_template).root
+            else
+                rexml=@xml.elements[root_element]
+            end
+
+            if indent
+                ind_enter="\n"
+                ind_tab='  '
+            else
+                ind_enter=''
+                ind_tab=' '
+            end
+
+            str=rexml.elements.collect(xpath_exp) {|n|
+                if n.class==REXML::Element
+                    str_line=""
+                    if n.has_elements?
+                        str_line << n.name << "=[" << ind_enter
+
+                        str_line << n.collect {|n2|
+                            if n2 && n2.class==REXML::Element
+                                str = ""
+                                str << ind_tab << n2.name << '='
+                                str << attr_to_str(n2.text) if n2.text
+                                str
+                            end
+                        }.compact.join(','+ind_enter)
+                        str_line<<" ]"
+                    else
+                        str_line << n.name << '=' << attr_to_str(n.text.to_s)
+                    end
+                    str_line
+                end
+            }.compact.join("\n")
+
+            str
+        end
+
+        def to_xml(pretty=false)
+            if NOKOGIRI && pretty
+                str = @xml.to_xml
+            elsif REXML_FORMATTERS && pretty
+                str = String.new
+
+                formatter = REXML::Formatters::Pretty.new
+                formatter.compact = true
+
+                formatter.write(@xml,str)
+            else
+                str = @xml.to_s
+            end
+
+            return str
+        end
+
+        def to_hash(hash={}, element=nil)
+            element ||= @xml.document.root
+
+            if NOKOGIRI
+                array = element.children
+                if array.length==1 and (array.first.text? or array.first.cdata?)
+                    r = array.first.text
+                else
+                    r = {}
+                    array.each { |c|
+                        if c.element?
+                            to_hash(r, c)
+                        end
+                    }
+                end
+            else
+                r = {}
+                if element.has_elements?
+                    element.each_element { |c| to_hash(r, c) }
+                elsif element.has_text?
+                    r = element.text
+                end
+            end
+
+            key = element.name
+            if hash.has_key?(key)
+                if hash[key].instance_of?(Array)
+                    hash[key] << r
+                else
+                    hash[key] = [hash[key], r]
+                end
+            else
+                hash[key] = r
+            end
+
+            hash
+        end
+
+    private
+        def attr_to_str(attr)
+            attr.gsub!('"',"\\\"")
+
+            if attr.match(/[=,' ']/)
+                return '"' + attr + '"'
+            end
+
+            return attr
+        end
+    end
+
+    # The XMLUtilsPool module provides an abstraction of the underlying
+    # XML parser engine. It provides XML-related methods for the Pools
+    class XMLPool < XMLElement
+
+        def initialize(xml=nil)
+            super(xml)
+        end
+
+        #Executes the given block for each element of the Pool
+        #block:: _Block_
+        def each_element(block)
+            if NOKOGIRI
+                @xml.xpath(
+                    "#{@element_name}").each {|pelem|
+                    block.call self.factory(pelem)
+                }
+            else
+                @xml.elements.each(
+                    "#{@element_name}") {|pelem|
+                    block.call self.factory(pelem)
+                }
+            end
+        end
+    end
+
+end