opennebula 5.0.2 → 5.1.80.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0b3f5a3432e11308e671bec5f860d0ffe8ff9681
-  data.tar.gz: 0cbc97bfb8280440743319d12ef1a2db9a05bd49
+  metadata.gz: bce5ec2f4c8ec1633421f1998e9a659a3b712fe2
+  data.tar.gz: 75718ab515a32acc13a5f931836a7a77a02c6ce4
 SHA512:
-  metadata.gz: ccfbb4c8dfd7d67bfe64e3049b50c2885b193cf74ca6693d618dce9af6632e5d27e5b6f30ad11864bcafb68dcfd9a52d525cfb6ac38146f23a5468271df4f0bd
-  data.tar.gz: d7ef9a12c93613878d1d0f9431ccbeeabdb9d8cf92fe4585b84e1db69c07c08ad1b96e7cd0ff828e77efd62445b6df23096559a25ad2e949562fbca731b92b84
+  metadata.gz: c69828852d920460e330c553ce20fd3f71e9450d5702576e4e800bbf12fbde0d273b8d7d03e4dd62c34971ba0c131d6e3fea21afc550de6a71794796f00d97d7
+  data.tar.gz: 23be93fa25689ce1d05d920a420cd3f766a47594a7f60d152539b3f013b953444357f8ebd01cdb8c6f0bbaa79c1186ad9beec04cea773c2ca4ee9b00b5c4a495

data/lib/CommandManager.rb

@@ -17,6 +17,7 @@
 require 'pp'
 require 'open3'
 require 'stringio'
+require 'timeout'
 
 # Generic command executor that holds the code shared by all the command
 # executors.
@@ -42,11 +43,14 @@ require 'stringio'
 
 
 class GenericCommand
+    ERROR_OPEN  = "ERROR MESSAGE --8<------"
+    ERROR_CLOSE = "ERROR MESSAGE ------>8--"
+
     attr_reader :code, :stdout, :stderr, :command
 
     # Creates a command and runs it
-    def self.run(command, logger=nil, stdin=nil)
-        cmd = self.new(command, logger, stdin)
+    def self.run(command, logger=nil, stdin=nil, timeout=nil)
+        cmd = self.new(command, logger, stdin, timeout)
         cmd.run
         cmd
     end
@@ -54,39 +58,72 @@ class GenericCommand
     # Creates the new command:
     # +command+: string with the command to be executed
     # +logger+: proc that takes a message parameter and logs it
-    def initialize(command, logger=nil, stdin=nil)
+    def initialize(command, logger=nil, stdin=nil, timeout=nil)
         @command = command
         @logger  = logger
         @stdin   = stdin
+        @timeout = timeout
     end
 
     # Sends a log message to the logger proc
-    def log(message)
-        @logger.call(message) if @logger
+    def log(message, all=true)
+        @logger.call(message, all) if @logger
+    end
+
+    def kill(pid)
+        # executed processes now have its own process group to be able
+        # to kill all children
+        pgid = Process.getpgid(pid)
+
+        # Kill all processes belonging to process group
+        Process.kill("HUP", pgid * -1)
     end
 
     # Runs the command
     def run
-        std = execute
+        std = nil
+        process = Proc.new do
+            std = execute
+
+            # Close standard IO descriptors
+            if @stdin
+                std[0] << @stdin
+                std[0].flush
+            end
+            std[0].close if !std[0].closed?
 
-        # Close standard IO descriptors
-        if @stdin
-            std[0] << @stdin
-            std[0].flush
+            @stdout=std[1].read
+            std[1].close if !std[1].closed?
+
+            @stderr=std[2].read
+            std[2].close if !std[2].closed?
+
+            @code=get_exit_code(@stderr)
+
+            if @code!=0
+                log("Command execution fail: #{command}")
+                log(@stderr)
+            end
         end
-        std[0].close if !std[0].closed?
 
-        @stdout=std[1].read
-        std[1].close if !std[1].closed?
+        begin
+            if @timeout
+                Timeout.timeout(@timeout, nil, &process)
+            else
+                process.call
+            end
+        rescue Timeout::Error
+            error_message = "Timeout executing #{command}"
+            log(error_message)
+
+            @stderr = ERROR_OPEN + "\n" + error_message + "\n" + ERROR_CLOSE
 
-        @stderr=std[2].read
-        std[2].close if !std[2].closed?
+            3.times {|n| std[n].close if !std[n].closed? }
 
-        @code=get_exit_code(@stderr)
+            pid = std[-1].pid
+            self.kill(pid)
 
-        if @code!=0
-            log("Command execution fail: #{command}")
-            log(@stderr)
+            @code = 255
         end
 
         return @code
@@ -94,7 +131,7 @@ class GenericCommand
 
     # Parses error message from +stderr+ output
     def get_error_message
-        tmp=@stderr.scan(/^ERROR MESSAGE --8<------\n(.*?)ERROR MESSAGE ------>8--$/m)
+        tmp=@stderr.scan(/^#{ERROR_OPEN}\n(.*?)#{ERROR_CLOSE}$/m)
         return "-" if !tmp[0]
         tmp[0].join(' ').strip
     end
@@ -124,7 +161,8 @@ class LocalCommand < GenericCommand
 private
 
     def execute
-        Open3.popen3("#{command} ; echo ExitCode: $? 1>&2")
+        Open3.popen3("#{command} ; echo ExitCode: $? 1>&2",
+                        :pgroup => true)
     end
 end
 
@@ -134,26 +172,28 @@ class SSHCommand < GenericCommand
     attr_accessor :host
 
     # Creates a command and runs it
-    def self.run(command, host, logger=nil, stdin=nil)
-        cmd=self.new(command, host, logger, stdin)
+    def self.run(command, host, logger=nil, stdin=nil, timeout=nil)
+        cmd=self.new(command, host, logger, stdin, timeout)
         cmd.run
         cmd
     end
 
     # This one takes another parameter. +host+ is the machine
     # where the command is going to be executed
-    def initialize(command, host, logger=nil, stdin=nil)
+    def initialize(command, host, logger=nil, stdin=nil, timeout=nil)
         @host=host
-        super(command, logger, stdin)
+        super(command, logger, stdin, timeout)
     end
 
 private
 
     def execute
         if @stdin
-            Open3.popen3("ssh #{@host} #{@command} ; echo ExitCode: $? 1>&2")
+            Open3.popen3("ssh #{@host} #{@command} ; echo ExitCode: $? 1>&2",
+                            :pgroup => true)
         else
-            Open3.popen3("ssh -n #{@host} #{@command} ; echo ExitCode: $? 1>&2")
+            Open3.popen3("ssh -n #{@host} #{@command} ; echo ExitCode: $? 1>&2",
+                            :pgroup => true)
         end
     end
 end
@@ -161,13 +201,13 @@ end
 class RemotesCommand < SSHCommand
 
     # Creates a command and runs it
-    def self.run(command, host, remote_dir, logger=nil, stdin=nil, retries=0)
+    def self.run(command, host, remote_dir, logger=nil, stdin=nil, retries=0, timeout=nil)
         cmd_file = command.split(' ')[0]
 
         cmd_string = "'if [ -x \"#{cmd_file}\" ]; then #{command}; else\
                               exit #{MAGIC_RC}; fi'"
 
-        cmd = self.new(cmd_string, host, logger, stdin)
+        cmd = self.new(cmd_string, host, logger, stdin, timeout)
         cmd.run
 
         while cmd.code != 0 and retries != 0

data/lib/DriverExecHelper.rb

@@ -108,12 +108,11 @@ module DriverExecHelper
 
     # Sends a log message to ONE. The +message+ can be multiline, it will
     # be automatically splitted by lines.
-    def log(number, message)
+    def log(number, message, all=true)
         in_error_message=false
         msg=message.strip
         msg.each_line {|line|
-            severity='I'
-
+            severity=all ? 'I' : nil
             l=line.strip
 
             if l=='ERROR MESSAGE --8<------'
@@ -134,21 +133,19 @@ module DriverExecHelper
                         severity='D'
                     when 'INFO'
                         severity='I'
-                    else
-                        severity='I'
                     end
                 end
             end
 
-            send_message("LOG", severity, number, line.strip)
+            send_message("LOG", severity, number, line.strip) if severity
         }
     end
 
     # Generates a proc with that calls log with a hardcoded number. It will
     # be used to add loging to command actions
     def log_method(num)
-        lambda {|message|
-            log(num, message)
+        lambda {|message, all=true|
+            log(num, message, all)
         }
     end
 

data/lib/OpenNebulaDriver.rb

@@ -53,12 +53,14 @@ class OpenNebulaDriver < ActionManager
             :concurrency => 10,
             :threaded    => true,
             :retries     => 0,
-            :local_actions => {}
+            :local_actions => {},
+            :timeout     => nil
         }.merge!(options)
 
         super(@options[:concurrency], @options[:threaded])
 
         @retries = @options[:retries]
+        @timeout = @options[:timeout]
 
         #Set default values
         initialize_helper(directory, @options)
@@ -94,7 +96,11 @@ class OpenNebulaDriver < ActionManager
         command = action_command_line(aname, params, options[:script_name])
 
         if action_is_local?(aname)
-            execution = LocalCommand.run(command, log_method(id), Base64::encode64(options[:stdin].to_s.gsub("\n","")))
+            stdin = Base64::encode64(options[:stdin].to_s.gsub("\n",""))
+            execution = LocalCommand.run(command,
+                                         log_method(id),
+                                         stdin,
+                                         @timeout)
         elsif options[:ssh_stream]
             if options[:stdin]
                 cmdin = "cat << EOT | #{command}"
@@ -104,15 +110,19 @@ class OpenNebulaDriver < ActionManager
                 stdin = nil
             end
 
-            execution = options[:ssh_stream].run(cmdin, stdin, command)
+            execution = options[:ssh_stream].run(cmdin,
+                                                 stdin,
+                                                 command,
+                                                 @timeout)
 
         else
             execution = RemotesCommand.run(command,
-                                         host,
-                                         @remote_scripts_base_path,
-                                         log_method(id),
-                                         options[:stdin],
-                                         @retries)
+                                           host,
+                                           @remote_scripts_base_path,
+                                           log_method(id),
+                                           options[:stdin],
+                                           @retries,
+                                           @timeout)
         end
 
         result, info = get_info_from_execution(execution)

data/lib/VirtualMachineDriver.rb

@@ -13,6 +13,7 @@
 # See the License for the specific language governing permissions and        #
 # limitations under the License.                                             #
 #--------------------------------------------------------------------------- #
+require 'opennebula'
 require "OpenNebulaDriver"
 require "CommandManager"
 require 'base64'
@@ -52,23 +53,8 @@ class VirtualMachineDriver < OpenNebulaDriver
         :update_sg   => "UPDATESG"
     }
 
-    POLL_ATTRIBUTE = {
-        :memory          => "MEMORY",
-        :cpu             => "CPU",
-        :nettx           => "NETTX",
-        :netrx           => "NETRX",
-        :state           => "STATE",
-        :disk_size       => "DISK_SIZE",
-        :snapshot_size   => "SNAPSHOT_SIZE"
-    }
-
-    VM_STATE = {
-        :active  => 'a',
-        :paused  => 'p',
-        :error   => 'e',
-        :deleted => 'd',
-        :unknown => '-'
-    }
+    POLL_ATTRIBUTE = OpenNebula::VirtualMachine::Driver::POLL_ATTRIBUTE
+    VM_STATE = OpenNebula::VirtualMachine::Driver::VM_STATE
 
     HOST_ARG = 1
 

data/lib/cloud/CloudClient.rb

@@ -50,7 +50,7 @@ end
 module CloudClient
 
     # OpenNebula version
-    VERSION = '5.0.2'
+    VERSION = '5.1.80'
 
     # #########################################################################
     # Default location for the authentication file

data/lib/opennebula.rb

@@ -66,5 +66,5 @@ require 'opennebula/marketplaceapp_pool'
 module OpenNebula
 
     # OpenNebula version
-    VERSION = '5.0.2'
+    VERSION = '5.1.80'
 end

data/lib/opennebula/user.rb

@@ -54,6 +54,10 @@ module OpenNebula
         # Driver name for x509 proxy authentication
         X509_PROXY_AUTH = "x509_proxy"
 
+        # Same as User.cc
+        INVALID_NAME_CHARS = [" ", ":", "\t", "\n", "\v", "\f", "\r"]
+        INVALID_PASS_CHARS = [" ", "\t", "\n", "\v", "\f", "\r"]
+
         # Creates a User description with just its identifier
         # this method should be used to create plain User objects.
         # +id+ the id of the user
@@ -188,15 +192,17 @@ module OpenNebula
 
         # Sets the LOGIN_TOKEN for the user
         #
-        # @param username [String] of the user
+        # @param uname [String] of the user
         # @param token [String] the login token, if empty OpenNebula will
         #   generate one
-        # @param expire [String] valid period of the token in secs. If <= 0
+        # @param expire [String] valid period of the token in secs. If == 0
         #   the token will be reset
+        # @param egid [Integer] Effective GID to use with this token. To use
+        # the current GID and user groups set it to -1
         # @return [String, OpenNebula::Error] token in case of success, Error
         #   otherwise
-        def login(username, token, expire)
-            return @client.call(USER_METHODS[:login], username, token, expire)
+        def login(uname, token, expire, egid = -1)
+            return @client.call(USER_METHODS[:login], uname, token, expire, egid)
         end
 
         #######################################################################

data/lib/opennebula/virtual_machine.rb

@@ -218,6 +218,27 @@ module OpenNebula
             'SL_PRIMARYIPADDRESS'
         ]
 
+        # VirtualMachineDriver constants
+        module Driver
+            POLL_ATTRIBUTE = {
+                :memory          => "MEMORY",
+                :cpu             => "CPU",
+                :nettx           => "NETTX",
+                :netrx           => "NETRX",
+                :state           => "STATE",
+                :disk_size       => "DISK_SIZE",
+                :snapshot_size   => "SNAPSHOT_SIZE"
+            }
+
+            VM_STATE = {
+                :active  => 'a',
+                :paused  => 'p',
+                :error   => 'e',
+                :deleted => 'd',
+                :unknown => '-'
+            }
+        end
+
         # Creates a VirtualMachine description with just its identifier
         # this method should be used to create plain VirtualMachine objects.
         # +id+ the id of the vm

data/lib/vcenter_driver.rb

@@ -42,7 +42,6 @@ require 'yaml'
 require 'opennebula'
 require 'base64'
 require 'openssl'
-require 'VirtualMachineDriver'
 
 ################################################################################
 # Monkey patch rbvmomi library with some extra functions
@@ -310,18 +309,22 @@ class VIClient
     def find_vm_template(uuid)
         version = @vim.serviceContent.about.version
 
+        found_vm = nil
+
         if version.split(".").first.to_i >= 6
-            @dc.vmFolder.findByUuid(uuid, RbVmomi::VIM::VirtualMachine, @dc)
-        else
-            vms = VIClient.get_entities(@dc.vmFolder, 'VirtualMachine')
+           found_vm = @dc.vmFolder.findByUuid(uuid, RbVmomi::VIM::VirtualMachine, @dc)
+        end
 
-            return vms.find do |v|
-                begin
-                    v.config && v.config.uuid == uuid
-                rescue RbVmomi::VIM::ManagedObjectNotFound
-                    false
-                end
-            end
+        return found_vm if found_vm
+
+        vms = VIClient.get_entities(@dc.vmFolder, 'VirtualMachine')
+
+        return vms.find do |v|
+             begin
+                 v.config && v.config.uuid == uuid
+             rescue RbVmomi::VIM::ManagedObjectNotFound
+                 false
+             end
         end
     end
 
@@ -1357,8 +1360,8 @@ end
 class VCenterVm
     attr_reader :vm
 
-    POLL_ATTRIBUTE  = VirtualMachineDriver::POLL_ATTRIBUTE
-    VM_STATE        = VirtualMachineDriver::VM_STATE
+    POLL_ATTRIBUTE  = OpenNebula::VirtualMachine::Driver::POLL_ATTRIBUTE
+    VM_STATE        = OpenNebula::VirtualMachine::Driver::VM_STATE
 
     ############################################################################
     #  Creates a new VIVm using a RbVmomi::VirtualMachine object
@@ -2272,10 +2275,14 @@ private
         vmid        = xml.root.elements["/VM/ID"].text
         context     = xml.root.elements["/VM/TEMPLATE/CONTEXT"]
 
-        # Read existing context if it is not a new VM
-        if !newvm
-            old_context = vm.config.extraConfig.select{|val|
-                       val[:key]=="guestinfo.opennebula.context"}
+        token = vm.config.extraConfig.select do |val|
+            val[:key] == "opennebula.token"
+        end
+
+        if token && !token.empty?
+            token = token.first[:value]
+        else
+            token = nil
         end
 
         # Add VMID to VM's extraConfig
@@ -2313,60 +2320,56 @@ private
 
             # OneGate
             onegate_token_flag = xml.root.elements["/VM/TEMPLATE/CONTEXT/TOKEN"]
-            if onegate_token_flag and
-               onegate_token_flag.text == "YES" and
-               !newvm
-                # Create the OneGate token string
-                vmid_str  = xml.root.elements["/VM/ID"].text
-                stime_str = xml.root.elements["/VM/STIME"].text
-                str_to_encrypt = "#{vmid_str}:#{stime_str}"
-
-                user_id = xml.root.elements['//CREATED_BY'].text
-
-                if user_id.nil?
-                    STDERR.puts {"VMID:#{vmid} CREATED_BY not present" \
-                        " in the VM TEMPLATE"}
-                    return nil
-                end
 
-                user = OpenNebula::User.new_with_id(user_id,
-                                                    OpenNebula::Client.new)
-                rc   = user.info
+            if onegate_token_flag and onegate_token_flag.text == "YES"
+                if token
+                    onegate_token_64 = token
+                else
+                    # Create the OneGate token string
+                    vmid_str  = xml.root.elements["/VM/ID"].text
+                    stime_str = xml.root.elements["/VM/STIME"].text
+                    str_to_encrypt = "#{vmid_str}:#{stime_str}"
 
-                if OpenNebula.is_error?(rc)
-                    STDERR.puts {"VMID:#{vmid} user.info" \
-                        " error: #{rc.message}"}
-                    return nil
-                end
+                    user_id = xml.root.elements['//CREATED_BY'].text
 
-                token_password = user['TEMPLATE/TOKEN_PASSWORD']
+                    if user_id.nil?
+                        STDERR.puts {"VMID:#{vmid} CREATED_BY not present" \
+                            " in the VM TEMPLATE"}
+                        return nil
+                    end
 
-                if token_password.nil?
-                    STDERR.puts {"VMID:#{vmid} TOKEN_PASSWORD not present"\
-                        " in the USER:#{user_id} TEMPLATE"}
-                    return nil
-                end
+                    user = OpenNebula::User.new_with_id(user_id,
+                                                        OpenNebula::Client.new)
+                    rc   = user.info
 
-                cipher = OpenSSL::Cipher::Cipher.new("aes-256-cbc")
-                cipher.encrypt
-                cipher.key = token_password
-                onegate_token = cipher.update(str_to_encrypt)
-                onegate_token << cipher.final
+                    if OpenNebula.is_error?(rc)
+                        STDERR.puts {"VMID:#{vmid} user.info" \
+                            " error: #{rc.message}"}
+                        return nil
+                    end
 
-                onegate_token_64 = Base64.encode64(onegate_token).chop
+                    token_password = user['TEMPLATE/TOKEN_PASSWORD']
 
-                context_text += "ONEGATE_TOKEN='#{onegate_token_64}'\n"
-            end
+                    if token_password.nil?
+                        STDERR.puts {"VMID:#{vmid} TOKEN_PASSWORD not present"\
+                            " in the USER:#{user_id} TEMPLATE"}
+                        return nil
+                    end
 
-            # If there is an old VM, we need to honor the existing ONEGATE_TOKEN
-            if !newvm
-                onegate_token =
-                    Base64.decode64(old_context[0][:value]).split("\n").
-                    select{|line| line.start_with?("ONEGATE_TOKEN")}[0]
+                    cipher = OpenSSL::Cipher::Cipher.new("aes-256-cbc")
+                    cipher.encrypt
+                    cipher.key = token_password
+                    onegate_token = cipher.update(str_to_encrypt)
+                    onegate_token << cipher.final
 
-                if onegate_token
-                  context_text += onegate_token
+                    onegate_token_64 = Base64.encode64(onegate_token).chop
+                    config_array << {
+                        :key    => 'opennebula.token',
+                        :value  => onegate_token_64
+                    }
                 end
+
+                context_text += "ONEGATE_TOKEN='#{onegate_token_64}'\n"
             end
 
             context_text = Base64.encode64(context_text.chop)
@@ -2423,7 +2426,8 @@ private
             vm.config.hardware.device.select { |d|
                 if is_disk?(d)
                    disks.each{|disk|
-                      if disk.elements["SOURCE"].text == d.backing.fileName
+                      if d.backing.respond_to?(:fileName) &&
+                         disk.elements["SOURCE"].text == d.backing.fileName &&
                          disks.delete(disk)
                       end
                    }
@@ -2581,13 +2585,13 @@ private
         end
 
         controller = nil
-       
+
         vm.config.hardware.device.each { |device|
           (controller = device ; break) if device.deviceInfo.label == available_controller_label
         }
-      
+
         new_unit_number =  available_numbers.sort[0]
-      
+
         return controller, new_unit_number
     end
 
@@ -2707,6 +2711,7 @@ private
         disks.each{ |disk|
           ds_and_img_name = "[#{disk['DATASTORE']}] #{disk['SOURCE']}"
           vcenter_disk = vm.config.hardware.device.select { |d| is_disk?(d) &&
+                                    d.backing.respond_to?(:fileName) &&
                                     d.backing.fileName == ds_and_img_name }[0]
            spec[:deviceChange] <<  {
                 :operation => :remove,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opennebula
 version: !ruby/object:Gem::Version
-  version: 5.0.2
+  version: 5.1.80.beta1
 platform: ruby
 authors:
 - OpenNebula
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-21 00:00:00.000000000 Z
+date: 2016-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -134,9 +134,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.5.1