occi 1.2.1 → 2.0.0

data/lib/OpenNebula/Pool.rb

@@ -0,0 +1,285 @@
+# -------------------------------------------------------------------------- #
+# 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
+
+    # The Pool class represents a generic OpenNebula Pool in XML format
+    # and provides the basic functionality to handle the Pool elements
+    class Pool < XMLPool
+        include Enumerable
+
+    protected
+        #pool:: _String_ XML name of the root element
+        #element:: _String_ XML name of the Pool elements
+        #client::  _Client_ represents a XML-RPC connection
+        def initialize(pool,element,client)
+            super(nil)
+
+            @pool_name    = pool.upcase
+            @element_name = element.upcase
+
+            @client = client
+        end
+
+        # 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
+        def factory(element_xml)
+            OpenNebula::PoolElement.new(element_xml,client)
+        end
+
+        #######################################################################
+        # Common XML-RPC Methods for all the Pool Types
+        #######################################################################
+
+        #Gets the pool without any filter. Host, Group and User Pools
+        # xml_method:: _String_ the name of the XML-RPC method
+        def info(xml_method)
+            return xmlrpc_info(xml_method)
+        end
+
+        def info_all(xml_method)
+            return xmlrpc_info(xml_method,INFO_ALL,-1,-1)
+        end
+
+        def info_mine(xml_method)
+            return xmlrpc_info(xml_method,INFO_MINE,-1,-1)
+        end
+
+        def info_group(xml_method)
+            return xmlrpc_info(xml_method,INFO_GROUP,-1,-1)
+        end
+
+        def info_filter(xml_method, who, start_id, end_id)
+            return xmlrpc_info(xml_method,who, start_id, end_id)
+        end
+
+    private
+        # 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
+        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
+
+    public
+        # Constants for info queries (include/RequestManagerPoolInfoFilter.h)
+        INFO_GROUP = -1
+        INFO_ALL   = -2
+        INFO_MINE  = -3
+
+        # Iterates over every PoolElement in the Pool and calls the block with a
+        # a PoolElement obtained calling the factory method
+        # block:: _Block_
+        def each(&block)
+            each_element(block) if @xml
+        end
+
+        # DO NOT USE - ONLY REXML BACKEND
+        def to_str
+            str = ""
+            REXML::Formatters::Pretty.new(1).write(@xml,str)
+
+            return str
+        end
+    end
+
+    # The PoolElement Class represents a generic element of a Pool in
+    # XML format
+    class PoolElement < XMLElement
+
+    protected
+        # node:: _XML_is a XML element that represents the Pool element
+        # client:: _Client_ represents a XML-RPC connection
+        def initialize(node, client)
+            @xml    = node
+            @client = client
+
+            if self['ID']
+                @pe_id = self['ID'].to_i
+            else
+                @pe_id = nil
+            end
+            @name = self['NAME'] if self['NAME']
+        end
+
+        #######################################################################
+        # Common XML-RPC Methods for all the Pool Element Types
+        #######################################################################
+
+        # Calls to the corresponding info method to retreive the element
+        # detailed information in XML format
+        # xml_method:: _String_ the name of the XML-RPC method
+        # root_element:: _String_ Base XML element
+        # [return] nil in case of success or an Error object
+        def info(xml_method, root_element)
+            return Error.new('ID not defined') if !@pe_id
+
+            rc = @client.call(xml_method,@pe_id)
+
+            if !OpenNebula.is_error?(rc)
+                initialize_xml(rc, root_element)
+                rc   = nil
+
+                @pe_id = self['ID'].to_i if self['ID']
+                @name  = self['NAME'] if self['NAME']
+            end
+
+            return rc
+        end
+
+        # Calls to the corresponding allocate method to create a new element
+        # in the OpenNebula core
+        # xml_method:: _String_ the name of the XML-RPC method
+        # args:: _Array_ additional arguments including the template for the
+        #                new element
+        # [return] nil in case of success or an Error object
+        def allocate(xml_method, *args)
+            rc = @client.call(xml_method, *args)
+
+            if !OpenNebula.is_error?(rc)
+                @pe_id = rc
+                rc     = nil
+            end
+
+            return rc
+        end
+
+        # Calls to the corresponding update method to modify
+        # the object's template
+        # xml_method:: _String_ the name of the XML-RPC method
+        # new_template:: _String_ the new template contents
+        # [return] nil in case of success or an Error object
+        def update(xml_method, new_template)
+            return Error.new('ID not defined') if !@pe_id
+
+            rc = @client.call(xml_method,@pe_id, new_template)
+            rc = nil if !OpenNebula.is_error?(rc)
+
+            return rc
+        end
+
+        # Calls to the corresponding delete method to remove this element
+        # from the OpenNebula core
+        # xml_method:: _String_ the name of the XML-RPC method
+        # [return] nil in case of success or an Error object
+        def delete(xml_method)
+            return Error.new('ID not defined') if !@pe_id
+
+            rc = @client.call(xml_method,@pe_id)
+            rc = nil if !OpenNebula.is_error?(rc)
+
+            return rc
+        end
+
+        # Calls to the corresponding chown method to modify
+        # the object's owner and group
+        # xml_method:: _String_ the name of the XML-RPC method
+        # 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(xml_method, uid, gid)
+            return Error.new('ID not defined') if !@pe_id
+
+            rc = @client.call(xml_method,@pe_id, uid, gid)
+            rc = nil if !OpenNebula.is_error?(rc)
+
+            return rc
+        end
+
+        # Calls to the corresponding chmod method to modify
+        # the object's permission bits
+        #
+        # @param xml_method [String] the name of the XML-RPC method
+        # @param octet [String] Permissions octed , e.g. 640
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def chmod_octet(xml_method, octet)
+            owner_u = octet[0..0].to_i & 4 != 0 ? 1 : 0
+            owner_m = octet[0..0].to_i & 2 != 0 ? 1 : 0
+            owner_a = octet[0..0].to_i & 1 != 0 ? 1 : 0
+            group_u = octet[1..1].to_i & 4 != 0 ? 1 : 0
+            group_m = octet[1..1].to_i & 2 != 0 ? 1 : 0
+            group_a = octet[1..1].to_i & 1 != 0 ? 1 : 0
+            other_u = octet[2..2].to_i & 4 != 0 ? 1 : 0
+            other_m = octet[2..2].to_i & 2 != 0 ? 1 : 0
+            other_a = octet[2..2].to_i & 1 != 0 ? 1 : 0
+
+            chmod(owner_u, owner_m, owner_a, group_u, group_m, group_a, other_u,
+                other_m, other_a)
+        end
+
+        # Calls to the corresponding chmod method to modify
+        # the object's permission bits
+        # Each [Integer] parameter must be 1 to allow, 0 deny, -1 do not change
+        #
+        # @param xml_method [String] the name of the XML-RPC method
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def chmod(xml_method, owner_u, owner_m, owner_a, group_u, group_m, group_a, other_u,
+                other_m, other_a)
+            return Error.new('ID not defined') if !@pe_id
+
+            rc = @client.call(xml_method, @pe_id, owner_u, owner_m,
+                            owner_a, group_u, group_m, group_a, other_u,
+                            other_m, other_a)
+            rc = nil if !OpenNebula.is_error?(rc)
+
+            return rc
+        end
+
+    public
+
+        # Creates new element specifying its id
+        # id:: identifyier of the element
+        # client:: initialized OpenNebula::Client object
+        def self.new_with_id(id, client=nil)
+            self.new(self.build_xml(id), client)
+        end
+
+        # Returns element identifier
+        # [return] _Integer_ the PoolElement ID
+        def id
+            @pe_id
+        end
+
+        # Gets element name
+        # [return] _String_ the PoolElement name
+        def name
+            @name
+        end
+
+        # DO NOT USE - ONLY REXML BACKEND
+        def to_str
+            str = ""
+            REXML::Formatters::Pretty.new(1).write(@xml,str)
+
+            return str
+        end
+    end
+end

data/lib/OpenNebula/Template.rb

@@ -0,0 +1,173 @@
+# -------------------------------------------------------------------------- #
+# 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 Template < PoolElement
+        #######################################################################
+        # Constants and Class Methods
+        #######################################################################
+
+
+        TEMPLATE_METHODS = {
+            :allocate    => "template.allocate",
+            :instantiate => "template.instantiate",
+            :info        => "template.info",
+            :update      => "template.update",
+            :publish     => "template.publish",
+            :delete      => "template.delete",
+            :chown       => "template.chown",
+            :chmod       => "template.chmod"
+        }
+
+        # Creates a Template description with just its identifier
+        # this method should be used to create plain Template objects.
+        # +id+ the id of the user
+        #
+        # Example:
+        #   template = Template.new(Template.build_xml(3),rpc_client)
+        #
+        def Template.build_xml(pe_id=nil)
+            if pe_id
+                obj_xml = "<VMTEMPLATE><ID>#{pe_id}</ID></VMTEMPLATE>"
+            else
+                obj_xml = "<VMTEMPLATE></VMTEMPLATE>"
+            end
+
+            XMLElement.build_xml(obj_xml,'VMTEMPLATE')
+        end
+
+        # Class constructor
+        def initialize(xml, client)
+            super(xml,client)
+
+            @client = client
+        end
+
+        #######################################################################
+        # XML-RPC Methods for the Template Object
+        #######################################################################
+
+        # Retrieves the information of the given Template.
+        def info()
+            super(TEMPLATE_METHODS[:info], 'VMTEMPLATE')
+        end
+
+        # Allocates a new Template in OpenNebula
+        #
+        # +templatename+ A string containing the name of the Template.
+        def allocate(templatename)
+            super(TEMPLATE_METHODS[:allocate], templatename)
+        end
+
+        # Deletes the Template
+        def delete()
+            super(TEMPLATE_METHODS[:delete])
+        end
+
+        # Creates a VM instance from a Template
+        #
+        # +name+ A string containing the name of the VM instance.
+        # [return] The new VM Instance ID, or an Error object
+        def instantiate(name="")
+            return Error.new('ID not defined') if !@pe_id
+
+            name ||= ""
+            rc = @client.call(TEMPLATE_METHODS[:instantiate], @pe_id, name)
+
+            return rc
+        end
+
+        # Replaces the template contents
+        #
+        # +new_template+ New template contents
+        def update(new_template)
+            return Error.new('ID not defined') if !@pe_id
+
+            super(TEMPLATE_METHODS[:update], new_template)
+        end
+
+        # Publishes the Template, to be used by other users
+        def publish
+            set_publish(true)
+        end
+
+        # Unplubishes the Image
+        def unpublish
+            set_publish(false)
+        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(TEMPLATE_METHODS[:chown], uid, gid)
+        end
+
+        # Changes the Template 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(TEMPLATE_METHODS[:chmod], octet)
+        end
+
+        # Changes the Template 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(TEMPLATE_METHODS[:chmod], owner_u, owner_m, owner_a, group_u,
+                group_m, group_a, other_u, other_m, other_a)
+        end
+
+        #######################################################################
+        # Helpers to get Template information
+        #######################################################################
+
+        # Returns the group identifier
+        # [return] _Integer_ the element's group ID
+        def gid
+            self['GID'].to_i
+        end
+
+        def owner_id
+            self['UID'].to_i
+        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