opennebula 6.6.2 → 6.7.80.pre

data/lib/opennebula/oneflow_client.rb

@@ -21,6 +21,7 @@ require 'cloud/CloudClient'
 include CloudCLI
 
 module Role
+
     # Actions that can be performed on the VMs of a given Role
     SCHEDULE_ACTIONS = [
         'terminate',
@@ -78,8 +79,9 @@ module Role
     # @param [String] state String number representing the state
     # @return the state string
     def self.state_str(state_number)
-        return STATE_STR[state_number.to_i]
+        STATE_STR[state_number.to_i]
     end
+
 end
 
 module Service
@@ -126,19 +128,19 @@ module Service
     # @param [String] state String number representing the state
     # @return the state string
     def self.state_str(state_number)
-        return STATE_STR[state_number.to_i]
+        STATE_STR[state_number.to_i]
     end
 
     # Build a json specifying an action
     # @param [String] perform action to be performed (e.g.: shutdown)
     # @param [Hash, nil] params contains the params for the action
     # @return [String] json representing the action
-    def self.build_json_action(perform, params=nil)
-        body = Hash.new
+    def self.build_json_action(perform, params = nil)
+        body = {}
         body['perform'] = perform
         body['params']  = params if params
 
-        action = Hash.new
+        action = {}
         action['action'] = body
 
         JSON.pretty_generate action
@@ -148,83 +150,83 @@ module Service
 
     DEFAULT_OPTIONS = [
         ENDPOINT = {
-            :name => "server",
-            :short => "-s url",
-            :large => "--server url",
+            :name => 'server',
+            :short => '-s url',
+            :large => '--server url',
             :format => String,
-            :description => "Service endpoint"
+            :description => 'Service endpoint'
         },
         USERNAME={
-            :name => "username",
-            :short => "-u name",
-            :large => "--username name",
+            :name => 'username',
+            :short => '-u name',
+            :large => '--username name',
             :format => String,
-            :description => "User name"
+            :description => 'User name'
         },
         PASSWORD={
-            :name => "password",
-            :short => "-p pass",
-            :large => "--password pass",
+            :name => 'password',
+            :short => '-p pass',
+            :large => '--password pass',
             :format => String,
-            :description => "User password"
+            :description => 'User password'
         }
     ]
 
     JSON_FORMAT = {
-        :name => "json",
-        :short => "-j",
-        :large => "--json",
-        :description => "Print the resource in JSON"
+        :name => 'json',
+        :short => '-j',
+        :large => '--json',
+        :description => 'Print the resource in JSON'
     }
 
     TOP = {
-        :name => "top",
-        :short => "-t",
-        :large => "--top",
-        :description => "Top for the command"
+        :name => 'top',
+        :short => '-t',
+        :large => '--top',
+        :description => 'Top for the command'
     }
 
     PERIOD = {
-        :name => "period",
-        :short => "-p x",
-        :large => "--period x",
+        :name => 'period',
+        :short => '-p x',
+        :large => '--period x',
         :format => Integer,
-        :description => "Seconds between each group of actions"
+        :description => 'Seconds between each group of actions'
     }
 
     NUMBER = {
-        :name => "number",
-        :short => "-n x",
-        :large => "--number x",
+        :name => 'number',
+        :short => '-n x',
+        :large => '--number x',
         :format => Integer,
-        :description => "Number of VMs to apply the action to each period"
+        :description => 'Number of VMs to apply the action to each period'
     }
 
     FORCE = {
-        :name => "force",
-        :short => "-f",
-        :large => "--force",
-        :description => "Force the new cardinality even if it is outside the limits"
+        :name => 'force',
+        :short => '-f',
+        :large => '--force',
+        :description => 'Force the new cardinality even if it is outside the limits'
     }
 
     # Format helpers
 
-#    def self.rname_to_id(name, poolname, options)
+    #    def self.rname_to_id(name, poolname, options)
     def self.rname_to_id(name, poolname)
         return 0, name.to_i if name.match(/^[0123456789]+$/)
 
-        client = Service::Client.new()
+        client = Service::Client.new
 
         resource_path = case poolname
-        when "SERVICE"          then "/service"
-        when "SERVICE TEMPLATE" then "/service_template"
-        end
+                        when 'SERVICE'          then '/service'
+                        when 'SERVICE TEMPLATE' then '/service_template'
+                        end
 
         response = client.get(resource_path)
 
-        if CloudClient::is_error?(response)
+        if CloudClient.is_error?(response)
             return -1, "OpenNebula #{poolname} name not found," <<
-                       " use the ID instead"
+                       ' use the ID instead'
         end
 
         pool = JSON.parse(response.body)
@@ -242,38 +244,32 @@ module Service
 
         objects = pool['DOCUMENT_POOL']['DOCUMENT'].select {|object| object['NAME'] == name }
 
-        if objects.length>0
-            if objects.length>1
-                return -1, "There are multiple #{ename}s with name #{name}."
-            else
-                result = objects.first['ID']
-            end
-        else
-            return -1, "#{ename} named #{name} not found."
-        end
+        return -1, "#{ename} named #{name} not found." unless objects.length>0
+        return -1, "There are multiple #{ename}s with name #{name}." if objects.length>1
+
+        result = objects.first['ID']
 
-        return 0, result
+        [0, result]
     end
 
     def self.list_to_id(names, poolname)
-
-        client = Service::Client.new()
+        client = Service::Client.new
 
         resource_path = case poolname
-        when "SERVICE"          then "/service"
-        when "SERVICE TEMPLATE" then "/service_template"
-        end
+                        when 'SERVICE'          then '/service'
+                        when 'SERVICE TEMPLATE' then '/service_template'
+                        end
 
         response = client.get(resource_path)
 
-        if CloudClient::is_error?(response)
+        if CloudClient.is_error?(response)
             return -1, "OpenNebula #{poolname} name not found," <<
-                       " use the ID instead"
+                       ' use the ID instead'
         end
 
         pool = JSON.parse(response.body)
 
-        result = names.split(',').collect { |name|
+        result = names.split(',').collect do |name|
             if name.match(/^[0123456789]+$/)
                 name.to_i
             else
@@ -285,9 +281,9 @@ module Service
 
                 rc[1]
             end
-        }
+        end
 
-        return 0, result
+        [0, result]
     end
 
     def self.list_to_id_desc(poolname)
@@ -304,8 +300,8 @@ module Service
         ids.each do |id|
             response = block.call(id) if block_given?
 
-            if CloudClient::is_error?(response)
-                puts response.to_s
+            if CloudClient.is_error?(response)
+                puts response
                 exit_code = response.code.to_i
             end
         end
@@ -321,16 +317,29 @@ module Service
         exit_code = 0
         response  = block.call(id) if block_given?
 
-        if CloudClient::is_error?(response)
-            puts response.to_s
+        if CloudClient.is_error?(response)
+            puts response
             exit_code = response.code.to_i
         end
 
         exit_code
     end
 
+    #
+    # Interface to OneFlow REST API through a Ruby client
+    #
     class Client
-        def initialize(opts={})
+
+        #
+        # The options are read from ENV and FS if not passed
+        #
+        # @param [Hash] opts Required configuration to interact with OneFlow
+        # @option opts [String] :url Endpoint where OneFlow is running. Defaults to 'http://localhost:2474'
+        # @option opts [String] :username OpenNebula user
+        # @option opts [String] :password OpenNebula user password
+        # @option opts [String] :user_agent Defaults to Ruby. Oneflow will behave accordingly.
+        #
+        def initialize(opts = {})
             endpoint  = '/.one/oneflow_endpoint'
             @username = opts[:username] || ENV['ONEFLOW_USER']
             @password = opts[:password] || ENV['ONEFLOW_PASSWORD']
@@ -339,23 +348,23 @@ module Service
                 url = opts[:url]
             elsif ENV['ONEFLOW_URL']
                 url = ENV['ONEFLOW_URL']
-            elsif ENV['HOME'] && File.exists?(ENV['HOME'] + endpoint)
+            elsif ENV['HOME'] && File.exist?(ENV['HOME'] + endpoint)
                 url = File.read(ENV['HOME'] + endpoint).strip
-            elsif File.exists?('/var/lib/one/.one/oneflow_endpoint')
+            elsif File.exist?('/var/lib/one/.one/oneflow_endpoint')
                 url = File.read('/var/lib/one/.one/oneflow_endpoint').strip
             else
                 url = 'http://localhost:2474'
             end
 
             if @username.nil? && @password.nil?
-                if ENV["ONE_AUTH"] and !ENV["ONE_AUTH"].empty? and File.file?(ENV["ONE_AUTH"])
-                    one_auth = File.read(ENV["ONE_AUTH"])
-                elsif ENV["HOME"] and File.file?(ENV["HOME"]+"/.one/one_auth")
-                    one_auth = File.read(ENV["HOME"]+"/.one/one_auth")
-                elsif File.file?("/var/lib/one/.one/one_auth")
-                    one_auth = File.read("/var/lib/one/.one/one_auth")
+                if ENV['ONE_AUTH'] and !ENV['ONE_AUTH'].empty? and File.file?(ENV['ONE_AUTH'])
+                    one_auth = File.read(ENV['ONE_AUTH'])
+                elsif ENV['HOME'] and File.file?(ENV['HOME']+'/.one/one_auth')
+                    one_auth = File.read(ENV['HOME']+'/.one/one_auth')
+                elsif File.file?('/var/lib/one/.one/one_auth')
+                    one_auth = File.read('/var/lib/one/.one/one_auth')
                 else
-                    raise "ONE_AUTH file not present"
+                    raise 'ONE_AUTH file not present'
                 end
 
                 one_auth = one_auth.rstrip
@@ -366,37 +375,37 @@ module Service
             @uri = URI.parse(url)
 
             @user_agent = "OpenNebula #{CloudClient::VERSION} " <<
-                "(#{opts[:user_agent]||"Ruby"})"
+                "(#{opts[:user_agent]||'Ruby'})"
 
             @host = nil
             @port = nil
 
-            if ENV['http_proxy']
-                uri_proxy  = URI.parse(ENV['http_proxy'])
-                flag = false
-
-                # Check if we need to bypass the proxy
-                if ENV['no_proxy']
-                    ENV['no_proxy'].split(',').each do |item|
-                        item = item.rstrip.lstrip
-
-                        unless (IPAddress @uri.host rescue nil).nil?
-                            unless (IPAddress item rescue nil).nil?
-                                flag |= IPAddress(item).include? IPAddress(@uri.host)
-                            end
-                        else
-                            if (IPAddress(item) rescue nil).nil?
-                                flag |= (item == @uri.host)
-                            end
+            return unless ENV['http_proxy']
+
+            uri_proxy = URI.parse(ENV['http_proxy'])
+            flag = false
+
+            #  Check if we need to bypass the proxy
+            if ENV['no_proxy']
+                ENV['no_proxy'].split(',').each do |item|
+                    item = item.strip
+
+                    if (IPAddress @uri.host rescue nil).nil?
+                        if (IPAddress(item) rescue nil).nil?
+                            flag |= (item == @uri.host)
+                        end
+                    else
+                        unless (IPAddress item rescue nil).nil?
+                            flag |= IPAddress(item).include? IPAddress(@uri.host)
                         end
                     end
                 end
-
-                unless flag
-                    @host = uri_proxy.host
-                    @port = uri_proxy.port
-                end
             end
+
+            return if flag
+
+            @host = uri_proxy.host
+            @port = uri_proxy.port
         end
 
         def set_content_type(content_type)
@@ -420,10 +429,8 @@ module Service
             req = Net::HTTP::Proxy(@host, @port)::Post.new(path)
             req.body = body
 
-            if path.start_with?('/service_template')
-                unless @content_type.nil?
-                    req.content_type = @content_type
-                end
+            if path.start_with?('/service_template') && !@content_type.nil?
+                req.content_type = @content_type
             end
             do_request(req)
         end
@@ -454,11 +461,11 @@ module Service
 
             req['User-Agent'] = @user_agent
 
-            res = CloudClient::http_start(@uri, @timeout) do |http|
+            CloudClient.http_start(@uri, @timeout) do |http|
                 http.request(req)
             end
-
-            res
         end
+
     end
+
 end

data/lib/opennebula/pool_element.rb

@@ -17,11 +17,13 @@
 require 'opennebula/pool'
 
 module OpenNebula
+
     # The PoolElement Class represents a generic element of a Pool in
     # XML format
     class PoolElement < XMLElement
 
-    protected
+        protected
+
         # node:: _XML_is a XML element that represents the Pool element
         # client:: _Client_ represents a XML-RPC connection
         def initialize(node, client)
@@ -49,12 +51,12 @@ module OpenNebula
         # @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
+            return Error.new('ID not defined') unless @pe_id
 
             rc = @client.call(xml_method, *args)
-            rc = nil if !OpenNebula.is_error?(rc)
+            rc = nil unless OpenNebula.is_error?(rc)
 
-            return rc
+            rc
         end
 
         # Calls to the corresponding info method to retreive the element
@@ -66,19 +68,19 @@ module OpenNebula
         # @return [nil, OpenNebula::Error] nil in case of success, Error
         #   otherwise
         def info(xml_method, root_element, decrypt = false)
-            return Error.new('ID not defined') if !@pe_id
+            return Error.new('ID not defined') unless @pe_id
 
             rc = @client.call(xml_method, @pe_id, decrypt)
 
             if !OpenNebula.is_error?(rc)
                 initialize_xml(rc, root_element)
-                rc   = nil
+                rc = nil
 
                 @pe_id = self['ID'].to_i if self['ID']
                 @name  = self['NAME'] if self['NAME']
             end
 
-            return rc
+            rc
         end
 
         # Calls to the corresponding allocate method to create a new element
@@ -97,7 +99,7 @@ module OpenNebula
                 rc     = nil
             end
 
-            return rc
+            rc
         end
 
         # Calls to the corresponding update method to modify
@@ -111,10 +113,10 @@ module OpenNebula
         #   otherwise
         def update(xml_method, new_template, *args)
             if new_template.nil?
-                return Error.new("Wrong argument", Error::EXML_RPC_CALL)
+                return Error.new('Wrong argument', Error::EXML_RPC_CALL)
             end
 
-            return call(xml_method, @pe_id, new_template, *args)
+            call(xml_method, @pe_id, new_template, *args)
         end
 
         # Calls to the corresponding delete method to remove this element
@@ -125,7 +127,7 @@ module OpenNebula
         # @return [nil, OpenNebula::Error] nil in case of success, Error
         #   otherwise
         def delete(xml_method)
-            return call(xml_method,@pe_id)
+            call(xml_method, @pe_id)
         end
 
         # Calls to the corresponding chown method to modify
@@ -138,7 +140,7 @@ module OpenNebula
         # @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)
+            call(xml_method, @pe_id, uid, gid)
         end
 
         # Calls to the corresponding chmod method to modify
@@ -149,7 +151,7 @@ module OpenNebula
         #
         # @return [nil, OpenNebula::Error] nil in case of success, Error
         #   otherwise
-        def chmod_octet(xml_method, octet)
+        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
@@ -161,7 +163,7 @@ module OpenNebula
             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)
+                  other_m, other_a)
         end
 
         # Calls to the corresponding chmod method to modify
@@ -173,13 +175,12 @@ module OpenNebula
         # @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)
+                  other_m, other_a)
+            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
@@ -189,28 +190,27 @@ module OpenNebula
         # @return [Hash<String, Array<Array<int>>, OpenNebula::Error] Hash with
         #   the requested xpath expressions, and an Array of [timestamp, value].
         def monitoring(xml_method, xpaths)
-            return Error.new('ID not defined') if !@pe_id
+            return Error.new('ID not defined') unless @pe_id
 
             rc = @client.call(xml_method, @pe_id)
 
-            if ( OpenNebula.is_error?(rc) )
+            if OpenNebula.is_error?(rc)
                 return rc
             end
 
             xmldoc = XMLElement.new
             xmldoc.initialize_xml(rc, 'MONITORING_DATA')
 
-
-            return OpenNebula.process_monitoring(xmldoc, @pe_id, xpaths)
+            OpenNebula.process_monitoring(xmldoc, @pe_id, xpaths)
         end
 
-    public
+        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)
+        def self.new_with_id(id, client = nil)
+            new(build_xml(id), client)
         end
 
         # Returns element identifier
@@ -221,16 +221,14 @@ module OpenNebula
 
         # Gets element name
         # [return] _String_ the PoolElement name
-        def name
-            @name
-        end
+        attr_reader :name
 
         # DO NOT USE - ONLY REXML BACKEND
         def to_str
-            str = ""
-            REXML::Formatters::Pretty.new(1).write(@xml,str)
+            str = ''
+            REXML::Formatters::Pretty.new(1).write(@xml, str)
 
-            return str
+            str
         end
 
         # Replace the xml pointed by xpath using  a Hash object
@@ -240,18 +238,19 @@ module OpenNebula
         # @param [Hash] options object containing pair key-value
         #
         # @returns the new xml representation
-        def replace(opts, xpath = "TEMPLATE")
-            if self[xpath]
-                opts.each do |att, value|
-                    xpath_u = xpath+"/#{att}"
-                    docs = retrieve_xmlelements(xpath_u)
-                    if docs.size == 1
-                        docs[0].set_content(value)
-                    end
+        def replace(opts, xpath = 'TEMPLATE')
+            return unless self[xpath]
+
+            opts.each do |att, value|
+                xpath_u = xpath+"/#{att}"
+                docs = retrieve_xmlelements(xpath_u)
+                if docs.size == 1
+                    docs[0].set_content(value)
                 end
-                update(template_like_str(xpath))
             end
+            update(template_like_str(xpath))
         end
+
     end
 
     # Processes the monitoring data in XML returned by OpenNebula
@@ -266,20 +265,22 @@ module OpenNebula
     def self.process_monitoring(xmldoc, oid, xpath_expressions)
         hash = {}
         timestamps = xmldoc.retrieve_elements(
-            "/MONITORING_DATA/MONITORING[ID=#{oid}]/TIMESTAMP")
+            "/MONITORING_DATA/MONITORING[ID=#{oid}]/TIMESTAMP"
+        )
 
-        xpath_expressions.each { |xpath|
+        xpath_expressions.each do |xpath|
             xpath_values = xmldoc.retrieve_elements(
-                "/MONITORING_DATA/MONITORING[ID=#{oid}]/#{xpath}")
+                "/MONITORING_DATA/MONITORING[ID=#{oid}]/#{xpath}"
+            )
 
-            if ( xpath_values.nil? )
+            if xpath_values.nil?
                 hash[xpath] = []
             else
                 hash[xpath] = timestamps.zip(xpath_values)
             end
-        }
+        end
 
-        return hash
+        hash
     end
 
 end