oca 3.2.1 → 3.4.1

data/lib/OpenNebula.rb

@@ -42,6 +42,10 @@ require 'OpenNebula/Group'
 require 'OpenNebula/GroupPool'
 require 'OpenNebula/Acl'
 require 'OpenNebula/AclPool'
+require 'OpenNebula/Datastore'
+require 'OpenNebula/DatastorePool'
+require 'OpenNebula/Cluster'
+require 'OpenNebula/ClusterPool'
 
 module OpenNebula
 
@@ -79,6 +83,30 @@ module OpenNebula
         value.class==OpenNebula::Error
     end
 
+
+    if OpenNebula::NOKOGIRI
+        class NokogiriStreamParser < XMLRPC::XMLParser::AbstractStreamParser
+            def initialize
+                @parser_class = NokogiriParser
+            end
+
+            class NokogiriParser < Nokogiri::XML::SAX::Document
+                include XMLRPC::XMLParser::StreamParserMixin
+
+                alias :cdata_block :character
+                alias :characters :character
+                alias :end_element :endElement
+                alias :start_element :startElement
+
+                def parse(str)
+                    parser = Nokogiri::XML::SAX::Parser.new(self)
+                    parser.parse(str)
+                end
+            end
+        end
+    end
+
+
     # The client class, represents the connection with the core and handles the
     # xml-rpc calls.
     class Client
@@ -113,14 +141,15 @@ module OpenNebula
             end
 
             @server = XMLRPC::Client.new2(@one_endpoint)
-        end
 
-        def call(action, *args)
-
-            if XMLPARSER
+            if OpenNebula::NOKOGIRI
+                @server.set_parser(NokogiriStreamParser.new)
+            elsif XMLPARSER
                 @server.set_parser(XMLRPC::XMLParser::XMLStreamParser.new)
             end
+        end
 
+        def call(action, *args)
             begin
                 response = @server.call_async("one."+action, @one_auth, *args)
 

data/lib/OpenNebula/Acl.rb

@@ -52,7 +52,9 @@ module OpenNebula
             "IMAGE"         => 0x8000000000,
             "USER"          => 0x10000000000,
             "TEMPLATE"      => 0x20000000000,
-            "GROUP"         => 0x40000000000
+            "GROUP"         => 0x40000000000,
+            "DATASTORE"     => 0x100000000000,
+            "CLUSTER"       => 0x200000000000
         }
 
         RIGHTS =

data/lib/OpenNebula/Cluster.rb

@@ -0,0 +1,236 @@
+# -------------------------------------------------------------------------- #
+# 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 Cluster < PoolElement
+        #######################################################################
+        # Constants and Class Methods
+        #######################################################################
+
+        CLUSTER_METHODS = {
+            :info           => "cluster.info",
+            :allocate       => "cluster.allocate",
+            :delete         => "cluster.delete",
+            :addhost        => "cluster.addhost",
+            :delhost        => "cluster.delhost",
+            :adddatastore   => "cluster.adddatastore",
+            :deldatastore   => "cluster.deldatastore",
+            :addvnet        => "cluster.addvnet",
+            :delvnet        => "cluster.delvnet"
+        }
+
+        # Creates a Cluster description with just its identifier
+        # this method should be used to create plain Cluster objects.
+        # +id+ the id of the host
+        #
+        # Example:
+        #   cluster = Cluster.new(Cluster.build_xml(3),rpc_client)
+        #
+        def Cluster.build_xml(pe_id=nil)
+            if pe_id
+                cluster_xml = "<CLUSTER><ID>#{pe_id}</ID></CLUSTER>"
+            else
+                cluster_xml = "<CLUSTER></CLUSTER>"
+            end
+
+            XMLElement.build_xml(cluster_xml,'CLUSTER')
+        end
+
+        # Class constructor
+        def initialize(xml, client)
+            super(xml,client)
+        end
+
+        #######################################################################
+        # XML-RPC Methods for the Cluster Object
+        #######################################################################
+
+        # Retrieves the information of the given Cluster.
+        def info()
+            super(CLUSTER_METHODS[:info], 'CLUSTER')
+        end
+
+        # Allocates a new Cluster in OpenNebula
+        #
+        # +clustername+ A string containing the name of the Cluster.
+        def allocate(clustername)
+            super(CLUSTER_METHODS[:allocate], clustername)
+        end
+
+        # Deletes the Cluster
+        def delete()
+            super(CLUSTER_METHODS[:delete])
+        end
+
+        # Adds a Host to this Cluster
+        # @param hid [Integer] Host ID
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def addhost(hid)
+            return Error.new('ID not defined') if !@pe_id
+
+            rc = @client.call(CLUSTER_METHODS[:addhost], @pe_id, hid)
+            rc = nil if !OpenNebula.is_error?(rc)
+
+            return rc
+        end
+
+        # Deletes a Host from this Cluster
+        # @param hid [Integer] Host ID
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def delhost(hid)
+            return Error.new('ID not defined') if !@pe_id
+
+            rc = @client.call(CLUSTER_METHODS[:delhost], @pe_id, hid)
+            rc = nil if !OpenNebula.is_error?(rc)
+
+            return rc
+        end
+
+        # Adds a Datastore to this Cluster
+        # @param ds_id [Integer] Datastore ID
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def adddatastore(ds_id)
+            return Error.new('ID not defined') if !@pe_id
+
+            rc = @client.call(CLUSTER_METHODS[:adddatastore], @pe_id, ds_id)
+            rc = nil if !OpenNebula.is_error?(rc)
+
+            return rc
+        end
+
+        # Deletes a Datastore from this Cluster
+        # @param ds_id [Integer] Datastore ID
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def deldatastore(ds_id)
+            return Error.new('ID not defined') if !@pe_id
+
+            rc = @client.call(CLUSTER_METHODS[:deldatastore], @pe_id, ds_id)
+            rc = nil if !OpenNebula.is_error?(rc)
+
+            return rc
+        end
+
+        # Adds a VNet to this Cluster
+        # @param vnet_id [Integer] VNet ID
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def addvnet(vnet_id)
+            return Error.new('ID not defined') if !@pe_id
+
+            rc = @client.call(CLUSTER_METHODS[:addvnet], @pe_id, vnet_id)
+            rc = nil if !OpenNebula.is_error?(rc)
+
+            return rc
+        end
+
+        # Deletes a VNet from this Cluster
+        # @param vnet_id [Integer] VNet ID
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def delvnet(vnet_id)
+            return Error.new('ID not defined') if !@pe_id
+
+            rc = @client.call(CLUSTER_METHODS[:delvnet], @pe_id, vnet_id)
+            rc = nil if !OpenNebula.is_error?(rc)
+
+            return rc
+        end
+
+        # ---------------------------------------------------------------------
+        # Helpers to get information
+        # ---------------------------------------------------------------------
+
+        # Returns whether or not the host with 'id' is part of this cluster
+        # @param id [Integer|Array] host ID
+        # @return [Boolean] true if found 
+        def contains_host?(id)
+            contains_resource?('HOSTS/ID', id)
+        end
+
+        # Returns an array with the numeric host ids
+        # @return [Array<Integer>]
+        def host_ids
+            array = Array.new
+
+            self.each("HOSTS/ID") do |id|
+                array << id.text.to_i
+            end
+
+            return array
+        end
+
+        # Returns whether or not the datastore with 'id' is part of this cluster
+        # @param id [Integer|Array] datastore ID
+        # @return [Boolean] true if found 
+        def contains_datastore?(id)
+            contains_resource?('DATASTORES/ID', id)
+        end
+
+        # Returns an array with the numeric datastore ids
+        # @return [Array<Integer>]
+        def datastore_ids
+            array = Array.new
+
+            self.each("DATASTORES/ID") do |id|
+                array << id.text.to_i
+            end
+
+            return array
+        end
+
+        # Returns whether or not the vnet with 'id' is part of this cluster
+        # @param id [Integer|Arrray] vnet ID
+        # @return [Boolean] true if found 
+        def contains_vnet?(id)
+            contains_resource?('VNETS/ID', id)
+        end
+
+        # Returns an array with the numeric vnet ids
+        # @return [Array<Integer>]
+        def vnet_ids
+            array = Array.new
+
+            self.each("VNETS/ID") do |id|
+                array << id.text.to_i
+            end
+
+            return array
+        end
+
+        private
+
+        def contains_resource?(xpath, id)
+            id_array = retrieve_elements(xpath)
+
+            return false if id_array.nil?
+
+            id = [id] if id.class != Array
+
+            id.each { |i| 
+                return false if !id_array.include?(i.to_s)
+            }
+
+            return true
+        end
+    end
+end

data/lib/OpenNebula/ClusterPool.rb

@@ -0,0 +1,56 @@
+# -------------------------------------------------------------------------- #
+# 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 ClusterPool < Pool
+        #######################################################################
+        # Constants and Class attribute accessors
+        #######################################################################
+
+        NONE_CLUSTER_ID      = -1
+        DEFAULT_CLUSTER_ID   = 0
+
+        CLUSTER_POOL_METHODS = {
+            :info => "clusterpool.info"
+        }
+
+        #######################################################################
+        # Class constructor & Pool Methods
+        #######################################################################
+
+        # +client+ a Client object that represents a XML-RPC connection
+        def initialize(client)
+            super('CLUSTER_POOL','CLUSTER',client)
+        end
+
+        # Factory method to create Cluster objects
+        def factory(element_xml)
+            OpenNebula::Cluster.new(element_xml,@client)
+        end
+
+        #######################################################################
+        # XML-RPC Methods for the Cluster Object
+        #######################################################################
+
+        # Retrieves all the Clusters in the pool.
+        def info()
+            super(CLUSTER_POOL_METHODS[:info])
+        end
+    end
+end

data/lib/OpenNebula/Datastore.rb

@@ -0,0 +1,147 @@
+# -------------------------------------------------------------------------- #
+# 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 Datastore < PoolElement
+        #######################################################################
+        # Constants and Class Methods
+        #######################################################################
+
+        DATASTORE_METHODS = {
+            :info       => "datastore.info",
+            :allocate   => "datastore.allocate",
+            :delete     => "datastore.delete",
+            :update     => "datastore.update",
+            :chown      => "datastore.chown",
+            :chmod      => "datastore.chmod"
+        }
+
+        # Creates a Datastore description with just its identifier
+        # this method should be used to create plain Datastore objects.
+        # +id+ the id of the user
+        #
+        # Example:
+        #   datastore = Datastore.new(Datastore.build_xml(3),rpc_client)
+        #
+        def Datastore.build_xml(pe_id=nil)
+            if pe_id
+                datastore_xml = "<DATASTORE><ID>#{pe_id}</ID></DATASTORE>"
+            else
+                datastore_xml = "<DATASTORE></DATASTORE>"
+            end
+
+            XMLElement.build_xml(datastore_xml,'DATASTORE')
+        end
+
+        # Class constructor
+        def initialize(xml, client)
+            super(xml,client)
+        end
+
+        #######################################################################
+        # XML-RPC Methods for the Datastore Object
+        #######################################################################
+
+        # Retrieves the information of the given Datastore.
+        def info()
+            super(DATASTORE_METHODS[:info], 'DATASTORE')
+        end
+
+        # Allocates a new Datastore in OpenNebula
+        #
+        # @param description [String] The template of the Datastore.
+        # @param cluster_id [Integer] Id of the cluster
+        #
+        # @return [Integer, OpenNebula::Error] the new ID in case of
+        #   success, error otherwise
+        def allocate(description, cluster_id=ClusterPool::NONE_CLUSTER_ID)
+            super(DATASTORE_METHODS[:allocate], description, cluster_id)
+        end
+
+        # Deletes the Datastore
+        def delete()
+            super(DATASTORE_METHODS[:delete])
+        end
+
+        # Replaces the template contents
+        #
+        # @param new_template [String] New template contents
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def update(new_template)
+            super(DATASTORE_METHODS[:update], new_template)
+        end
+
+        # Changes the owner/group
+        #
+        # @param uid [Integer] the new owner id. Set to -1 to leave the current one
+        # @param gid [Integer] the new group id. Set to -1 to leave the current one
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def chown(uid, gid)
+            super(DATASTORE_METHODS[:chown], uid, gid)
+        end
+
+        # Changes the datastore 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(DATASTORE_METHODS[:chmod], octet)
+        end
+
+        # Changes the datastore 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(DATASTORE_METHODS[:chmod], owner_u, owner_m, owner_a, group_u,
+                group_m, group_a, other_u, other_m, other_a)
+        end
+
+        # ---------------------------------------------------------------------
+        # Helpers to get information
+        # ---------------------------------------------------------------------
+
+        # Returns whether or not the image with id 'id' is part of this datastore
+        def contains(id)
+            #This doesn't work in ruby 1.8.5
+            #return self["DATASTORE/ID[.=#{uid}]"] != nil
+
+            id_array = retrieve_elements('IMAGES/ID')
+            return id_array != nil && id_array.include?(uid.to_s)
+        end
+
+        # Returns an array with the numeric image ids
+        def img_ids
+            array = Array.new
+
+            self.each("IMAGES/ID") do |id|
+                array << id.text.to_i
+            end
+
+            return array
+        end
+    end
+end

data/lib/OpenNebula/DatastorePool.rb

@@ -0,0 +1,53 @@
+# -------------------------------------------------------------------------- #
+# 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 DatastorePool < Pool
+        #######################################################################
+        # Constants and Class attribute accessors
+        #######################################################################
+
+        DATASTORE_POOL_METHODS = {
+            :info => "datastorepool.info"
+        }
+
+        #######################################################################
+        # Class constructor & Pool Methods
+        #######################################################################
+
+        # +client+ a Client object that represents a XML-RPC connection
+        def initialize(client)
+            super('DATASTORE_POOL','DATASTORE',client)
+        end
+
+        # Factory method to create User objects
+        def factory(element_xml)
+            OpenNebula::Group.new(element_xml,@client)
+        end
+
+        #######################################################################
+        # XML-RPC Methods for the User Object
+        #######################################################################
+
+        # Retrieves all the Groups in the pool.
+        def info()
+            super(DATASTORE_POOL_METHODS[:info])
+        end
+    end
+end

data/lib/OpenNebula/Group.rb

@@ -69,7 +69,7 @@ module OpenNebula
         # Creates ACLs for the group. The ACL rules are described in a file
         def create_acls(filename = GROUP_DEFAULT)
             if !File.readable?(filename)
-                return -1, "Can not read deafult ACL file for group"
+                return -1, "Cannot read deafult ACL file for group"
             end
 
             msg = String.new

data/lib/OpenNebula/Host.rb

@@ -79,14 +79,15 @@ module OpenNebula
         # Allocates a new Host in OpenNebula
         #
         # @param hostname [String] Name of the new Host.
-        # @param im [String] Name of the im_driver
-        # @param vmm [String] Name of the vmm_driver
-        # @param tm [String] Name of the tm_driver
+        # @param im [String] Name of the im_driver (information/monitoring)
+        # @param vmm [String] Name of the vmm_driver (hypervisor)
+        # @param tm [String] Name of the vnm_driver (networking)
+        # @param cluster_id [String] Id of the cluster
         #
-        # @return [Integer, OpenNebula::Error] the new VM ID in case of
+        # @return [Integer, OpenNebula::Error] the new ID in case of
         #   success, error otherwise
-        def allocate(hostname,im,vmm,vnm,tm)
-            super(HOST_METHODS[:allocate],hostname,im,vmm,vnm,tm)
+        def allocate(hostname,im,vmm,vnm,cluster_id=ClusterPool::NONE_CLUSTER_ID)
+            super(HOST_METHODS[:allocate],hostname,im,vmm,vnm,cluster_id)
         end
 
         # Deletes the Host

data/lib/OpenNebula/Image.rb

@@ -91,9 +91,13 @@ module OpenNebula
 
         # Allocates a new Image in OpenNebula
         #
-        # +description+ A string containing the template of the Image.
-        def allocate(description)
-            super(IMAGE_METHODS[:allocate],description)
+        # @param description [String] A string containing the template of the Image.
+        # @param ds_id [Integer] the target datastore ID
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def allocate(description, ds_id)
+            super(IMAGE_METHODS[:allocate],description, ds_id)
         end
 
         # Replaces the template contents

data/lib/OpenNebula/Pool.rb

@@ -178,6 +178,8 @@ module OpenNebula
         def update(xml_method, new_template)
             return Error.new('ID not defined') if !@pe_id
 
+            new_template ||= template_xml
+
             rc = @client.call(xml_method,@pe_id, new_template)
             rc = nil if !OpenNebula.is_error?(rc)
 

data/lib/OpenNebula/Template.rb

@@ -70,9 +70,12 @@ module OpenNebula
 
         # Allocates a new Template in OpenNebula
         #
-        # +templatename+ A string containing the name of the Template.
-        def allocate(templatename)
-            super(TEMPLATE_METHODS[:allocate], templatename)
+        # @param description [String] The contents of the Template.
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def allocate(description)
+            super(TEMPLATE_METHODS[:allocate], description)
         end
 
         # Deletes the Template

data/lib/OpenNebula/VirtualNetwork.rb

@@ -78,15 +78,19 @@ module OpenNebula
 
         # Allocates a new VirtualNetwork in OpenNebula
         #
-        # +description+ A string containing the template of the VirtualNetwork.
-        def allocate(description)
-            super(VN_METHODS[:allocate],description)
+        # @param description [String] The template of the VirtualNetwork.
+        # @param cluster_id [Integer] Id of the cluster
+        #
+        # @return [Integer, OpenNebula::Error] the new ID in case of
+        #   success, error otherwise
+        def allocate(description,cluster_id=ClusterPool::NONE_CLUSTER_ID)
+            super(VN_METHODS[:allocate], description, cluster_id)
         end
 
         # Replaces the template contents
         #
         # +new_template+ New template contents
-        def update(new_template)
+        def update(new_template=nil)
             super(VN_METHODS[:update], new_template)
         end
 
@@ -158,9 +162,12 @@ module OpenNebula
         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
+        #
+        # @param uid [Integer] the new owner id. Set to -1 to leave the current one
+        # @param gid [Integer] the new group id. Set to -1 to leave the current one
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
         def chown(uid, gid)
             super(VN_METHODS[:chown], uid, gid)
         end

data/lib/OpenNebula/XMLUtils.rb

@@ -101,6 +101,44 @@ module OpenNebula
             end
         end
 
+        def delete_element(xpath)
+            if NOKOGIRI
+                @xml.xpath(xpath.to_s).remove
+            else
+                @xml.delete_element(xpath.to_s)
+            end
+        end
+
+        def add_element(xpath, elems)
+            elems.each { |key, value|
+                if value.instance_of?(Hash)
+                    if NOKOGIRI
+                        elem = Nokogiri::XML::Node.new key, @xml.document
+                        value.each { |k2, v2|
+                            child = Nokogiri::XML::Node.new k2, elem
+                            child.content = v2
+                            elem.add_child(child)
+                        }
+                        @xml.xpath(xpath.to_s).first.add_child(elem)
+                    else
+                        elem = REXML::Element.new(key)
+                        value.each { |k2, v2|
+                            elem.add_element(k2).text = v2
+                        }
+                        @xml.elements[xpath].add_element(elem)
+                    end
+                else
+                    if NOKOGIRI
+                        elem = Nokogiri::XML::Node.new key, @xml.document
+                        elem.content = value
+                        @xml.xpath(xpath.to_s).first.add_child(elem)
+                    else
+                        @xml.elements[xpath].add_element(key).text = value
+                    end
+                end
+            }
+        end
+
         # Gets an array of text from elemenets extracted
         # using  the XPATH  expression passed as filter
         def retrieve_elements(filter)
@@ -187,6 +225,8 @@ module OpenNebula
             end
         end
 
+        # Returns wheter there are elements for a given XPath
+        # xpath_str:: _String_ XPath expression to locate the element
         def has_elements?(xpath_str)
             if NOKOGIRI
                 element = @xml.xpath(xpath_str.to_s.upcase)
@@ -197,51 +237,69 @@ module OpenNebula
             end
         end
 
+        # Returns the <TEMPLATE> element in text form
+        # indent:: _Boolean_ indents the resulting string, default true
         def template_str(indent=true)
             template_like_str('TEMPLATE', indent)
         end
 
+        # Returns the <TEMPLATE> element in XML form
+        def template_xml
+            if NOKOGIRI
+                @xml.xpath('TEMPLATE').to_s
+            else
+                @xml.elements['TEMPLATE'].to_s
+            end
+        end
+
+        # Returns elements in text form
+        # root_element:: _String_ base element
+        # indent:: _Boolean_ indents the resulting string, default true
+        # xpath_exp:: _String_ filter elements with a XPath
         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
+                xml_template = @xml.xpath(root_element).to_s
+                rexml        = REXML::Document.new(xml_template).root
             else
-                rexml=@xml.elements[root_element]
+                rexml = @xml.elements[root_element]
             end
 
             if indent
-                ind_enter="\n"
-                ind_tab='  '
+                ind_enter = "\n"
+                ind_tab   = '  '
             else
-                ind_enter=''
-                ind_tab=' '
+                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
+            str = rexml.elements.collect(xpath_exp) {|n|
+                next if n.class != REXML::Element
+
+                str_line = ""
+
+                if n.has_elements?
+                    str_line << "#{n.name}=[#{ind_enter}" << n.collect { |n2|
+
+                        next if n2.class != REXML::Element or !n2.has_text?
+
+                        str = "#{ind_tab}#{n2.name}=#{attr_to_str(n2.text)}"
+
+                    }.compact.join(",#{ind_enter}") << " ]"
+                else
+                    next if !n.has_text?
+
+                    str_line << "#{n.name}=#{attr_to_str(n.text)}"
                 end
+
+                str_line
             }.compact.join("\n")
 
-            str
+            return str
         end
 
+        #
+        #
+        #
         def to_xml(pretty=false)
             if NOKOGIRI && pretty
                 str = @xml.to_xml
@@ -259,6 +317,9 @@ module OpenNebula
             return str
         end
 
+        #
+        #
+        #
         def to_hash(hash={}, element=nil)
             element ||= @xml.document.root
 
@@ -298,13 +359,14 @@ module OpenNebula
         end
 
     private
+    
+        #
+        #
+        #
         def attr_to_str(attr)
             attr.gsub!('"',"\\\"")
-
-            if attr.match(/[=,' ']/)
-                return '"' + attr + '"'
-            end
-
+            attr = "\"#{attr}\""
+            
             return attr
         end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oca
 version: !ruby/object:Gem::Version
-  version: 3.2.1
+  version: 3.4.1
   prerelease: 
 platform: ruby
 authors:
@@ -52,6 +52,10 @@ files:
 - lib/OpenNebula.rb
 - lib/OpenNebula/Acl.rb
 - lib/OpenNebula/AclPool.rb
+- lib/OpenNebula/Cluster.rb
+- lib/OpenNebula/ClusterPool.rb
+- lib/OpenNebula/Datastore.rb
+- lib/OpenNebula/DatastorePool.rb
 - lib/OpenNebula/Group.rb
 - lib/OpenNebula/GroupPool.rb
 - lib/OpenNebula/Host.rb