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