diff --git a/src/cli/one_helper/onehost_helper.rb b/src/cli/one_helper/onehost_helper.rb index a936d0de16..d80a3b3c4b 100644 --- a/src/cli/one_helper/onehost_helper.rb +++ b/src/cli/one_helper/onehost_helper.rb @@ -1,5 +1,5 @@ # -------------------------------------------------------------------------- # -# Copyright 2002-2013, OpenNebula Project (OpenNebula.org), C12G Labs # +# Copyright 2002-2014, OpenNebula Project (OpenNebula.org), C12G Labs # # # # 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 # @@ -14,940 +14,384 @@ # limitations under the License. # #--------------------------------------------------------------------------- # -require 'cli_helper' +require 'one_helper' +require 'one_helper/onevm_helper' -require 'opennebula' -include OpenNebula +class OneHostHelper < OpenNebulaHelper::OneHelper + TEMPLATE_XPATH = '//HOST/TEMPLATE' + VERSION_XPATH = "#{TEMPLATE_XPATH}/VERSION" -module OpenNebulaHelper - ONE_VERSION=<<-EOT -OpenNebula #{OpenNebula::VERSION} -Copyright 2002-2013, OpenNebula Project (OpenNebula.org), C12G Labs - -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 -EOT - - if ONE_LOCATION - TABLE_CONF_PATH=ONE_LOCATION+"/etc/cli" - else - TABLE_CONF_PATH="/etc/one/cli" + def self.rname + "HOST" end - EDITOR_PATH='/usr/bin/vi' - - ######################################################################## - # Options - ######################################################################## - XML={ - :name => "xml", - :short => "-x", - :large => "--xml", - :description => "Show the resource in xml format" - } - - NUMERIC={ - :name => "numeric", - :short => "-n", - :large => "--numeric", - :description => "Do not translate user and group IDs" - } - - KILOBYTES={ - :name => "kilobytes", - :short => "-k", - :large => "--kilobytes", - :description => "Show units in kilobytes" - } - - DESCRIBE={ - :name => "describe", - :large => "--describe", - :description => "Describe list columns" - } - - APPEND = { - :name => "append", - :short => "-a", - :large => "--append", - :description => "Append new attributes to the current template" - } - - # Command line VM template options - TEMPLATE_NAME_VM={ - :name => 'name', - :large => '--name name', - :description => - 'Name for the new VM', - :format => String - } - - DRY={ - :name => 'dry', - :large => '--dry', - :description => 'Just print the template' - } - - CLIENT_OPTIONS=[ - { - :name => 'user', - :large => '--user name', - :description => 'User name used to connect to OpenNebula', - :format => String - }, - { - :name => 'password', - :large => '--password password', - :description => 'Password to authenticate with OpenNebula', - :format => String - }, - { - :name => 'endpoint', - :large => '--endpoint endpoint', - :description => 'URL of OpenNebula xmlrpc frontend', - :format => String - } - ] - - GROUP_OPTIONS=[ - { - :name => 'name', - :large => '--name name', - :short => "-n", - :description => - 'Name for the new group', - :format => String - }, - { - :name => 'admin_group', - :large => '--admin_group name', - :short => "-a", - :description => - 'Creates an admin group with name', - :format => String - }, - { - :name => 'admin_user', - :large => '--admin_user name', - :short => "-u", - :description => - 'Creates an admin user for the group with name', - :format => String - }, - { - :name => 'admin_passwd', - :large => '--admin_passwd password', - :short => "-p", - :description => - 'Password for the admin user of the group', - :format => String - }, - { - :name => 'admin_driver', - :large => '--admin_driver auth_driver', - :short => "-d", - :description => - 'Auth driver for the admin user of the group', - :format => String - } - ] - - #NOTE: Other options defined using this array, add new options at the end - TEMPLATE_OPTIONS=[ - { - :name => 'cpu', - :large => '--cpu cpu', - :description => - "CPU percentage reserved for the VM (1=100% one\n"<< - " "*31<<"CPU)", - :format => Float - }, - { - :name => 'vcpu', - :large => '--vcpu vcpu', - :description => - "Number of virtualized CPUs", - :format => Integer - }, - { - :name => 'arch', - :large => '--arch arch', - :description => - 'Architecture of the VM, e.g.: i386 or x86_64', - :format => String - }, - { - :name => 'memory', - :large => '--memory memory', - :description => 'Memory amount given to the VM. By default the '<< - "unit is megabytes. To use gigabytes add a 'g', floats "<< - "can be used: 8g=8192, 0.5g=512", - :format => String, - :proc => lambda do |o,options| - m=o.strip.match(/^(\d+(?:\.\d+)?)(m|mb|g|gb)?$/i) - - if !m - [-1, 'Memory value malformed'] - else - multiplier=case m[2] - when /(g|gb)/i - 1024 - else - 1 - end - - value=m[1].to_f*multiplier - - [0, value.floor] - end - end - }, - { - :name => 'disk', - :large => '--disk image0,image1', - :description => "Disks to attach. To use an image owned by"<< - " other user use user[disk]", - :format => Array - }, - { - :name => 'nic', - :large => '--nic network0,network1', - :description => "Networks to attach. To use a network owned by"<< - " other user use user[network]", - :format => Array - }, - { - :name => 'raw', - :large => '--raw string', - :description => "Raw string to add to the template. Not to be\n"<< - " "*31<<"confused with the RAW attribute", - :format => String - }, - { - :name => 'vnc', - :large => '--vnc', - :description => 'Add VNC server to the VM' - }, - { - :name => 'vnc_password', - :large => '--vnc-password password', - :format => String, - :description => 'VNC password' - }, - { - :name => 'vnc_listen', - :large => '--vnc-listen ip', - :format => String, - :description => 'VNC IP where to listen for connections. '<< - 'By default is 0.0.0.0 (all interfaces).' - }, - { - :name => 'spice', - :large => '--spice', - :description => 'Add spice server to the VM' - }, - { - :name => 'spice_password', - :large => '--spice-password password', - :format => String, - :description => 'spice password' - }, - { - :name => 'spice_listen', - :large => '--spice-listen ip', - :format => String, - :description => 'spice IP where to listen for connections. '<< - 'By default is 0.0.0.0 (all interfaces).' - }, - { - :name => 'ssh', - :large => '--ssh [file]', - :description => "Add an ssh public key to the context. If the \n"<< - (' '*31)<<"file is omited then the user variable \n"<< - (' '*31)<<"SSH_PUBLIC_KEY will be used.", - :format => String, - :proc => lambda do |o, options| - if !o - [0, true] - else - [0, o] - end - end - }, - { - :name => 'net_context', - :large => '--net_context', - :description => 'Add network contextualization parameters' - }, - { - :name => 'context', - :large => '--context line1,line2,line3', - :format => Array, - :description => 'Lines to add to the context section' - }, - { - :name => 'boot', - :large => '--boot device', - :description => 'Select boot device (hd|fd|cdrom|network)', - :format => String - }, - { - :name => 'files_ds', - :large => '--files_ds file1,file2', - :format => Array, - :description => 'Add files to the contextualization CD from the' << - 'files datastore' - }, - { - :name => 'init', - :large => '--init script1,script2', - :format => Array, - :description => 'Script or scripts to start in context' - } - ] - - TEMPLATE_OPTIONS_VM=[TEMPLATE_NAME_VM]+TEMPLATE_OPTIONS+[DRY] - - CAPACITY_OPTIONS_VM=[TEMPLATE_OPTIONS[0],TEMPLATE_OPTIONS[1],TEMPLATE_OPTIONS[3]] - - OPTIONS = XML, NUMERIC, KILOBYTES - - class OneHelper - attr_accessor :client - - def self.get_client(options) - if defined?(@@client) - @@client - else - secret=nil - user=options[:user] - if user - password=options[:password]||self.get_password - secret="#{user}:#{password}" - end - - endpoint=options[:endpoint] - - @@client=OpenNebula::Client.new(secret, endpoint) - end - end - - def self.client - if defined?(@@client) - @@client - else - self.get_client({}) - end - end - - if RUBY_VERSION>="1.9.3" - require 'io/console' - def self.get_password - print "Password: " - pass=nil - STDIN.noecho {|io| pass=io.gets } - puts - - pass.chop! if pass - pass - end - else - # This function is copied from ruby net/imap.rb - def self.get_password - print "Password: " - system("stty", "-echo") - begin - return gets.chop - ensure - system("stty", "echo") - print "\n" - end - end - end - - def initialize(secret=nil, endpoint=nil) - @client=nil - - @translation_hash = nil - end - - def set_client(options) - @client=OpenNebulaHelper::OneHelper.get_client(options) - end - - def create_resource(options, &block) - resource = factory - - rc = block.call(resource) - if OpenNebula.is_error?(rc) - return -1, rc.message - else - puts "ID: #{resource.id.to_s}" - return 0 - end - end - - def list_pool(options, top=false, filter_flag=nil) - if options[:describe] - table = format_pool(options) - - table.describe_columns - return 0 - end - - filter_flag ||= OpenNebula::Pool::INFO_ALL - - pool = factory_pool(filter_flag) - - rc = pool.info - return -1, rc.message if OpenNebula.is_error?(rc) - - if options[:xml] - return 0, pool.to_xml(true) - else - table = format_pool(options) - - if top - table.top(options) { - pool.info - pool_to_array(pool) - } - else - array=pool_to_array(pool) - - if options[:ids] - array=array.select do |element| - options[:ids].include? element['ID'].to_i - end - end - - table.show(array, options) - end - - return 0 - end - end - - def show_resource(id, options) - resource = retrieve_resource(id) - - rc = resource.info - return -1, rc.message if OpenNebula.is_error?(rc) - - if options[:xml] - return 0, resource.to_xml(true) - else - format_resource(resource, options) - return 0 - end - end - - def perform_action(id, options, verbose, &block) - resource = retrieve_resource(id) - - rc = block.call(resource) - if OpenNebula.is_error?(rc) - return -1, rc.message - else - if options[:verbose] - puts "#{self.class.rname} #{id}: #{verbose}" - end - return 0 - end - end - - def perform_actions(ids,options,verbose,&block) - exit_code = 0 - ids.each do |id| - rc = perform_action(id,options,verbose,&block) - - unless rc[0]==0 - puts rc[1] - exit_code=rc[0] - end - end - - exit_code - end - - ######################################################################## - # Id translation - ######################################################################## - def user_name(resource, options={}) - if options[:numeric] - resource['UID'] - else - resource['UNAME'] - end - end - - def group_name(resource, options={}) - if options[:numeric] - resource['GID'] - else - resource['GNAME'] - end - end - - ######################################################################## - # Formatters for arguments - ######################################################################## - def to_id(name) - return 0, name.to_i if name.match(/^[0123456789]+$/) - - rc = get_pool - return rc if rc.first != 0 - - pool = rc[1] - poolname = self.class.rname - - OneHelper.name_to_id(name, pool, poolname) - end - - def self.to_id_desc - "OpenNebula #{self.rname} name or id" - end - - def list_to_id(names) - rc = get_pool - return rc if rc.first != 0 - - pool = rc[1] - poolname = self.class.rname - - result = names.split(',').collect { |name| - if name.match(/^[0123456789]+$/) - name.to_i - else - rc = OneHelper.name_to_id(name, pool, poolname) - - if rc.first == -1 - return rc[0], rc[1] - end - - rc[1] - end - } - - return 0, result - end - - def self.list_to_id_desc - "Comma-separated list of OpenNebula #{self.rname} names or ids" - end - - def self.name_to_id(name, pool, ename) - objects=pool.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 0, result - end - - def filterflag_to_i(str) - filter_flag = case str - when "a", "all" then OpenNebula::Pool::INFO_ALL - when "m", "mine" then OpenNebula::Pool::INFO_MINE - when "g", "group" then OpenNebula::Pool::INFO_GROUP - else - if str.match(/^[0123456789]+$/) - str.to_i - else - rc = OpenNebulaHelper.rname_to_id(str, "USER") - if rc.first==-1 - return rc - else - rc[1] - end - end - end - - return 0, filter_flag - end - - def self.filterflag_to_i_desc - desc=<<-EOT -a, all all the known #{self.rname}s -m, mine the #{self.rname} belonging to the user in ONE_AUTH -g, group 'mine' plus the #{self.rname} belonging to the groups - the user is member of -uid #{self.rname} of the user identified by this uid -user #{self.rname} of the user identified by the username -EOT - end - - def self.table_conf - path = "#{ENV["HOME"]}/.one/cli/#{self.conf_file}" - - if File.exists?(path) - return path - else - return "#{TABLE_CONF_PATH}/#{self.conf_file}" - end - end - - private - - def retrieve_resource(id) - factory(id) - end - - def pool_to_array(pool) - if !pool.instance_of?(Hash) - phash = pool.to_hash - else - phash = pool - end - - rname = self.class.rname - - if phash["#{rname}_POOL"] && - phash["#{rname}_POOL"]["#{rname}"] - if phash["#{rname}_POOL"]["#{rname}"].instance_of?(Array) - phash = phash["#{rname}_POOL"]["#{rname}"] - else - phash = [phash["#{rname}_POOL"]["#{rname}"]] - end - else - phash = Array.new - end - - phash - end - - def get_pool - user_flag = OpenNebula::Pool::INFO_ALL - pool = factory_pool(user_flag) - - rc = pool.info - if OpenNebula.is_error?(rc) - return -1, "OpenNebula #{self.class.rname} name not " << - "found, use the ID instead" - end - - return 0, pool - end + def self.conf_file + "onehost.yaml" end - def OpenNebulaHelper.rname_to_id(name, poolname) - return 0, name.to_i if name.match(/^[0123456789]+$/) + def self.state_to_str(id) + id = id.to_i + state_str = Host::HOST_STATES[id] - client=OneHelper.client + return Host::SHORT_HOST_STATES[state_str] + end - pool = case poolname - when "HOST" then OpenNebula::HostPool.new(client) - when "GROUP" then OpenNebula::GroupPool.new(client) - when "USER" then OpenNebula::UserPool.new(client) - when "DATASTORE" then OpenNebula::DatastorePool.new(client) - when "CLUSTER" then OpenNebula::ClusterPool.new(client) - when "VNET" then OpenNebula::VirtualNetworkPool.new(client) - when "IMAGE" then OpenNebula::ImagePool.new(client) - when "VMTEMPLATE" then OpenNebula::TemplatePool.new(client) - when "VM" then OpenNebula::VirtualMachinePool.new(client) - when "ZONE" then OpenNebula::ZonePool.new(client) + def format_pool(options) + config_file = self.class.table_conf + + table = CLIHelper::ShowTable.new(config_file, self) do + column :ID, "ONE identifier for Host", :size=>4 do |d| + d["ID"] + end + + column :NAME, "Name of the Host", :left, :size=>15 do |d| + d["NAME"] + end + + column :CLUSTER, "Name of the Cluster", :left, :size=>9 do |d| + OpenNebulaHelper.cluster_str(d["CLUSTER"]) + end + + column :RVM, "Number of Virtual Machines running", :size=>3 do |d| + d["HOST_SHARE"]["RUNNING_VMS"] + end + + column :ZVM, "Number of Virtual Machine zombies", :size=>3 do |d| + d["TEMPLATE"]["TOTAL_ZOMBIES"] || 0 + end + + column :TCPU, "Total CPU percentage", :size=>4 do |d| + d["HOST_SHARE"]["MAX_CPU"] + end + + column :FCPU, "Free CPU percentage", :size=>4 do |d| + d["HOST_SHARE"]["MAX_CPU"].to_i- + d["HOST_SHARE"]["USED_CPU"].to_i + end + + column :ACPU, "Available cpu percentage (not reserved by VMs)", + :size=>4 do |d| + max_cpu=d["HOST_SHARE"]["MAX_CPU"].to_i + max_cpu=100 if max_cpu==0 + max_cpu-d["HOST_SHARE"]["CPU_USAGE"].to_i + end + + column :TMEM, "Total Memory", :size=>7 do |d| + OpenNebulaHelper.unit_to_str( + d["HOST_SHARE"]["MAX_MEM"].to_i, + options) + end + + column :FMEM, "Free Memory", :size=>7 do |d| + OpenNebulaHelper.unit_to_str( + d["HOST_SHARE"]["FREE_MEM"].to_i, + options) + end + + column :AMEM, "Available Memory (not reserved by VMs)", + :size=>7 do |d| + acpu=d["HOST_SHARE"]["MAX_MEM"].to_i- + d["HOST_SHARE"]["MEM_USAGE"].to_i + OpenNebulaHelper.unit_to_str(acpu,options) + end + + column :REAL_CPU, "Real CPU", :size=>18 do |d| + max_cpu = d["HOST_SHARE"]["MAX_CPU"].to_i + + if max_cpu != 0 + used_cpu = d["HOST_SHARE"]["USED_CPU"].to_i + ratio = (used_cpu*100) / max_cpu + "#{used_cpu} / #{max_cpu} (#{ratio}%)" + else + '-' + end + end + + column :ALLOCATED_CPU, "Allocated CPU)", :size=>18 do |d| + max_cpu = d["HOST_SHARE"]["MAX_CPU"].to_i + cpu_usage = d["HOST_SHARE"]["CPU_USAGE"].to_i + + if max_cpu == 0 && cpu_usage == 0 + '-' + else + cpu_usage = d["HOST_SHARE"]["CPU_USAGE"].to_i + + if max_cpu != 0 + ratio = (cpu_usage*100) / max_cpu + "#{cpu_usage} / #{max_cpu} (#{ratio}%)" + else + "#{cpu_usage} / -" + end + end + end + + column :REAL_MEM, "Real MEM", :size=>18 do |d| + max_mem = d["HOST_SHARE"]["MAX_MEM"].to_i + + if max_mem != 0 + used_mem = d["HOST_SHARE"]["USED_MEM"].to_i + ratio = (used_mem*100) / max_mem + "#{OpenNebulaHelper.unit_to_str(used_mem,options)} / #{OpenNebulaHelper.unit_to_str(max_mem,options)} (#{ratio}%)" + else + '-' + end + end + + column :ALLOCATED_MEM, "Allocated MEM", :size=>18 do |d| + max_mem = d["HOST_SHARE"]["MAX_MEM"].to_i + mem_usage = d["HOST_SHARE"]["MEM_USAGE"].to_i + + if max_mem == 0 && mem_usage == 0 + '-' + else + if max_mem != 0 + ratio = (mem_usage*100) / max_mem + "#{OpenNebulaHelper.unit_to_str(mem_usage,options)} / #{OpenNebulaHelper.unit_to_str(max_mem,options)} (#{ratio}%)" + else + "#{OpenNebulaHelper.unit_to_str(mem_usage,options)} / -" + end + end + end + + column :STAT, "Host status", :left, :size=>6 do |d| + OneHostHelper.state_to_str(d["STATE"]) + end + + default :ID, :NAME, :CLUSTER, :RVM, :ALLOCATED_CPU, :ALLOCATED_MEM, :STAT end + table + end + + + NUM_THREADS = 15 + def sync(host_ids, options) + begin + current_version = File.read(REMOTES_LOCATION+'/VERSION').strip + rescue + STDERR.puts("Could not read #{REMOTES_LOCATION}/VERSION") + exit(-1) + end + + if current_version.empty? + STDERR.puts "Remotes version can not be empty" + exit(-1) + end + + cluster_id = options[:cluster] + + # Get remote_dir (implies oneadmin group) + rc = OpenNebula::System.new(@client).get_configuration + return -1, rc.message if OpenNebula.is_error?(rc) + + conf = rc + remote_dir = conf['SCRIPTS_REMOTE_DIR'] + + # Verify the existence of REMOTES_LOCATION + if !File.directory? REMOTES_LOCATION + error_msg = "'#{REMOTES_LOCATION}' does not exist. " << + "This command must be run in the frontend." + return -1,error_msg + end + + # Touch the update file + FileUtils.touch(File.join(REMOTES_LOCATION,'.update')) + + # Get the Host pool + filter_flag ||= OpenNebula::Pool::INFO_ALL + + pool = factory_pool(filter_flag) + rc = pool.info - if OpenNebula.is_error?(rc) - return -1, "OpenNebula #{poolname} name not found," << - " use the ID instead" - end + return -1, rc.message if OpenNebula.is_error?(rc) - OneHelper.name_to_id(name, pool, poolname) - end + # Assign hosts to threads + i = 0 + queue = Array.new - def OpenNebulaHelper.rname_to_id_desc(poolname) - "OpenNebula #{poolname} name or id" - end - - def OpenNebulaHelper.boolean_to_str(str) - if str.to_i == 1 - "Yes" - else - "No" - end - end - - def OpenNebulaHelper.time_to_str(time, print_seconds=true) - value=time.to_i - if value==0 - value='-' - else - if print_seconds - value=Time.at(value).strftime("%m/%d %H:%M:%S") - else - value=Time.at(value).strftime("%m/%d %H:%M") - end - end - - return value - end - - def OpenNebulaHelper.period_to_str(time, print_seconds=true) - seconds=time.to_i - minutes, seconds=seconds.divmod(60) - hours, minutes=minutes.divmod(60) - days, hours=hours.divmod(24) - - if print_seconds - "%3dd %02dh%02dm%02ds" % [days, hours, minutes, seconds] - else - "%3dd %02dh%02dm" % [days, hours, minutes] - end - end - - def OpenNebulaHelper.short_period_to_str(time, print_seconds=true) - seconds=time.to_i - minutes, seconds=seconds.divmod(60) - hours, minutes=minutes.divmod(60) - - if print_seconds - "%3dh%02dm%02ds" % [hours, minutes, seconds] - else - "%3dh%02dm" % [hours, minutes] - end - end - - BinarySufix = ["K", "M", "G", "T" ] - - def OpenNebulaHelper.unit_to_str(value, options, unit="K") - if options[:kilobytes] - value - else - i=BinarySufix.index(unit).to_i - - while value > 1024 && i < 3 do - value /= 1024.0 - i+=1 + pool.each do |host| + if host_ids + next if !host_ids.include?(host['ID'].to_i) + elsif cluster_id + next if host['CLUSTER_ID'].to_i != cluster_id end - value = (value * 10).round / 10.0 + host_version=host['TEMPLATE/VERSION'] - value = value.to_i if value - value.round == 0 - st = value.to_s + BinarySufix[i] - end - end - - # If the cluster name is empty, returns a '-' char. - # - # @param str [String || Hash] Cluster name, or empty Hash (when ) - # @return [String] the same Cluster name, or '-' if it is empty - def OpenNebulaHelper.cluster_str(str) - if str != nil && !str.empty? - str - else - "-" - end - end - - def OpenNebulaHelper.update_template(id, resource, path=nil, xpath='TEMPLATE') - return update_template_helper(false, id, resource, path, xpath) - end - - def OpenNebulaHelper.append_template(id, resource, path=nil, xpath='TEMPLATE') - return update_template_helper(true, id, resource, path, xpath) - end - - def OpenNebulaHelper.update_template_helper(append, id, resource, path, xpath) - unless path - require 'tempfile' - - tmp = Tempfile.new(id.to_s) - path = tmp.path - - if !append - rc = resource.info - - if OpenNebula.is_error?(rc) - puts rc.message - exit -1 - end - - tmp << resource.template_like_str(xpath) - tmp.flush + if !options[:force] + next if host_version && host_version >= current_version end - editor_path = ENV["EDITOR"] ? ENV["EDITOR"] : EDITOR_PATH - system("#{editor_path} #{path}") + puts "* Adding #{host['NAME']} to upgrade" - unless $?.exitstatus == 0 - puts "Editor not defined" - exit -1 - end - - tmp.close + queue << host end - str = File.read(path) - str - end + # Run the jobs in threads + host_errors = Array.new + queue_lock = Mutex.new + error_lock = Mutex.new + total = queue.length - def self.parse_user_object(user_object) - reg=/^([^\[]+)(?:\[([^\]]+)\])?$/ - - m=user_object.match(reg) - - return nil if !m - - user=nil - if m[2] - user=m[1] - object=m[2] - else - object=m[1] + if total==0 + puts "No hosts are going to be updated." + exit(0) end - [user, object] - end + ts = (1..NUM_THREADS).map do |t| + Thread.new do + while true do + host = nil + size = 0 - def self.create_disk_net(objects, section, name) - template='' + queue_lock.synchronize do + host=queue.shift + size=queue.length + end - objects.each do |obj| - res=parse_user_object(obj) - return [-1, "#{section.capitalize} \"#{obj}\" malformed"] if !res - user, object=*res + break if !host - template<<"#{section.upcase}=[\n" - template<<" #{name.upcase}_UNAME=\"#{user}\",\n" if user - if object.match(/^\d+$/) - template<<" #{name.upcase}_ID=#{object}\n" - else - template<<" #{name.upcase}=\"#{object}\"\n" - end - template<<"]\n" - end if objects + print_update_info(total-size, total, host['NAME']) - [0, template] - end + if options[:rsync] + sync_cmd = "rsync -Laz --delete #{REMOTES_LOCATION}" << + " #{host['NAME']}:#{remote_dir}" + else + sync_cmd = "scp -rp #{REMOTES_LOCATION}/. " << + "#{host['NAME']}:#{remote_dir} 2> /dev/null" + end - def self.create_context(options) - context_options = [:ssh, :net_context, :context, :init, :files_ds] - if !(options.keys & context_options).empty? - lines=[] + `#{sync_cmd} 2>/dev/null` - if options[:ssh] - if options[:ssh]==true - lines<<"SSH_PUBLIC_KEY=\"$USER[SSH_PUBLIC_KEY]\"" - else - begin - key=File.read(options[:ssh]).strip - rescue Exception => e - STDERR.puts e.message - exit(-1) + if !$?.success? + error_lock.synchronize { + host_errors << host['NAME'] + } + else + update_version(host, current_version) end - lines<<"SSH_PUBLIC_KEY=\"#{key}\"" end end + end - if options[:net_context] - lines << "NETWORK = \"YES\"" - end + # Wait for threads to finish + ts.each{|t| t.join} - lines+=options[:context] if options[:context] + puts - if options[:files_ds] - text='FILES_DS="' - text << options[:files_ds].map do |file| - %Q<$FILE[IMAGE=\\"#{file}\\"]> - end.join(' ') - text << '"' - - lines << text - end - - if options[:init] - lines << %Q - end - - if !lines.empty? - "CONTEXT=[\n"< version) + + template=host.template_str + host.update(template) + end + + def factory(id=nil) + if id + OpenNebula::Host.new_with_id(id, @client) + else + xml=OpenNebula::Host.build_xml + OpenNebula::Host.new(xml, @client) + end + end + + def factory_pool(user_flag=-2) + #TBD OpenNebula::HostPool.new(@client, user_flag) + OpenNebula::HostPool.new(@client) + end + + def format_resource(host, options = {}) + str = "%-22s: %-20s" + str_h1 = "%-80s" + + CLIHelper.print_header( + str_h1 % "HOST #{host.id.to_s} INFORMATION", true) + + puts str % ["ID", host.id.to_s] + puts str % ["NAME", host.name] + puts str % ["CLUSTER", OpenNebulaHelper.cluster_str(host['CLUSTER'])] + puts str % ["STATE", host.state_str] + puts str % ["IM_MAD", host['IM_MAD']] + puts str % ["VM_MAD", host['VM_MAD']] + puts str % ["VN_MAD", host['VN_MAD']] + puts str % ["LAST MONITORING TIME", OpenNebulaHelper.time_to_str(host['LAST_MON_TIME'])] + puts + + CLIHelper.print_header(str_h1 % "HOST SHARES", false) + + puts str % ["TOTAL MEM", OpenNebulaHelper.unit_to_str(host['HOST_SHARE/MAX_MEM'].to_i, {})] + puts str % ["USED MEM (REAL)", OpenNebulaHelper.unit_to_str(host['HOST_SHARE/USED_MEM'].to_i, {})] + puts str % ["USED MEM (ALLOCATED)", OpenNebulaHelper.unit_to_str(host['HOST_SHARE/MEM_USAGE'].to_i, {})] + puts str % ["TOTAL CPU", host['HOST_SHARE/MAX_CPU']] + puts str % ["USED CPU (REAL)", host['HOST_SHARE/USED_CPU']] + puts str % ["USED CPU (ALLOCATED)", host['HOST_SHARE/CPU_USAGE']] + puts str % ["RUNNING VMS", host['HOST_SHARE/RUNNING_VMS']] + puts + + datastores = host.to_hash['HOST']['HOST_SHARE']['DATASTORES']['DS'] + + if datastores.nil? + datastores = [] + else + datastores = [datastores].flatten + end + + datastores.each do |datastore| + CLIHelper.print_header(str_h1 % "LOCAL SYSTEM DATASTORE ##{datastore['ID']} CAPACITY", false) + puts str % ["TOTAL:", OpenNebulaHelper.unit_to_str(datastore['TOTAL_MB'].to_i, {},'M')] + puts str % ["USED: ", OpenNebulaHelper.unit_to_str(datastore['USED_MB'].to_i, {},'M')] + puts str % ["FREE:", OpenNebulaHelper.unit_to_str(datastore['FREE_MB'].to_i, {},'M')] + puts + end + + CLIHelper.print_header(str_h1 % "MONITORING INFORMATION", false) + + puts host.template_str + + puts + CLIHelper.print_header("VIRTUAL MACHINES", false) + puts + + onevm_helper=OneVMHelper.new + onevm_helper.client=@client + onevm_helper.list_pool({:filter=>["HOST=#{host.name}"]}, false) end end