opennebula-oca 3.9.0.beta → 3.9.90.rc

data/lib/opennebula/pool_element.rb

@@ -1,269 +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
-    # 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
-        #######################################################################
-
-        # Common client call wrapper. Checks that @pe_id is defined, and
-        # returns nil instead of the response if it is successful
-        #
-        # @param [String] xml_method xml-rpc method
-        # @param [Array] args any arguments for the xml-rpc method
-        #
-        # @return [nil, OpenNebula::Error] nil in case of success, Error
-        #   otherwise
-        def call(xml_method, *args)
-            return Error.new('ID not defined') if !@pe_id
-
-            rc = @client.call(xml_method, *args)
-            rc = nil if !OpenNebula.is_error?(rc)
-
-            return rc
-        end
-
-        # Calls to the corresponding info method to retreive the element
-        # detailed information in XML format
-        #
-        # @param [String] xml_method the name of the XML-RPC method
-        # @param [String] root_element Base XML element name
-        # @param [Array] args additional arguments
-        #
-        # @return [nil, OpenNebula::Error] nil in case of success, Error
-        #   otherwise
-        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
-        #
-        # @param [String] xml_method the name of the XML-RPC method
-        # @param [Array] args any extra arguments for the xml-rpc method
-        #
-        # @return [nil, OpenNebula::Error] nil in case of success, Error
-        #   otherwise
-        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
-        #
-        # @param [String] xml_method the name of the XML-RPC method
-        # @param [String] new_template the new template contents
-        # @param [Array] args any extra arguments for the xml-rpc method
-        #
-        # @return [nil, OpenNebula::Error] nil in case of success, Error
-        #   otherwise
-        def update(xml_method, new_template, *args)
-            new_template ||= template_xml
-
-            return call(xml_method, @pe_id, new_template, *args)
-        end
-
-        # Calls to the corresponding delete method to remove this element
-        # from the OpenNebula core
-        #
-        # @param [String] xml_method the name of the XML-RPC method
-        #
-        # @return [nil, OpenNebula::Error] nil in case of success, Error
-        #   otherwise
-        def delete(xml_method)
-            return call(xml_method,@pe_id)
-        end
-
-        # Calls to the corresponding chown method to modify
-        # the object's owner and group
-        #
-        # @param [String] xml_method the name of the XML-RPC method
-        # @param [Integer] uid the new owner id. Set to -1 to leave the current one
-        # @param [Integer] gid the new goup id. Set to -1 to leave the current one
-        #
-        # @return [nil, OpenNebula::Error] nil in case of success, Error
-        #   otherwise
-        def chown(xml_method, uid, gid)
-            return call(xml_method, @pe_id, uid, gid)
-        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 call(xml_method, @pe_id, owner_u, owner_m,
-                            owner_a, group_u, group_m, group_a, other_u,
-                            other_m, other_a)
-        end
-
-
-        # Retrieves this Element's monitoring data from OpenNebula
-        #
-        # @param [String] xml_method the name of the XML-RPC 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 xpath_expressions [Array<String>] Xpath expressions for the
-        #   elements to retrieve.
-        #
-        # @return [Hash<String, Array<Array<int>>, OpenNebula::Error] Hash with
-        #   the requested xpath expressions, and an Array of [timestamp, value].
-        def monitoring(xml_method, root_elem, timestamp_elem, xpath_expressions)
-            return Error.new('ID not defined') if !@pe_id
-
-            rc = @client.call(xml_method, @pe_id)
-
-            if ( OpenNebula.is_error?(rc) )
-                return rc
-            end
-
-            xmldoc = XMLElement.new
-            xmldoc.initialize_xml(rc, 'MONITORING_DATA')
-
-
-            return OpenNebula.process_monitoring(
-                xmldoc, root_elem, timestamp_elem, @pe_id, xpath_expressions)
-        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
-
-    # Processes the monitoring data in XML returned by OpenNebula
-    #
-    # @param [XMLElement] xmldoc monitoring data returned by OpenNebula
-    # @param [String] root_elem Root for each individual PoolElement
-    # @param [String] timestamp_elem Name of the XML element with the last
-    #   monitorization timestamp
-    # @param [Integer] Id of the object to process
-    # @param [Array<String>] xpath_expressions Elements to retrieve.
-    # @param args arguemnts for the xml_method call
-    #
-    # @return [Hash<String, Array<Array<int>>, OpenNebula::Error] Hash with
-    #   the requested xpath expressions, and an Array of [timestamp, value].
-    def self.process_monitoring(xmldoc, root_elem, timestamp_elem, oid, xpath_expressions)
-        hash = {}
-        timestamps = xmldoc.retrieve_elements(
-            "#{root_elem}[ID=#{oid}]/#{timestamp_elem}")
-
-        xpath_expressions.each { |xpath|
-            xpath_values = xmldoc.retrieve_elements("#{root_elem}[ID=#{oid}]/#{xpath}")
-
-            if ( xpath_values.nil? )
-                hash[xpath] = []
-            else
-                hash[xpath] = timestamps.zip(xpath_values)
-            end
-        }
-
-        return hash
-    end
-end

data/lib/opennebula/server_cipher_auth.rb

@@ -1,148 +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 'openssl'
-require 'digest/sha1'
-
-require 'base64'
-require 'fileutils'
-
-module OpenNebula; end
-
-# Server authentication class. This method can be used by OpenNebula services
-# to let access authenticated users by other means. It is based on OpenSSL 
-# symmetric ciphers
-class OpenNebula::ServerCipherAuth 
-    ###########################################################################
-    #Constants with paths to relevant files and defaults
-    ###########################################################################
-
-    CIPHER = "aes-256-cbc"
-
-    ###########################################################################
-
-    def initialize(srv_user, srv_passwd)
-        @srv_user   = srv_user
-        @srv_passwd = srv_passwd 
-
-        if !srv_passwd.empty?
-            @key = Digest::SHA1.hexdigest(@srv_passwd)
-        else
-            @key = ""
-        end
-
-        @cipher = OpenSSL::Cipher::Cipher.new(CIPHER)
-    end
-
-    ###########################################################################
-    # Client side
-    ###########################################################################
-
-    # Creates a ServerCipher for client usage
-    def self.new_client(srv_user=nil, srv_passwd=nil)
-        if ( srv_user == nil || srv_passwd == nil ) 
-            begin
-                if ENV["ONE_CIPHER_AUTH"] and !ENV["ONE_CIPHER_AUTH"].empty?
-                    one_auth = File.read(ENV["ONE_CIPHER_AUTH"])
-                else
-                    raise "ONE_CIPHER_AUTH environment variable not set"
-                end
-
-                one_auth.rstrip!
-
-                rc =  one_auth.match(/(.*?):(.*)/)
-                
-                if rc.nil?
-                    raise "Bad format for one_auth token (<user>:<passwd>)"
-                else 
-                    srv_user   = rc[1]
-                    srv_passwd = rc[2]
-                end
-            rescue => e
-                raise e.message
-            end
-        end 
-
-        self.new(srv_user, srv_passwd)
-    end
-
-    # Generates a login token in the form:
-    #   - server_user:target_user:time_expires 
-    # The token is then encrypted with the contents of one_auth
-    def login_token(expire, target_user=nil)
-        target_user ||= @srv_user
-        token_txt   =   "#{@srv_user}:#{target_user}:#{expire}"
-
-        token   = encrypt(token_txt)
-        token64 = Base64::encode64(token).strip.delete("\n")
-
-        return "#{@srv_user}:#{target_user}:#{token64}"
-    end
-
-    # Returns a valid password string to create a user using this auth driver
-    def password
-        return @srv_passwd
-    end
-
-    ###########################################################################
-    # Driver side
-    ###########################################################################
-
-    # Creates a ServerCipher for driver usage
-    def self.new_driver()
-        self.new("","")
-    end
-
-    # auth method for auth_mad
-    def authenticate(srv_user,srv_pass, signed_text)
-        begin
-            @key = srv_pass
-            
-            s_user, t_user, expires = decrypt(signed_text).split(':')
-
-            return "User name missmatch" if s_user != srv_user
-             
-            return "login token expired" if Time.now.to_i >= expires.to_i
-
-            return true
-        rescue => e
-            return e.message
-        end
-    end
-
-    private
-
-    def encrypt(data) 
-        @cipher.encrypt
-        @cipher.key = @key
-        
-        rc = @cipher.update(data)
-        rc << @cipher.final
-
-        return rc
-    end
-
-    def decrypt(data) 
-        @cipher.decrypt
-        @cipher.key = @key
-        
-        rc = @cipher.update(Base64::decode64(data))
-        rc << @cipher.final
-
-        return rc
-    end
-end
-

data/lib/opennebula/server_x509_auth.rb

@@ -1,104 +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 'openssl'
-require 'base64'
-require 'fileutils'
-
-require 'opennebula/x509_auth'
-
-module OpenNebula; end
-
-# Server authentication class. This authmethod can be used by opennebula services
-# to let access authenticated users by other means. It is based on x509 server
-# certificates
-class OpenNebula::ServerX509Auth < OpenNebula::X509Auth
-    ###########################################################################
-    #Constants with paths to relevant files and defaults
-    ###########################################################################
-
-    SERVER_AUTH_CONF_PATH = ETC_LOCATION + "/auth/server_x509_auth.conf"
-
-    SERVER_DEFAULTS = {
-        :one_cert => ETC_LOCATION + "/auth/cert.pem",
-        :one_key  => ETC_LOCATION + "/auth/key.pem"
-    }
-
-    ###########################################################################
-
-    def initialize()
-        @options = SERVER_DEFAULTS
-
-        load_options(SERVER_AUTH_CONF_PATH)
-
-        begin
-            certs = [ File.read(@options[:one_cert]) ]
-            key   =   File.read(@options[:one_key])
-
-            super(:certs_pem => certs, :key_pem => key)
-        rescue
-            raise
-        end
-
-        if @options[:srv_user] == nil || @options[:srv_user].empty?
-           raise "User for x509 server not defined"
-        end
-    end
-
-    ###########################################################################
-    # Client side
-    ###########################################################################
-
-    # Creates a ServerCipher for client and driver sage
-    class << OpenNebula::ServerX509Auth
-        alias :new_client :new
-        alias :new_driver :new
-    end
-
-    # Generates a login token in the form:
-    #   - server_user:target_user:time_expires
-    def login_token(expire, target_user=nil)
-        target_user ||= @options[:srv_user]
-        token_txt   =   "#{@options[:srv_user]}:#{target_user}:#{expire}"
-
-        token   = encrypt(token_txt)
-        token64 = Base64::encode64(token).strip.delete("\n")
-
-        return "#{@options[:srv_user]}:#{target_user}:#{token64}"
-    end
-
-    ###########################################################################
-    # Server side
-    ###########################################################################
-
-    # auth method for auth_mad
-    def authenticate(server_user, server_pass, signed_text)
-        begin
-            s_user, t_user, expires = decrypt(signed_text).split(':')
-
-            return "Server password missmatch" if server_pass != password
-
-            return "User name missmatch" if ( s_user != server_user ||
-                                              s_user != @options[:srv_user] )
-
-            return "login token expired" if Time.now.to_i >= expires.to_i
-
-            return true
-        rescue => e
-            return e.message
-        end
-    end
-end

data/lib/opennebula/ssh_auth.rb

@@ -1,139 +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 'pp'
-require 'openssl'
-require 'base64'
-require 'fileutils'
-
-module OpenNebula; end
-
-# SSH key authentication class. It can be used as a driver for auth_mad
-# as auth method is defined. It also holds some helper methods to be used
-# by oneauth command
-class OpenNebula::SshAuth
-    LOGIN_PATH = ENV['HOME']+'/.one/one_ssh'
-
-    # Initialize SshAuth object
-    #
-    # @param [Hash] default options for path
-    # @option options [String] :public_key public key for the user
-    # @option options [String] :private_key key private key for the user.
-    def initialize(options={})
-        @private_key = nil
-        @public_key  = nil
-
-        if options[:private_key]
-            begin
-                @private_key = File.read(options[:private_key])
-            rescue Exception => e
-                raise "Cannot read #{options[:private_key]}"
-            end
-        end
-
-        if options[:public_key]
-            @public_key = options[:public_key]
-        elsif @private_key != nil
-            # Init ssh keys using private key. public key is extracted in a
-            # format compatible with openssl. The public key does not contain
-            # "---- BEGIN/END RSA PUBLIC KEY ----" and is in a single line
-            key = OpenSSL::PKey::RSA.new(@private_key)
-
-            @public_key = key.public_key.to_pem.split("\n")
-            @public_key = @public_key.reject {|l| l.match(/RSA PUBLIC KEY/) }.join('')
-        end
-
-        if @private_key.nil? && @public_key.nil?
-            raise "You have to define at least one of the keys"
-        end
-    end
-
-    # Creates the login file for ssh authentication at ~/.one/one_ssh.
-    # By default it is valid for 1 hour but it can be changed to any number
-    # of seconds with expire parameter (in seconds)
-    def login(user, expire=3600)
-        expire ||= 3600
-
-        # Init proxy file path and creates ~/.one directory if needed
-        proxy_dir = File.dirname(LOGIN_PATH)
-
-        begin
-            FileUtils.mkdir_p(proxy_dir)
-        rescue Errno::EEXIST
-        end
-
-        # Generate security token
-        time = Time.now.to_i + expire.to_i
-
-        secret_plain   = "#{user}:#{time}"
-        secret_crypted = encrypt(secret_plain)
-
-        proxy = "#{user}:#{secret_crypted}"
-
-        file = File.open(LOGIN_PATH, "w")
-        file.write(proxy)
-        file.close
-
-        File.chmod(0600,LOGIN_PATH)
-        
-        secret_crypted
-    end
-
-    # Returns a valid password string to create a user using this auth driver.
-    # In this case the ssh public key.
-    def password
-        @public_key
-    end
-
-    # Checks the proxy created with the login method
-    def authenticate(user, token)
-        begin
-            token_plain = decrypt(token)
-            _user, time = token_plain.split(':')
-
-            if user == _user
-                if Time.now.to_i >= time.to_i
-                    return "ssh proxy expired, login again to renew it"
-                else
-                    return true
-                end
-            else
-                return "invalid credentials"
-            end
-        rescue
-            return "error"
-        end
-    end
-
-    private
-
-    ###########################################################################
-    #                       Methods to handle ssh keys
-    ###########################################################################
-    # Encrypts data with the private key of the user and returns
-    # base 64 encoded output in a single line
-    def encrypt(data)
-        rsa=OpenSSL::PKey::RSA.new(@private_key)
-        Base64::encode64(rsa.private_encrypt(data)).gsub!(/\n/, '').strip
-    end
-
-    # Decrypts base 64 encoded data with pub_key (public key)
-    def decrypt(data)
-        rsa=OpenSSL::PKey::RSA.new(Base64::decode64(@public_key))
-        rsa.public_decrypt(Base64::decode64(data))
-    end
-end