opennebula-oca 3.9.0.beta → 3.9.90.rc

data/lib/opennebula/image.rb

@@ -1,293 +0,0 @@
-# -------------------------------------------------------------------------- #
-# 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_element'
-require 'fileutils'
-
-module OpenNebula
-    class Image < PoolElement
-        #######################################################################
-        # Constants and Class Methods
-        #######################################################################
-
-
-        IMAGE_METHODS = {
-            :info        => "image.info",
-            :allocate    => "image.allocate",
-            :update      => "image.update",
-            :enable      => "image.enable",
-            :persistent  => "image.persistent",
-            :delete      => "image.delete",
-            :chown       => "image.chown",
-            :chmod       => "image.chmod",
-            :chtype      => "image.chtype",
-            :clone       => "image.clone",
-            :rename      => "image.rename"
-        }
-
-        IMAGE_STATES=%w{INIT READY USED DISABLED LOCKED ERROR CLONE DELETE USED_PERS}
-
-        SHORT_IMAGE_STATES={
-            "INIT"      => "init",
-            "READY"     => "rdy",
-            "USED"      => "used",
-            "DISABLED"  => "disa",
-            "LOCKED"    => "lock",
-            "ERROR"     => "err",
-            "CLONE"     => "clon",
-            "DELETE"    => "dele",
-            "USED_PERS" => "used"
-        }
-
-        IMAGE_TYPES=%w{OS CDROM DATABLOCK KERNEL RAMDISK CONTEXT}
-
-        SHORT_IMAGE_TYPES={
-            "OS"        => "OS",
-            "CDROM"     => "CD",
-            "DATABLOCK" => "DB",
-            "KERNEL"    => "KL",
-            "RAMDISK"   => "RD",
-            "CONTEXT"   => "CX"
-        }
-
-        # Creates an Image description with just its identifier
-        # this method should be used to create plain Image objects.
-        # +id+ the id of the image
-        #
-        # Example:
-        #   image = Image.new(Image.build_xml(3),rpc_client)
-        #
-        def Image.build_xml(pe_id=nil)
-            if pe_id
-                image_xml = "<IMAGE><ID>#{pe_id}</ID></IMAGE>"
-            else
-                image_xml = "<IMAGE></IMAGE>"
-            end
-
-            XMLElement.build_xml(image_xml,'IMAGE')
-        end
-
-        # Class constructor
-        def initialize(xml, client)
-            super(xml,client)
-
-            @client = client
-        end
-
-        #######################################################################
-        # XML-RPC Methods for the Image Object
-        #######################################################################
-
-        # Retrieves the information of the given Image.
-        def info()
-            super(IMAGE_METHODS[:info], 'IMAGE')
-        end
-
-        # Allocates a new Image in OpenNebula
-        #
-        # @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
-        #
-        # +new_template+ New template contents. If no argument is provided
-        #   the object will be updated using the @xml variable
-        def update(new_template=nil)
-            super(IMAGE_METHODS[:update], new_template)
-        end
-
-        # Enables an Image
-        def enable
-            set_enabled(true)
-        end
-
-        # Disables an Image
-        def disable
-            set_enabled(false)
-        end
-
-        # Publishes the Image, to be used by other users
-        def publish
-            set_publish(true)
-        end
-
-        # Unplubishes the Image
-        def unpublish
-            set_publish(false)
-        end
-
-        # Makes the Image persistent
-        def persistent
-            set_persistent(true)
-        end
-
-        # Makes the Image non persistent
-        def nonpersistent
-            set_persistent(false)
-        end
-
-        # Deletes the Image
-        def delete()
-            super(IMAGE_METHODS[:delete])
-        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(IMAGE_METHODS[:chown], uid, gid)
-        end
-
-        # Changes the Image 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(IMAGE_METHODS[:chmod], octet)
-        end
-
-        # Changes the Image 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(IMAGE_METHODS[:chmod], owner_u, owner_m, owner_a, group_u,
-                group_m, group_a, other_u, other_m, other_a)
-        end
-
-        # Changes the Image type
-        # @param type [String] new Image type
-        # @return [nil, OpenNebula::Error] nil in case of success, Error
-        #   otherwise
-        def chtype(type)
-            return Error.new('ID not defined') if !@pe_id
-
-            rc = @client.call(IMAGE_METHODS[:chtype], @pe_id, type)
-            rc = nil if !OpenNebula.is_error?(rc)
-
-            return rc
-        end
-
-        # Clones this Image into a new one
-        #
-        # @param [String] name for the new Image.
-        #
-        # @return [Integer, OpenNebula::Error] The new Image ID in case
-        #   of success, Error otherwise
-        def clone(name)
-            return Error.new('ID not defined') if !@pe_id
-
-            rc = @client.call(IMAGE_METHODS[:clone], @pe_id, name)
-
-            return rc
-        end
-
-        # Renames this Image
-        #
-        # @param name [String] New name for the Image.
-        #
-        # @return [nil, OpenNebula::Error] nil in case of success, Error
-        #   otherwise
-        def rename(name)
-            return call(IMAGE_METHODS[:rename], @pe_id, name)
-        end
-
-        #######################################################################
-        # Helpers to get Image information
-        #######################################################################
-
-        # Returns the state of the Image (numeric value)
-        def state
-            self['STATE'].to_i
-        end
-
-        # Returns the state of the Image (string value)
-        def state_str
-            IMAGE_STATES[state]
-        end
-
-        # Returns the state of the Image (string value)
-        def short_state_str
-            SHORT_IMAGE_STATES[state_str]
-        end
-
-        # Returns the type of the Image (numeric value)
-        def type
-            self['TYPE'].to_i
-        end
-
-        # Returns the type of the Image (string value)
-        def type_str
-            IMAGE_TYPES[type]
-        end
-
-        # Returns the state of the Image (string value)
-        def short_type_str
-            SHORT_IMAGE_TYPES[type_str]
-        end
-
-        # Returns the group identifier
-        # [return] _Integer_ the element's group ID
-        def gid
-            self['GID'].to_i
-        end
-
-        def public?
-            if self['PERMISSIONS/GROUP_U'] == "1" || self['PERMISSIONS/OTHER_U'] == "1"
-                true
-            else
-                false
-            end
-        end
-
-    private
-
-        def set_enabled(enabled)
-            return Error.new('ID not defined') if !@pe_id
-
-            rc = @client.call(IMAGE_METHODS[:enable], @pe_id, enabled)
-            rc = nil if !OpenNebula.is_error?(rc)
-
-            return rc
-        end
-
-        def set_publish(published)
-            group_u = published ? 1 : 0
-
-            chmod(-1, -1, -1, group_u, -1, -1, -1, -1, -1)
-        end
-
-        def set_persistent(persistence)
-            return Error.new('ID not defined') if !@pe_id
-
-            rc = @client.call(IMAGE_METHODS[:persistent], @pe_id, persistence)
-            rc = nil if !OpenNebula.is_error?(rc)
-
-            return rc
-        end
-    end
-end

data/lib/opennebula/image_pool.rb

@@ -1,74 +0,0 @@
-# -------------------------------------------------------------------------- #
-# 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 ImagePool < Pool
-        #######################################################################
-        # Constants and Class attribute accessors
-        #######################################################################
-
-
-        IMAGE_POOL_METHODS = {
-            :info => "imagepool.info"
-        }
-
-        #######################################################################
-        # Class constructor & Pool Methods
-        #######################################################################
-
-        # +client+ a Client object that represents a XML-RPC connection
-        # +user_id+ is to refer to a Pool with Images from that user
-        def initialize(client, user_id=-1)
-            super('IMAGE_POOL','IMAGE',client)
-
-            @user_id  = user_id
-        end
-
-        # Default Factory Method for the Pools
-        def factory(element_xml)
-            OpenNebula::Image.new(element_xml,@client)
-        end
-
-        #######################################################################
-        # XML-RPC Methods for the Image Object
-        #######################################################################
-
-        # Retrieves all or part of the VirtualMachines in the pool.
-        def info(*args)
-            case args.size
-                when 0
-                    info_filter(IMAGE_POOL_METHODS[:info],@user_id,-1,-1)
-                when 3
-                    info_filter(IMAGE_POOL_METHODS[:info],args[0],args[1],args[2])
-            end
-        end
-
-        def info_all()
-            return super(IMAGE_POOL_METHODS[:info])
-        end
-
-        def info_mine()
-            return super(IMAGE_POOL_METHODS[:info])
-        end
-
-        def info_group()
-            return super(IMAGE_POOL_METHODS[:info])
-        end
-    end
-end

data/lib/opennebula/ldap_auth.rb

@@ -1,99 +0,0 @@
-# ---------------------------------------------------------------------------- #
-# Copyright 2010-2012, C12G Labs S.L                                           #
-#                                                                              #
-# 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 'rubygems'
-require 'net/ldap'
-
-module OpenNebula; end
-
-class OpenNebula::LdapAuth
-    def initialize(options)
-        @options={
-            :host => 'localhost',
-            :port => 389,
-            :user => nil,
-            :password => nil,
-            :base => nil,
-            :auth_method => :simple,
-            :user_field => 'cn'
-        }.merge(options)
-
-        ops={}
-
-        if @options[:user]
-            ops[:auth] = {
-                :method => @options[:auth_method],
-                :username => @options[:user],
-                :password => @options[:password]
-            }
-        end
-
-        ops[:host]=@options[:host] if @options[:host]
-        ops[:port]=@options[:port].to_i if @options[:port]
-        ops[:encryption]=@options[:encryption] if @options[:encryption]
-
-        @ldap=Net::LDAP.new(ops)
-    end
-
-    def find_user(name)
-        begin
-            result=@ldap.search(
-                :base => @options[:base],
-                :filter => "#{@options[:user_field]}=#{name}")
-
-            if result && result.first
-                result.first.dn
-            else
-                result=@ldap.search(:base => name)
-
-                if result && result.first
-                    name
-                else
-                    nil
-                end
-            end
-        rescue
-            nil
-        end
-    end
-
-    def is_in_group?(user, group)
-        result=@ldap.search(:base => group, :filter => "(member=#{user})")
-
-        if result && result.first
-            true
-        else
-            false
-        end
-    end
-
-    def authenticate(user, password)
-        ldap=@ldap.clone
-
-        auth={
-            :method => @options[:auth_method],
-            :username => user,
-            :password => password
-        }
-
-        if ldap.bind(auth)
-            true
-        else
-            false
-        end
-    end
-end
-

data/lib/opennebula/ldap_auth_spec.rb

@@ -1,70 +0,0 @@
-# ---------------------------------------------------------------------------- #
-# Copyright 2010-2012, C12G Labs S.L                                           #
-#                                                                              #
-# 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 'ldap_auth'
-
-options={
-    :host => 'ubuntu-test',
-    :base => 'dc=localdomain'
-}
-
-describe LdapAuth do
-    before(:all) do
-        @ldap=LdapAuth.new(options)
-    end
-
-    it 'should find user dn' do
-        name=@ldap.find_user('user01')
-        name.should=='cn=user01,dc=localdomain'
-
-        name=@ldap.find_user('user02')
-        name.should=='cn=user02,dc=localdomain'
-
-        name=@ldap.find_user('user03')
-        name.should==nil
-
-        name=@ldap.find_user('cn=user01,dc=localdomain')
-        name.should=='cn=user01,dc=localdomain'
-    end
-
-    it 'should tell if a user is in a group' do
-        group='cn=cloud,ou=groups,dc=localdomain'
-
-        result=@ldap.is_in_group?('cn=user01,dc=localdomain', group)
-        result.should==true
-
-        result=@ldap.is_in_group?('cn=user02,dc=localdomain', group)
-        result.should==false
-    end
-
-    it 'should authenticate user' do
-        result=@ldap.authenticate('cn=user01,dc=localdomain', 'password01')
-        result.should==true
-
-        result=@ldap.authenticate('cn=user02,dc=localdomain', 'password02')
-        result.should==true
-
-        result=@ldap.authenticate('cn=user01,dc=localdomain', 'password02')
-        result.should==false
-
-        result=@ldap.authenticate('user01,dc=localdomain', 'password01')
-        result.should==false
-    end
-
-end
-

data/lib/opennebula/pool.rb

@@ -1,157 +0,0 @@
-# -------------------------------------------------------------------------- #
-# 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/xml_utils'
-
-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, *args)
-            return xmlrpc_info(xml_method,INFO_ALL,-1,-1, *args)
-        end
-
-        def info_mine(xml_method, *args)
-            return xmlrpc_info(xml_method,INFO_MINE,-1,-1, *args)
-        end
-
-        def info_group(xml_method, *args)
-            return xmlrpc_info(xml_method,INFO_GROUP,-1,-1, *args)
-        end
-
-        def info_filter(xml_method, who, start_id, end_id, *args)
-            return xmlrpc_info(xml_method,who, start_id, end_id, *args)
-        end
-
-        # Retrieves the monitoring data for all the Objects in the pool
-        #
-        # @param [String] xml_method xml-rcp method
-        # @param [String] root_elem Root for each individual PoolElement
-        # @param [String] timestamp_elem Name of the XML element with the last
-        #   monitorization timestamp
-        # @param [Array<String>] xpath_expressions Elements to retrieve.
-        # @param args arguemnts for the xml_method call
-        #
-        # @return [Hash<String, <Hash<String, Array<Array<int>>>>>,
-        #   OpenNebula::Error] The first level hash uses the Object ID as keys,
-        #   and as value a Hash with the requested xpath expressions,
-        #   and an Array of 'timestamp, value'.
-        def monitoring(xml_method, root_elem, timestamp_elem, xpath_expressions,
-            *args)
-
-            rc = @client.call(xml_method, *args)
-
-            if ( OpenNebula.is_error?(rc) )
-                return rc
-            end
-
-            xmldoc = XMLElement.new
-            xmldoc.initialize_xml(rc, 'MONITORING_DATA')
-
-            hash = {}
-
-            # Get all existing Object IDs
-            ids = xmldoc.retrieve_elements("#{root_elem}/ID")
-
-            if ids.nil?
-                return hash
-            else
-                ids.uniq!
-            end
-
-            ids.each { |id|
-                hash[id] = OpenNebula.process_monitoring(
-                    xmldoc, root_elem, timestamp_elem, id, xpath_expressions)
-
-            }
-
-            return hash
-        end
-
-    private
-        # 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
-end