Philippe Caseiro
e9ff4ad34c
Le service onenode ne se lance pas a cause d'une boucle dans les dépendances de services. Pour régler le problème on le lance après la multi-user.target De plus au moment ou le service se lance opennebula n'est pas complètement lancé alors le script essaye d'ouvrir des connections pendant 20 secondes avant de remonter un problème. Enfin on garde une liste des machines qui sont "running" avant l'arrêt du serveur pour pouvoir les relance proprement. Contribution de Cadoles (htts://www.cadoles.com) ref #20338 @6h
231 lines
4.7 KiB
Ruby
Executable File
231 lines
4.7 KiB
Ruby
Executable File
#!/usr/bin/env ruby
|
|
|
|
##############################################################################
|
|
# Environment Configuration
|
|
##############################################################################
|
|
ONE_LOCATION=ENV["ONE_LOCATION"]
|
|
USER=ENV["user"]
|
|
RUNVMFILE="/var/lib/one/running.bck"
|
|
TIMEOUT=20
|
|
|
|
# oneadmin user flag value
|
|
USERFLAG=-2
|
|
|
|
if !ONE_LOCATION
|
|
RUBY_LIB_LOCATION="/usr/lib/one/ruby"
|
|
else
|
|
RUBY_LIB_LOCATION=ONE_LOCATION+"/lib/ruby"
|
|
end
|
|
|
|
$: << RUBY_LIB_LOCATION
|
|
|
|
##############################################################################
|
|
# Required libraries
|
|
##############################################################################
|
|
require 'opennebula'
|
|
require 'optparse'
|
|
|
|
include OpenNebula
|
|
|
|
MAXWAIT=60
|
|
INTERVAL=1
|
|
|
|
def _wait(vm, st)
|
|
wait = 0
|
|
while vm.status != st
|
|
vm.info
|
|
if vm.status == 'unkn'
|
|
break
|
|
end
|
|
wait += INTERVAL
|
|
sleep(INTERVAL)
|
|
if wait >= MAXWAIT
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
def CreoleGet(variable)
|
|
begin
|
|
value = `CreoleGet #{variable}`
|
|
return value
|
|
rescue
|
|
return nil
|
|
end
|
|
end
|
|
|
|
#
|
|
# NAME: _do_suspend
|
|
# PARAM: OpenNebula::VirtualMachine object
|
|
# AIM: Suspend a virtual machine
|
|
#
|
|
def _do_suspend(vm, wait)
|
|
fd = File.open(RUNVMFILE,'a')
|
|
if vm.status == "runn"
|
|
puts("Suspending #{vm.name} ...")
|
|
fd.write("#{vm.id}\n")
|
|
vm.suspend
|
|
if wait
|
|
_wait(vm, "susp")
|
|
end
|
|
end
|
|
fd.close
|
|
end
|
|
|
|
#
|
|
# NAME: _do_resume
|
|
# PARAM: OpenNebula::VirtualMachine object
|
|
# AIM: Resum a suspended virtual machines
|
|
#
|
|
def _do_resume(vm, wait, force=FALSE)
|
|
if force
|
|
vm.resume
|
|
else
|
|
if vm.status == "susp"
|
|
puts("Resume on #{vm.name}")
|
|
vm.resume
|
|
# elsif vm.status == 'save'
|
|
# puts("Recover on #{vm.name}")
|
|
# # Try to recover VM with retry action
|
|
# vm.recover(2)
|
|
# vm.resume
|
|
elsif vm.status == 'unkn'
|
|
puts("Resume on #{vm.name}")
|
|
vm.resume
|
|
else
|
|
return -1
|
|
end
|
|
end
|
|
|
|
if wait
|
|
_wait(vm, "runn")
|
|
end
|
|
end
|
|
|
|
|
|
options = {:creds => nil, :action => nil, :endpoint => nil,
|
|
:timeout => nil}
|
|
|
|
parser = OptionParser.new do|opts|
|
|
opts.banner = "Usage: #{File.basename(__FILE__)} [options]"
|
|
opts.on('-c', '--creds file', 'Crediential file') do |value|
|
|
options[:creds] = value;
|
|
end
|
|
|
|
opts.on('-a', '--action action', 'Action to run') do |value|
|
|
options[:action] = value;
|
|
end
|
|
|
|
opts.on('-e', '--end-point url', 'End point URL') do |value|
|
|
options[:endpoint] = value;
|
|
end
|
|
|
|
opts.on('-t', '--timeout timeout', 'Timeout for opennebula connection') do |value|
|
|
options[:timeout] = value.to_i;
|
|
end
|
|
|
|
opts.on('-w', '--wait', 'Wait for action ends') do |w|
|
|
options[:wait] = w
|
|
end
|
|
|
|
opts.on('-h', '--help', 'Displays Help') do
|
|
puts opts
|
|
exit
|
|
end
|
|
|
|
|
|
end
|
|
|
|
parser.parse!
|
|
|
|
# OpenNebula credentials
|
|
|
|
if not options[:creds]
|
|
options[:creds] = "/var/lib/one/.one/one_auth"
|
|
end
|
|
|
|
if not options[:action]
|
|
options[:action] = "status"
|
|
end
|
|
|
|
if not options[:endpoint]
|
|
ip = CreoleGet('adresse_ip_eth0').chomp
|
|
options[:endpoint] = "http://#{ip}:2633/RPC2"
|
|
end
|
|
|
|
if not options[:timeout]
|
|
options[:timeout] = TIMEOUT
|
|
end
|
|
|
|
# Actions
|
|
SUPPORTED = ['status', 'boot', 'resume', 'shutdown', 'suspend']
|
|
|
|
|
|
if not SUPPORTED.include?(options[:action])
|
|
puts("Action : #{options[:action]}) is not supported")
|
|
exit(-1)
|
|
end
|
|
|
|
begin
|
|
File.readlines(options[:creds]).each do |line|
|
|
CREDENTIALS = line
|
|
end
|
|
rescue
|
|
puts("#{options[:creds]}: Problem loading credentials, check if file exists.")
|
|
exit(-1)
|
|
end
|
|
|
|
begin
|
|
client = Client.new(CREDENTIALS, options[:endpoint])
|
|
|
|
vm_pool = VirtualMachinePool.new(client, USERFLAG)
|
|
|
|
if File.exist?(RUNVMFILE)
|
|
running_vms = File.open(RUNVMFILE,'r')
|
|
else
|
|
running_vms = []
|
|
end
|
|
|
|
rc = vm_pool.info
|
|
cnt = 0
|
|
while OpenNebula.is_error?(rc)
|
|
if cnt == options[:timeout]
|
|
puts rc.message
|
|
exit(-1)
|
|
end
|
|
rc = vm_pool.info
|
|
sleep(1)
|
|
cnt += 1
|
|
end
|
|
|
|
vm_pool.each do |vm|
|
|
case options[:action]
|
|
when "status"
|
|
puts("#{vm.name}\t#{vm.status}")
|
|
when "boot"
|
|
puts("DEBUG #{vm.status}")
|
|
if vm.status == "unkn"
|
|
puts("Booting #{vm.name} ...")
|
|
vm.boot
|
|
end
|
|
when "suspend"
|
|
_do_suspend(vm, options[:wait])
|
|
when "resume"
|
|
force = FALSE
|
|
if running_vms.include?('vm.id')
|
|
force = TRUE
|
|
end
|
|
_do_resume(vm, options[:wait], force)
|
|
else
|
|
puts("#{vm.name}\t#{vm.status}")
|
|
end
|
|
end
|
|
if options[:action] == "resume"
|
|
File.truncate(RUNVMFILE, 0)
|
|
end
|
|
rescue Exception => e
|
|
puts e.message
|
|
exit(-1)
|
|
end
|
|
exit 0
|
|
|