opennebula-cli 5.10.5 → 5.12.0.1

data/lib/one_helper/oneflowtemplate_helper.rb

@@ -0,0 +1,312 @@
+# -------------------------------------------------------------------------- #
+# Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                #
+#                                                                            #
+# 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 'one_helper'
+
+# Oneflow Template command helper
+class OneFlowTemplateHelper < OpenNebulaHelper::OneHelper
+
+    # Configuration file
+    def self.conf_file
+        'oneflowtemplate.yaml'
+    end
+
+    # Get client to make request
+    #
+    # @options [Hash] CLI options
+    def client(options)
+        Service::Client.new(
+            :username => options[:username],
+            :password => options[:password],
+            :url => options[:server],
+            :user_agent => USER_AGENT
+        )
+    end
+
+    # Get service template pool
+    def format_service_template_pool
+        config_file = self.class.table_conf
+
+        CLIHelper::ShowTable.new(config_file, self) do
+            column :ID, 'ID', :size => 10 do |d|
+                d['ID']
+            end
+
+            column :USER, 'Username', :left, :size => 15 do |d|
+                d['UNAME']
+            end
+
+            column :GROUP, 'Group', :left, :size => 15 do |d|
+                d['GNAME']
+            end
+
+            column :NAME, 'Name', :left, :expand => true do |d|
+                d['NAME']
+            end
+
+            default :ID, :USER, :GROUP, :NAME
+        end
+    end
+
+    # List service template pool
+    #
+    # @param client  [Service::Client] Petition client
+    # @param options [Hash]            CLI options
+    def list_service_template_pool(client, options)
+        response = client.get(RESOURCE_PATH)
+
+        if CloudClient.is_error?(response)
+            [response.code.to_i, response.to_s]
+        else
+            if options[:json]
+                [0, response.body]
+            else
+                documents = JSON.parse(response.body)['DOCUMENT_POOL']
+                format_service_template_pool.show(documents['DOCUMENT'])
+
+                0
+            end
+        end
+    end
+
+    # List service template pool continiously
+    #
+    # @param client  [Service::Client] Petition client
+    # @param options [Hash]            CLI options
+    def top_service_template_pool(client, options)
+        # TODO: make default delay configurable
+        options[:delay] ? delay = options[:delay] : delay = 4
+
+        begin
+            loop do
+                CLIHelper.scr_cls
+                CLIHelper.scr_move(0, 0)
+
+                list_service_template_pool(client, options)
+
+                sleep delay
+            end
+        rescue StandardError => e
+            STDERR.puts e.message
+            exit(-1)
+        end
+
+        0
+    end
+
+    # Show service template detailed information
+    #
+    # @param client           [Service::Client] Petition client
+    # @param service_template [Integer]         Service template ID
+    # @param options          [Hash]            CLI options
+    def format_resource(client, service_template, options)
+        response = client.get("#{RESOURCE_PATH}/#{service_template}")
+
+        if CloudClient.is_error?(response)
+            [response.code.to_i, response.to_s]
+        else
+            if options[:json]
+                [0, response.body]
+            else
+                str    = '%-20s: %-20s'
+                str_h1 = '%-80s'
+
+                document = JSON.parse(response.body)['DOCUMENT']
+                template = document['TEMPLATE']['BODY']
+
+                CLIHelper.print_header(
+                    str_h1 % "SERVICE TEMPLATE #{document['ID']} INFORMATION"
+                )
+
+                puts Kernel.format str, 'ID',   document['ID']
+                puts Kernel.format str, 'NAME', document['NAME']
+                puts Kernel.format str, 'USER', document['UNAME']
+                puts Kernel.format str, 'GROUP', document['GNAME']
+
+                puts
+
+                CLIHelper.print_header(str_h1 % 'PERMISSIONS', false)
+
+                %w[OWNER GROUP OTHER].each do |e|
+                    mask = '---'
+                    permissions_hash = document['PERMISSIONS']
+                    mask[0] = 'u' if permissions_hash["#{e}_U"] == '1'
+                    mask[1] = 'm' if permissions_hash["#{e}_M"] == '1'
+                    mask[2] = 'a' if permissions_hash["#{e}_A"] == '1'
+
+                    puts Kernel.format str, e, mask
+                end
+
+                puts
+
+                CLIHelper.print_header(str_h1 % 'TEMPLATE CONTENTS', false)
+                puts JSON.pretty_generate(template)
+
+                0
+            end
+        end
+    end
+
+    # Get custom attributes values from user
+    #
+    # @param custom_attrs [Hash] Custom attributes from template
+    #
+    # @return [Hash] Custom attributes values
+    def custom_attrs(custom_attrs)
+        # rubocop:disable Layout/LineLength
+        return if custom_attrs.nil? || custom_attrs.empty?
+
+        ret = {}
+        ret['custom_attrs_values'] = OpenNebulaHelper.parse_user_inputs(custom_attrs)
+
+        # rubocop:enable Layout/LineLength
+        ret
+    end
+
+    def networks(vnets)
+        return unless vnets
+
+        ret = {}
+        ret['networks_values'] = parse_networks(vnets)
+
+        ret
+    end
+
+    def parse_networks(vnets, get_defaults = false)
+        unless get_defaults
+            puts 'There are some networks that require user input. ' \
+                 'Use the string <<EDITOR>> to launch an editor ' \
+                 '(e.g. for multi-line inputs)'
+        end
+
+        answers = []
+
+        vnets.each do |key, val|
+            input_cfg = val.split('|', -1)
+
+            if input_cfg.length != 5
+                STDERR.puts 'Malformed user input. It should have 5'\
+                            "parts separated by '|':"
+                STDERR.puts "  #{key}: #{val}"
+                exit(-1)
+            end
+
+            mandatory, _type, description, _params, initial = input_cfg
+
+            vnet = {}
+
+            if initial && !initial.empty?
+                type, resource_id, extra = initial.split(':', -1)
+            end
+
+            if (type.nil? || resource_id.nil?) &&
+               (initial && !initial.empty?)
+                STDERR.puts 'Wrong type for user input default value:'
+                STDERR.puts "  #{key}: #{val}"
+                exit(-1)
+            end
+
+            vnet[key] = {}
+
+            if get_defaults
+                vnet[key][type] = resource_id
+                vnet[key]['extra'] = extra
+
+                answers << vnet unless mandatory == 'M'
+                next
+            end
+
+            puts "  * (#{key}) #{description}"
+
+            #######################################
+            # Asks for type
+            #######################################
+
+            header = '    '
+            header += 'TYPE Existing(1), Create(2), Reserve(3). '
+
+            if !type.nil? && type != ''
+                header += 'Press enter for default. '
+            end
+
+            print header
+
+            answer = STDIN.readline.chop
+
+            type_a = type
+
+            case answer.to_i
+            when 1
+                type_a = 'id'
+            when 2
+                type_a = 'template_id'
+            when 3
+                type_a = 'reserve_from'
+            end
+
+            #######################################
+            # Asks for resource id
+            #######################################
+
+            header = '    '
+            if type_a == 'template_id'
+                header += 'VN Template ID. '
+            else
+                header += 'VN ID. '
+            end
+
+            if !resource_id.nil? && resource_id != ''
+                header += "Press enter for default (#{resource_id}). "
+            end
+
+            print header
+
+            resource_id_a = STDIN.readline.chop
+
+            resource_id_a = resource_id if resource_id_a.empty?
+
+            #######################################
+            # Asks for extra
+            #######################################
+
+            if type_a != 'id'
+                header = '    '
+                header += 'EXTRA (Type EMPTY for leaving empty). '
+
+                if !extra.nil? && extra != ''
+                    header += " Press enter for default (#{extra}). "
+                end
+
+                print header
+
+                extra_a = STDIN.readline.chop
+
+                if extra_a.empty?
+                    vnet[key]['extra'] = extra
+                else
+                    vnet[key]['extra'] = extra_a
+                end
+            end
+
+            vnet[key][type_a] = resource_id_a
+
+            answers << vnet
+        end
+
+        answers
+    end
+
+end

data/lib/one_helper/onegroup_helper.rb

@@ -1,5 +1,5 @@
 # -------------------------------------------------------------------------- #
-# Copyright 2002-2019, OpenNebula Project, OpenNebula Systems                #
+# Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                #
 #                                                                            #
 # 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    #

data/lib/one_helper/onehook_helper.rb

@@ -1,5 +1,5 @@
 # -------------------------------------------------------------------------- #
-# Copyright 2002-2019, OpenNebula Project, OpenNebula Systems                #
+# Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                #
 #                                                                            #
 # 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    #

data/lib/one_helper/onehost_helper.rb

@@ -1,5 +1,5 @@
 # -------------------------------------------------------------------------- #
-# Copyright 2002-2019, OpenNebula Project, OpenNebula Systems                #
+# Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                #
 #                                                                            #
 # 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    #
@@ -17,6 +17,7 @@
 require 'one_helper'
 require 'one_helper/onevm_helper'
 require 'rubygems'
+require 'time'
 
 # implements onehost command
 class OneHostHelper < OpenNebulaHelper::OneHelper
@@ -48,25 +49,25 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
         :az => {
             :help => <<-EOT.unindent
                 #-----------------------------------------------------------------------
-                # Supported AZURE AUTH ATTRIBUTTES:
+                # Mandatory AZURE ATTRIBUTTES:
                 #
-                #  AZ_ID   = <azure classic id>
-                #  AZ_CERT = <azure classic certificate>
+                # AZ_SUB    = "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX"
+                # AZ_CLIENT = "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX"
+                # AZ_SECRET = "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX"
+                # AZ_TENANT = "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX"
+                # AZ_REGION = "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX"
                 #
-                #  REGION_NAME = <the name of the azure region>
+                # CAPACITY=[
+                #   STANDARD_B1LS =<number of machines Standard_B1ls>,
+                #   STANDARD_A1_V2=<number of machines Standard_A1_v2>
+                # ]
                 #
-                #  CAPACITY = [
-                #    Small = <number of small machines>,
-                #    Medium = <number of medium machines>,
-                #    Large = <number of large machines
-                #  ]
-                #
-                # You can set any machine type supported by azure classic
-                # See your az_driver.conf for more information
+                # Optional AZURE ATTRIBUTES:
                 #
-                # Optionally you can set a endpoint
+                # AZ_RGROUP = ""
                 #
-                #  AZ_ENDPOINT = <endpoint address>
+                # You can set any machine type supported by azure
+                # See your az_driver.conf for more information
                 #
                 #-----------------------------------------------------------------------
             EOT
@@ -75,6 +76,15 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
 
     VERSION_XPATH = "#{TEMPLATE_XPATH}/VERSION"
 
+    MONITORING = {
+        'FREE_CPU'    => 'CAPACITY',
+        'FREE_MEMORY' => 'CAPACITY',
+        'USED_CPU'    => 'CAPACITY',
+        'USED_MEMORY' => 'CAPACITY',
+        'NETRX'       => 'SYSTEM',
+        'NETTX'       => 'SYSTEM'
+    }
+
     def self.rname
         'HOST'
     end
@@ -359,14 +369,15 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
 
                     print_update_info(total - size, total, host['NAME'])
 
-                    if options[:rsync]
-                        sync_cmd = "rsync -Laz --delete #{REMOTES_LOCATION}" \
-                                   " #{host['NAME']}:#{remote_dir}"
-                    else
+                    if options[:ssh]
                         sync_cmd = "ssh #{host['NAME']}" \
+                                   " rm -rf '#{remote_dir}' 2>/dev/null;" \
                                    " mkdir -p '#{remote_dir}' 2>/dev/null &&" \
                                    " scp -rp #{REMOTES_LOCATION}/*" \
                                    " #{host['NAME']}:#{remote_dir} 2> /dev/null"
+                    else
+                        sync_cmd = "rsync -Laz --delete #{REMOTES_LOCATION}/" \
+                                   " #{host['NAME']}:#{remote_dir}/"
                     end
 
                     retries = 3
@@ -424,8 +435,7 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
         rc = pool.info
         return -1, rc.message if OpenNebula.is_error?(rc)
 
-        # Assign hosts to threads
-        queue = []
+        host_errors = []
 
         pool.each do |host|
             if host_ids
@@ -434,7 +444,6 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
                 next if host['CLUSTER_ID'].to_i != cluster_id
             end
 
-            vm_mad = host['VM_MAD'].downcase
             state = host['STATE']
 
             # Skip this host from remote syncing if it's a PUBLIC_CLOUD host
@@ -443,60 +452,104 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
             # Skip this host from remote syncing if it's OFFLINE
             next if Host::HOST_STATES[state.to_i] == 'OFFLINE'
 
-            # Skip this host if it is a vCenter cluster
-            next if vm_mad == 'vcenter'
+            rc = host.forceupdate
 
-            queue << host
+            host_errors << host['NAME'] if OpenNebula.is_error?(rc)
         end
 
-        # Run the jobs in threads
-        host_errors = []
-        queue_lock = Mutex.new
-        error_lock = Mutex.new
-        total = queue.length
+        if host_errors.empty?
+            puts 'All hosts updated successfully.'
+            0
+        else
+            STDERR.puts 'Failed to update the following hosts:'
+            host_errors.each {|h| STDERR.puts "* #{h}" }
+            -1
+        end
+    end
 
-        if total.zero?
-            puts 'No hosts are going to be forced.'
-            exit(0)
+    def monitoring(host, attr, options)
+        unit    = options[:unit] || 'G'
+        start_d = options[:start]
+        end_d   = options[:end]
+        n_elems = options[:n_elems] || 8
+
+        # Different available size units
+        units = %w[K M G T]
+
+        # Attrs that need units conversion
+        attrs = %w[FREE_MEMORY USED_MEMORY]
+
+        if unit && !units.include?(unit)
+            STDERR.puts "Invalid unit `#{unit}`"
+            exit(-1)
         end
 
-        ts = (1..NUM_THREADS).map do |_t|
-            Thread.new do
-                loop do
-                    host = nil
-                    size = 0
+        attr      = attr.upcase
+        start_d   = Time.parse(start_d) if start_d
+        end_d     = Time.parse(end_d) if end_d
 
-                    queue_lock.synchronize do
-                        host = queue.shift
-                        size = queue.length
-                    end
+        # Get monitoring data from user path
+        #
+        #   0 -> timestamp
+        #   1 -> data retrieved
+        monitoring_data = host.monitoring(["#{MONITORING[attr]}/#{attr}"])
+        monitoring_data = monitoring_data["#{MONITORING[attr]}/#{attr}"]
 
-                    break unless host
+        if monitoring_data.empty?
+            STDERR.puts 'No monitoring data found'
+            return
+        end
 
-                    cmd = 'cat /tmp/one-collectd-client.pid | xargs kill -HUP'
-                    system("ssh #{host['NAME']} \"#{cmd}\" 2>/dev/null")
+        # Get data max and min date
+        start_d ||= Time.at(monitoring_data.min {|v| v[0].to_i }[0].to_i)
+        end_d   ||= Time.at(monitoring_data.max {|v| v[0].to_i }[0].to_i)
 
-                    if !$CHILD_STATUS.success?
-                        error_lock.synchronize do
-                            host_errors << host['NAME']
-                        end
-                    else
-                        puts "#{host['NAME']} monitoring forced"
-                    end
-                end
+        # Filter data betwen dates
+        monitoring_data.reject! do |v|
+            v[0].to_i < start_d.to_i || v[0].to_i > end_d.to_i
+        end
+
+        if monitoring_data.empty?
+            STDERR.puts "No monitoring data found between #{start_d} " \
+                        "and #{end_d}"
+            return
+        end
+
+        start_d = start_d.strftime('%d/%m/%Y %H:%M')
+        end_d   = end_d.strftime('%d/%m/%Y %H:%M')
+
+        # Parse dcollected data
+        x = monitoring_data.collect {|v| Time.at(v[0].to_i).strftime('%H:%M') }
+        y = monitoring_data.collect do |v|
+            if attrs.include?(attr)
+                # GB is the default unit
+                v = OpenNebulaHelper.bytes_to_unit(v[1].to_i, unit).round(2)
+                "#{v} #{unit}B"
+            else
+                v[1]
             end
         end
 
-        # Wait for threads to finish
-        ts.each {|t| t.join }
+        title = ''
+        title << "Host #{host.id} #{attr} "
+        title << "in #{unit}B " if unit && attrs.include?(attr)
+        title << "from #{start_d} to #{end_d}"
 
-        if host_errors.empty?
-            puts 'All hosts updated successfully.'
-            0
+        x = x.last(n_elems)
+        y = y.last(n_elems)
+
+        if options[:table]
+            print_monitoring_table(x, y, title)
+        elsif options[:csv]
+            csv = ''
+
+            csv << "TIME#{options[:csv]}VALUE\n"
+
+            x.zip(y) {|x_v, y_v| csv << "#{x_v}#{options[:csv]}#{y_v}\n" }
+
+            puts csv
         else
-            STDERR.puts 'Failed to update the following hosts:'
-            host_errors.each {|h| STDERR.puts "* #{h}" }
-            -1
+            puts OpenNebulaHelper.get_plot(x, y, attr, title)
         end
     end
 
@@ -565,7 +618,7 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
         puts format(str, 'IM_MAD', host['IM_MAD'])
         puts format(str, 'VM_MAD', host['VM_MAD'])
         puts format(str, 'LAST MONITORING TIME',
-                    OpenNebulaHelper.time_to_str(host['LAST_MON_TIME']))
+                    OpenNebulaHelper.time_to_str(host['MONITORING/TIMESTAMP']))
         puts
 
         CLIHelper.print_header(str_h1 % 'HOST SHARES', false)
@@ -579,8 +632,9 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
                     OpenNebulaHelper.unit_to_str(host['HOST_SHARE/MAX_MEM']
                                     .to_i, {}))
         puts format(str, '  USED (REAL)',
-                    OpenNebulaHelper.unit_to_str(host['HOST_SHARE/USED_MEM']
-                                    .to_i, {}))
+                    OpenNebulaHelper
+                    .unit_to_str(host['MONITORING/CAPACITY/USED_MEMORY']
+                    .to_i, {}))
         puts format(str, '  USED (ALLOCATED)',
                     OpenNebulaHelper.unit_to_str(host['HOST_SHARE/MEM_USAGE']
                                     .to_i, {}))
@@ -588,7 +642,7 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
         CLIHelper.print_header(str_h1 % 'CPU', false)
         puts format(str, '  TOTAL', host['HOST_SHARE/TOTAL_CPU'])
         puts format(str, '  TOTAL +/- RESERVED', host['HOST_SHARE/MAX_CPU'])
-        puts format(str, '  USED (REAL)', host['HOST_SHARE/USED_CPU'])
+        puts format(str, '  USED (REAL)', host['MONITORING/CAPACITY/USED_CPU'])
         puts format(str, '  USED (ALLOCATED)', host['HOST_SHARE/CPU_USAGE'])
         puts
 
@@ -662,13 +716,13 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
                                    .split("\n")
                 name   = wild['VM_NAME']
                 import = wild_tmplt.select do |line|
-                             line[/^IMPORT_VM_ID/]
+                             line[/DEPLOY_ID/]
                          end[0].split('=')[1].tr('"', ' ').strip
                 memory = wild_tmplt.select do |line|
-                             line[/^MEMORY/]
+                             line[/MEMORY/]
                          end[0].split('=')[1].tr('"', ' ').strip
                 cpu    = wild_tmplt.select do |line|
-                             line[/^CPU/]
+                             line[/CPU/]
                          end[0].split('=')[1].tr('"', ' ').strip
             else
                 name = wild['DEPLOY_ID']
@@ -918,4 +972,30 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
         table.show(hugepages)
     end
 
+    def print_monitoring_table(x, y, title)
+        puts
+        CLIHelper.print_header(title, true)
+        puts
+
+        table = CLIHelper::ShowTable.new(nil, self) do
+            column :TIME, 'Timestamp', :size => 8, :left => false do |d|
+                d['TIME']
+            end
+
+            column :VALUE, 'Value', :size => 8, :left => false do |d|
+                d['VALUE']
+            end
+
+            default :TIME, :VALUE
+        end
+
+        data = []
+
+        x.zip(y) do |x_v, y_v|
+            data << { 'TIME' => x_v, 'VALUE' => y_v }
+        end
+
+        table.show(data)
+    end
+
 end