opennebula-oca 3.8.0.beta1

data/lib/OpenNebula/Acl.rb

@@ -0,0 +1,259 @@
+# -------------------------------------------------------------------------- #
+# 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
+
+    # Abstract rules of the type USER RESOURCE RIGHTS
+    # which are:
+    #     USER      -> #<num>
+    #                  @<num>
+    #                  ALL
+    #     RESOURCE  -> + separated list and "/{#,@}<num>|ALL"
+    #                  VM,
+    #                  HOST
+    #                  NET
+    #                  IMAGE
+    #                  USER
+    #                  TEMPLATE
+    #                  GROUP
+    #                  ACL
+    #     RIGHTS    -> + separated list
+    #                  USE
+    #                  MANAGE
+    #                  ADMIN
+    #                  CREATE
+    class Acl < PoolElement
+
+        USERS = {
+            "UID"           => 0x100000000,
+            "GID"           => 0x200000000,
+            "ALL"           => 0x400000000
+        }
+
+        RESOURCES =
+        {
+            "VM"            => 0x1000000000,
+            "HOST"          => 0x2000000000,
+            "NET"           => 0x4000000000,
+            "IMAGE"         => 0x8000000000,
+            "USER"          => 0x10000000000,
+            "TEMPLATE"      => 0x20000000000,
+            "GROUP"         => 0x40000000000,
+            "DATASTORE"     => 0x100000000000,
+            "CLUSTER"       => 0x200000000000,
+            "DOCUMENT"      => 0x400000000000
+        }
+
+        RIGHTS =
+        {
+            "USE"           => 0x1,  # Auth. to use an object
+            "MANAGE"        => 0x2,  # Auth. to perform management actions
+            "ADMIN"         => 0x4,  # Auth. to perform administrative actions
+            "CREATE"        => 0x8   # Auth. to create an object
+        }
+
+        # Constructor
+        #
+        # @param xml [String] must be an xml built with {#build_xml}
+        # @param client [Client] represents an XML-RPC connection
+        def initialize(xml, client)
+            super(xml,client)
+        end
+
+        # Creates an empty XML representation. It contains the id, if it is
+        # specified.
+        #
+        # @param pe_id [Integer] rule ID
+        # @param client [Client] represents an XML-RPC connection
+        #
+        # @return [String] an empty XML representation
+        def self.build_xml(pe_id=nil)
+            if pe_id
+                acl_xml = "<ACL><ID>#{pe_id}</ID></ACL>"
+            else
+                acl_xml = "<ACL></ACL>"
+            end
+
+            XMLElement.build_xml(acl_xml,'ACL')
+        end
+
+        # Creates a new ACL rule.
+        #
+        # @param user [String]
+        #   A string containing a hex number, e.g. 0x100000001
+        # @param resource [String]
+        #   A string containing a hex number, e.g. 0x2100000001
+        # @param rights [String]
+        #   A string containing a hex number, e.g. 0x10
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def allocate(user, resource, rights)
+            return super( AclPool::ACL_POOL_METHODS[:addrule],
+                          user,
+                          resource,
+                          rights )
+        end
+
+        # Deletes the Acl rule
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def delete()
+            super(AclPool::ACL_POOL_METHODS[:delrule])
+        end
+
+        # Does nothing, individual ACL rules info can't be retrieved from
+        # OpenNebula
+        #
+        # @return [nil] nil
+        def info()
+            return nil
+        end
+
+        # Parses a rule string, e.g. "#5 HOST+VM/@12 INFO+CREATE+DELETE"
+        #
+        # @param rule_str [String] an ACL rule in string format
+        #
+        # @return [Array] an Array containing 3 strings (hex 64b numbers),
+        # or OpenNebula::Error objects
+        def self.parse_rule(rule_str)
+            ret = Array.new
+
+            rule_str = rule_str.split(" ")
+
+            if rule_str.length != 3
+                return OpenNebula::Error.new(
+                    "String needs three components: User, Resource, Rights")
+            end
+
+            ret << parse_users(rule_str[0])
+            ret << parse_resources(rule_str[1])
+            ret << parse_rights(rule_str[2])
+
+            errors=ret.map do |arg|
+                if OpenNebula.is_error?(arg)
+                    arg.message
+                else
+                    nil
+                end
+            end
+
+            errors.compact!
+
+            if errors.length>0
+                return OpenNebula::Error.new(errors.join(', '))
+            end
+
+            return ret
+        end
+
+private
+
+        # Converts a string in the form [#<id>, @<id>, *] to a hex. number
+        #
+        # @param users [String] Users component string
+        #
+        # @return [String] A string containing a hex number
+        def self.parse_users(users)
+           begin
+               return calculate_ids(users).to_i.to_s(16)
+           rescue Exception  => e
+               return OpenNebula::Error.new(e.message)
+           end
+        end
+
+        # Converts a resources string to a hex. number
+        #
+        # @param resources [String] Resources component string
+        #
+        # @return [String] A string containing a hex number
+        def self.parse_resources(resources)
+            begin
+                ret = 0
+                resources = resources.split("/")
+
+                if resources.size != 2
+                    raise "Resource '#{resources}' malformed"
+                end
+
+                resources[0].split("+").each{ |resource|
+                    if !RESOURCES[resource.upcase]
+                        raise "Resource '#{resource}' does not exist"
+                    end
+                    ret += RESOURCES[resource.upcase]
+                }
+
+                ret += calculate_ids(resources[1])
+
+                return ret.to_i.to_s(16)
+            rescue Exception  => e
+                return OpenNebula::Error.new(e.message)
+            end
+        end
+
+        # Converts a rights string to a hex. number
+        #
+        # @param rights [String] Rights component string
+        #
+        # @return [String] A string containing a hex number
+        def self.parse_rights(rights)
+            begin
+                ret = 0
+                rights = rights.split("+")
+
+                rights.each{ |right|
+                    raise "Right '#{right}' does not exist" if !RIGHTS[right.upcase]
+
+                    ret += RIGHTS[right.upcase]
+                }
+
+                return ret.to_i.to_s(16)
+            rescue Exception  => e
+                return OpenNebula::Error.new(e.message)
+            end
+        end
+
+        # Calculates the numeric value for a String containing an individual
+        # (#<id>), group (@<id>) or all (*) ID component
+        #
+        # @param id_str [String] Rule Id string
+        #
+        # @return [Integer] the numeric value for the given id_str
+        def self.calculate_ids(id_str)
+            raise "ID string '#{id_str}' malformed" if
+                !id_str.match(/^([\#@]\d+|\*)$/)
+
+            value = 0
+
+            case id_str[0..0]
+                when "#"
+                    value = USERS["UID"]
+                    users_value = id_str[1..-1].to_i + value
+
+                when "@"
+                    value = USERS["GID"]
+                    users_value = id_str[1..-1].to_i + value
+
+                when "*"
+                    users_value = USERS["ALL"]
+            end
+
+            return users_value
+        end
+    end
+end

data/lib/OpenNebula/AclPool.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 AclPool < Pool
+
+        #######################################################################
+        # Constants and Class Methods
+        #######################################################################
+
+
+        ACL_POOL_METHODS = {
+            :info       => "acl.info",
+            :addrule    => "acl.addrule",
+            :delrule    => "acl.delrule"
+        }
+
+        # Class constructor
+        def initialize(client)
+            super('ACL_POOL','ACL',client)
+        end
+
+        def factory(element_xml)
+            OpenNebula::Acl.new(element_xml, @client)
+        end
+
+        #######################################################################
+        # XML-RPC Methods
+        #######################################################################
+
+        # Retrieves the ACL Pool
+        def info()
+        # Retrieves all the Acls in the pool.
+            super(ACL_POOL_METHODS[:info])
+        end
+    end
+end

data/lib/OpenNebula/Cluster.rb

@@ -0,0 +1,247 @@
+# -------------------------------------------------------------------------- #
+# 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",
+            :update         => "cluster.update",
+        }
+
+        # 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
+
+        # 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(CLUSTER_METHODS[:update], new_template)
+        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