#!/usr/bin/env ruby
# -------------------------------------------------------------------------- #
# Copyright 2002-2015, 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 #
# #
# 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. #
#--------------------------------------------------------------------------- #
# Set up the environment for the driver
ONE_LOCATION = ENV["ONE_LOCATION"]
if !ONE_LOCATION
RUBY_LIB_LOCATION = "/usr/lib/one/ruby"
MAD_LOCATION = "/usr/lib/one/mads"
ETC_LOCATION = "/etc/one/"
else
RUBY_LIB_LOCATION = ONE_LOCATION + "/lib/ruby"
MAD_LOCATION = ONE_LOCATION + "/lib/mads"
ETC_LOCATION = ONE_LOCATION + "/etc/"
end
$: << RUBY_LIB_LOCATION
$: << MAD_LOCATION
require "VirtualMachineDriver"
require 'one_vnm'
require 'one_tm'
require 'getoptlong'
require 'ssh_stream'
require 'rexml/document'
require 'pp'
class VmmAction
# List of xpaths required by the VNM driver actions
XPATH_LIST = %w(ID DEPLOY_ID TEMPLATE/NIC HISTORY_RECORDS/HISTORY/HOSTNAME)
attr_reader :data
# Initialize a VmmAction object
# @param[OpenNebula::ExecDriver] Driver to be used for the actions
# @param[String] Id of the VM
# @param[String] name of the actions as described in the VMM protocol
# @param[xml_data] data sent from OpenNebula core
def initialize(driver, id, action, xml_data)
# Initialize object with xml data
@vmm = driver
@id = id
@main_action = action
@xml_data = @vmm.decode(xml_data)
@data = Hash.new
get_data(:host)
get_data(:net_drv)
get_data(:deploy_id)
get_data(:checkpoint_file)
get_data(:local_dfile, :LOCAL_DEPLOYMENT_FILE)
get_data(:remote_dfile, :REMOTE_DEPLOYMENT_FILE)
# For migration
get_data(:dest_host, :MIGR_HOST)
get_data(:dest_driver, :MIGR_NET_DRV)
# For disk hotplugging
get_data(:disk_target_path)
get_data(:tm_command)
# VM template
vm_template = @xml_data.elements['VM'].to_s
@data[:vm] = Base64.encode64(vm_template).delete("\n")
# VM data for VNM
vm_template_xml = REXML::Document.new(vm_template).root
vm_vnm_xml = REXML::Document.new('').root
XPATH_LIST.each do |xpath|
elements = vm_template_xml.elements.each(xpath) do |element|
add_element_to_path(vm_vnm_xml, element, xpath)
end
end
# Initialize streams and vnm
@ssh_src = @vmm.get_ssh_stream(action, @data[:host], @id)
@vnm_src = VirtualNetworkDriver.new(@data[:net_drv],
:local_actions => @vmm.options[:local_actions],
:message => vm_vnm_xml.to_s,
:ssh_stream => @ssh_src)
if @data[:dest_host] and !@data[:dest_host].empty?
@ssh_dst = @vmm.get_ssh_stream(action, @data[:dest_host], @id)
@vnm_dst = VirtualNetworkDriver.new(@data[:dest_driver],
:local_actions => @vmm.options[:local_actions],
:message => vm_vnm_xml.to_s,
:ssh_stream => @ssh_dst)
end
@tm = TransferManagerDriver.new(nil)
end
#Execute a set of steps defined with
# - :driver :vmm or :vnm to execute the step
# - :action for the step
# - :parameters command line paremeters for the action
# - :destination use next host
# - :fail_action steps to be executed if steps fail
# - :stdin for the action
# @param [Array] of steps
def run(steps, info_on_success = nil)
result = execute_steps(steps)
@ssh_src.close if @ssh_src
@ssh_dst.close if @ssh_dst
#Prepare the info for the OpenNebula core
if DriverExecHelper.failed?(result)
info = @data[:failed_info]
else
info = @data["#{@main_action.to_s}_info".to_sym]
end
@vmm.send_message(VirtualMachineDriver::ACTION[@main_action],
result, @id, info)
end
private
DRIVER_NAMES = {
:vmm => "virtualization driver",
:vnm => "network driver",
:tm => "transfer manager driver"
}
# Executes a set of steps. If one step fails any recover action is performed
# and the step execution breaks.
# @param [Array] array of steps to be executed
# @return [String, Hash] "SUCCESS/FAILURE" for the step set, and
# information associated to each step (by :_info). In case of
# failure information is also in [:failed_info]
def execute_steps(steps)
result = DriverExecHelper.const_get(:RESULT)[:failure]
steps.each do |step|
# Execute Step
case step[:driver]
when :vmm
if step[:destination]
host = @data[:dest_host]
ssh = @ssh_dst
else
host = @data[:host]
ssh = @ssh_src
end
result, info = @vmm.do_action(get_parameters(step[:parameters]),
@id,
host,
step[:action],
:ssh_stream => ssh,
:respond => false,
:stdin => step[:stdin])
when :vnm
if step[:destination]
vnm = @vnm_dst
else
vnm = @vnm_src
end
result, info = vnm.do_action(@id, step[:action],
:parameters => get_parameters(step[:parameters]))
when :tm
result, info = @tm.do_transfer_action(@id, step[:parameters])
else
result = DriverExecHelper.const_get(:RESULT)[:failure]
info = "No driver in #{step[:action]}"
end
# Save the step info
@data["#{step[:action]}_info".to_sym] = info.strip
# Roll back steps, store failed info and break steps
if DriverExecHelper.failed?(result)
execute_steps(step[:fail_actions]) if step[:fail_actions]
@data[:failed_info] = info
@vmm.log(@id,
"Failed to execute #{DRIVER_NAMES[step[:driver]]} " \
"operation: #{step[:action]}.")
if step[:no_fail]
result = DriverExecHelper::RESULT[:success]
else
break
end
else
@vmm.log(@id,
"Successfully execute #{DRIVER_NAMES[step[:driver]]} " \
"operation: #{step[:action]}.")
end
end
return result
end
# Prepare the parameters for the action step generating a blank separated
# list of command arguments
# @param [Hash] an action step
def get_parameters(step_params)
parameters = step_params || []
parameters.map do |param|
if Symbol===param
"\'#{@data[param].to_s}\'"
else
"\'#{param}\'"
end
end.join(' ')
end
# Extracts data from the XML argument of the VMM action
# @param [Symbol] corresponding to a XML element
# @param [String] an xpath for the XML element
# @return [String] the element value
def get_data(name, xml_path=nil)
if xml_path
path=xml_path.to_s
else
path=name.to_s.upcase
end
if (elem = @xml_data.elements[path])
@data[name]=elem.text
end
end
# Adds a REXML node to a specific xpath
#
# @param [REXML::Element] xml document to add to
# @param [REXML::Element] element to add
# @param [String] path where the element is inserted in the xml document
# @return [REXML::Element]
def add_element_to_path(xml, element, path)
root = xml
path.split('/')[0..-2].each do |path_element|
xml = xml.add_element(path_element) if path_element
end
xml.add_element(element)
root
end
end
# The main class for the Sh driver
class ExecDriver < VirtualMachineDriver
attr_reader :options
# Initializes the VMM driver
# @param [String] hypervisor name identifies the plugin
# @param [OpenNebulaDriver::options]
def initialize(hypervisor, options={})
@options={
:threaded => true
}.merge!(options)
if options[:shell]
@shell=options[:shell]
else
@shell='bash'
end
super("vmm/#{hypervisor}", @options)
@hypervisor = hypervisor
end
# Creates an SshStream to execute commands on the target host
# @param[String] the hostname of the host
# @param[String] id of the VM to log messages
# @return [SshStreamCommand]
def get_ssh_stream(aname, host, id)
SshStreamCommand.new(host,
@remote_scripts_base_path,
log_method(id), nil, @shell)
end
#---------------------------------------------------------------------------
# Virtual Machine Manager Protocol Actions
#---------------------------------------------------------------------------
#
# DEPLOY action, sends the deployment file to remote host
#
def deploy(id, drv_message)
action = VmmAction.new(self, id, :deploy, drv_message)
# ----------------------------------------------------------------------
# Initialization of deployment data
# ----------------------------------------------------------------------
local_dfile=action.data[:local_dfile]
if !local_dfile || File.zero?(local_dfile)
send_message(ACTION[:deploy],RESULT[:failure],id,
"Cannot open deployment file #{local_dfile}")
return
end
domain = File.read(local_dfile)
if action_is_local?(:deploy)
dfile = action.data[:local_dfile]
else
dfile = action.data[:remote_dfile]
end
# ----------------------------------------------------------------------
# Deployment Steps
# ----------------------------------------------------------------------
steps=[
# Execute pre-boot networking setup
{
:driver => :vnm,
:action => :pre
},
# Boot the Virtual Machine
{
:driver => :vmm,
:action => :deploy,
:parameters => [dfile, :host],
:stdin => domain,
},
# Execute post-boot networking setup
{
:driver => :vnm,
:action => :post,
:parameters => [:deploy_info],
:fail_actions => [
{
:driver => :vmm,
:action => :cancel,
:parameters => [:deploy_info, :host]
}
]
}
]
action.run(steps)
end
#
# SHUTDOWN action, graceful shutdown and network clean up
#
def shutdown(id, drv_message)
action = VmmAction.new(self, id, :shutdown, drv_message)
steps=[
# Shutdown the Virtual Machine
{
:driver => :vmm,
:action => :shutdown,
:parameters => [:deploy_id, :host]
},
# Execute networking clean up operations
{
:driver => :vnm,
:action => :clean
}
]
action.run(steps)
end
#
# CANCEL action, destroys a VM and network clean up
#
def cancel(id, drv_message)
action = VmmAction.new(self, id, :cancel, drv_message)
steps=[
# Cancel the Virtual Machine
{
:driver => :vmm,
:action => :cancel,
:parameters => [:deploy_id, :host]
},
# Execute networking clean up operations
{
:driver => :vnm,
:action => :clean
}
]
action.run(steps)
end
#
# SAVE action, stops the VM and saves its state, network is cleaned up
#
def save(id, drv_message)
action = VmmAction.new(self, id, :save, drv_message)
steps=[
# Save the Virtual Machine state
{
:driver => :vmm,
:action => :save,
:parameters => [:deploy_id, :checkpoint_file, :host]
},
# Execute networking clean up operations
{
:driver => :vnm,
:action => :clean
}
]
action.run(steps)
end
#
# RESTORE action, restore a VM from a previous state, and restores network
#
def restore(id, drv_message)
action=VmmAction.new(self, id, :restore, drv_message)
steps=[
# Execute pre-boot networking setup
{
:driver => :vnm,
:action => :pre
},
# Restore the Virtual Machine from checkpoint
{
:driver => :vmm,
:action => :restore,
:parameters => [:checkpoint_file, :host, :deploy_id]
},
# Execute post-boot networking setup
{
:driver => :vnm,
:action => :post,
:parameters => [:deploy_id],
:fail_actions => [
{
:driver => :vmm,
:action => :cancel,
:parameters => [:deploy_id, :host]
}
],
}
]
action.run(steps)
end
#
# MIGRATE (live) action, migrates a VM to another host creating network
#
def migrate(id, drv_message)
action = VmmAction.new(self, id, :migrate, drv_message)
pre = "PRE"
post = "POST"
pre << action.data[:tm_command] << " " << action.data[:vm]
post << action.data[:tm_command] << " " << action.data[:vm]
steps=[
# Execute a pre-migrate TM setup
{
:driver => :tm,
:action => :tm_premigrate,
:parameters => pre.split
},
# Execute pre-boot networking setup on migrating host
{
:driver => :vnm,
:action => :pre,
:destination => true
},
# Migrate the Virtual Machine
{
:driver => :vmm,
:action => :migrate,
:parameters => [:deploy_id, :dest_host, :host]
},
# Execute networking clean up operations
# NOTE: VM is now in the new host. If we fail from now on, oned will
# assume that the VM is in the previous host but it is in fact
# migrated. Log errors will be shown in vm.log
{
:driver => :vnm,
:action => :clean,
:no_fail => true
},
# Execute post-boot networking setup on migrating host
{
:driver => :vnm,
:action => :post,
:parameters => [:deploy_id],
:destination => :true,
:no_fail => true
},
{
:driver => :tm,
:action => :tm_postmigrate,
:parameters => post.split,
:no_fail => true
},
]
action.run(steps)
end
#
# POLL action, gets information of a VM
#
def poll(id, drv_message)
data = decode(drv_message)
host = data.elements['HOST'].text
deploy_id = data.elements['DEPLOY_ID'].text
do_action("#{deploy_id} #{host}", id, host, ACTION[:poll])
end
#
# REBOOT action, reboots a running VM
#
def reboot(id, drv_message)
data = decode(drv_message)
host = data.elements['HOST'].text
deploy_id = data.elements['DEPLOY_ID'].text
do_action("#{deploy_id} #{host}", id, host, ACTION[:reboot])
end
#
# RESET action, resets a running VM
#
def reset(id, drv_message)
data = decode(drv_message)
host = data.elements['HOST'].text
deploy_id = data.elements['DEPLOY_ID'].text
do_action("#{deploy_id} #{host}", id, host, ACTION[:reset])
end
#
# ATTACHDISK action, attaches a disk to a running VM
#
def attach_disk(id, drv_message)
action = ACTION[:attach_disk]
xml_data = decode(drv_message)
tm_command = ensure_xpath(xml_data, id, action, 'TM_COMMAND') || return
tm_rollback= xml_data.elements['TM_COMMAND_ROLLBACK'].text.strip
target_xpath = "VM/TEMPLATE/DISK[ATTACH='YES']/TARGET"
target = ensure_xpath(xml_data, id, action, target_xpath) || return
target_index = target.downcase[-1..-1].unpack('c').first - 97
action = VmmAction.new(self, id, :attach_disk, drv_message)
# Bug #1355, argument character limitation in ESX
# Message not used in vmware anyway
if @hypervisor == "vmware"
drv_message = "drv_message"
end
steps = [
# Perform a PROLOG on the disk
{
:driver => :tm,
:action => :tm_attach,
:parameters => tm_command.split
},
# Run the attach vmm script
{
:driver => :vmm,
:action => :attach_disk,
:parameters => [
:deploy_id,
:disk_target_path,
target,
target_index,
drv_message
],
:fail_actions => [
{
:driver => :tm,
:action => :tm_detach,
:parameters => tm_rollback.split
}
]
}
]
action.run(steps)
end
#
# DETACHDISK action, attaches a disk to a running VM
#
def detach_disk(id, drv_message)
action = ACTION[:detach_disk]
xml_data = decode(drv_message)
tm_command = ensure_xpath(xml_data, id, action, 'TM_COMMAND') || return
target_xpath = "VM/TEMPLATE/DISK[ATTACH='YES']/TARGET"
target = ensure_xpath(xml_data, id, action, target_xpath) || return
target_index = target.downcase[-1..-1].unpack('c').first - 97
action = VmmAction.new(self, id, :detach_disk, drv_message)
steps = [
# Run the detach vmm script
{
:driver => :vmm,
:action => :detach_disk,
:parameters => [
:deploy_id,
:disk_target_path,
target,
target_index
]
},
# Perform an EPILOG on the disk
{
:driver => :tm,
:action => :tm_detach,
:parameters => tm_command.split
}
]
action.run(steps)
end
#
# SNAPSHOTCREATE action, creates a new system snapshot
#
def snapshot_create(id, drv_message)
action = ACTION[:snapshot_create]
xml_data = decode(drv_message)
host = xml_data.elements['HOST'].text
deploy_id = xml_data.elements['DEPLOY_ID'].text
snap_id_xpath = "VM/TEMPLATE/SNAPSHOT[ACTIVE='YES']/SNAPSHOT_ID"
snap_id = xml_data.elements[snap_id_xpath].text.to_i
do_action("#{deploy_id} #{snap_id}",
id,
host,
ACTION[:snapshot_create],
:script_name => "snapshot_create")
end
#
# SNAPSHOTREVERT action, reverts to a system snapshot
#
def snapshot_revert(id, drv_message)
action = ACTION[:snapshot_revert]
xml_data = decode(drv_message)
host = xml_data.elements['HOST'].text
deploy_id = xml_data.elements['DEPLOY_ID'].text
snap_id_xpath = "VM/TEMPLATE/SNAPSHOT[ACTIVE='YES']/HYPERVISOR_ID"
snapshot_name = xml_data.elements[snap_id_xpath].text
do_action("#{deploy_id} #{snapshot_name}",
id,
host,
ACTION[:snapshot_revert],
:script_name => "snapshot_revert")
end
#
# SNAPSHOTDELETE action, deletes a system snapshot
#
def snapshot_delete(id, drv_message)
action = ACTION[:snapshot_delete]
xml_data = decode(drv_message)
host = xml_data.elements['HOST'].text
deploy_id = xml_data.elements['DEPLOY_ID'].text
snap_id_xpath = "VM/TEMPLATE/SNAPSHOT[ACTIVE='YES']/HYPERVISOR_ID"
snapshot_name = xml_data.elements[snap_id_xpath].text
do_action("#{deploy_id} #{snapshot_name}",
id,
host,
ACTION[:snapshot_delete],
:script_name => "snapshot_delete")
end
#
# CLEANUP action, frees resources allocated in a host: VM and disk images
#
def cleanup(id, drv_message)
aname = ACTION[:cleanup]
xml_data = decode(drv_message)
tm_command = xml_data.elements['TM_COMMAND'].text
mhost = xml_data.elements['MIGR_HOST'].text
deploy_id = xml_data.elements['DEPLOY_ID'].text
action = VmmAction.new(self, id, :cleanup, drv_message)
steps = Array.new
# Cancel the VM at host (only if we have a valid deploy-id)
if deploy_id && !deploy_id.empty?
steps <<
{
:driver => :vmm,
:action => :cancel,
:parameters => [:deploy_id, :host],
:no_fail => true
}
steps <<
{
:driver => :vnm,
:action => :clean,
:no_fail => true
}
end
# Cancel the VM at the previous host (in case of migration)
if mhost && !mhost.empty?
steps <<
{
:driver => :vmm,
:action => :cancel,
:parameters => [:deploy_id, :dest_host],
:destination => true,
:no_fail => true
}
steps <<
{
:driver => :vnm,
:action => :clean,
:destination => true,
:no_fail => true
}
end
# Cleans VM disk images and directory
tm_command.each_line { |tc|
tc.strip!
steps <<
{
:driver => :tm,
:action => :tm_delete,
:parameters => tc.split,
:no_fail => true
} if !tc.empty?
} if tm_command
action.run(steps)
end
#
# ATTACHNIC action to attach a new nic interface
#
def attach_nic(id, drv_message)
xml_data = decode(drv_message)
begin
source = xml_data.elements["VM/TEMPLATE/NIC[ATTACH='YES']/BRIDGE"]
mac = xml_data.elements["VM/TEMPLATE/NIC[ATTACH='YES']/MAC"]
nic_id = xml_data.elements["VM/TEMPLATE/NIC[ATTACH='YES']/NIC_ID"]
source = source.text.strip
mac = mac.text.strip
nic_id = nic_id.text.strip
rescue
send_message(action, RESULT[:failure], id,
"Error in #{ACTION[:attach_nic]}, BRIDGE and MAC needed in NIC")
return
end
model = xml_data.elements["VM/TEMPLATE/NIC[ATTACH='YES']/MODEL"]
model = model.text if !model.nil?
model = model.strip if !model.nil?
model = "-" if model.nil?
net_drv = xml_data.elements["NET_DRV"]
net_drv = net_drv.text if !net_drv.nil?
net_drv = net_drv.strip if !net_drv.nil?
net_drv = "-" if net_drv.nil?
action = VmmAction.new(self, id, :attach_nic, drv_message)
steps=[
# Execute pre-attach networking setup
{
:driver => :vnm,
:action => :pre
},
# Attach the new NIC
{
:driver => :vmm,
:action => :attach_nic,
:parameters => [:deploy_id, mac, source, model, net_drv]
},
# Execute post-boot networking setup
{
:driver => :vnm,
:action => :post,
:parameters => [:deploy_id, nic_id],
:fail_actions => [
{
:driver => :vmm,
:action => :detach_nic,
:parameters => [:deploy_id, mac]
}
]
}
]
action.run(steps)
end
#
# DETACHNIC action to detach a nic interface
#
def detach_nic(id, drv_message)
xml_data = decode(drv_message)
begin
mac = xml_data.elements["VM/TEMPLATE/NIC[ATTACH='YES']/MAC"]
nic_id = xml_data.elements["VM/TEMPLATE/NIC[ATTACH='YES']/NIC_ID"]
mac = mac.text.strip
nic_id = nic_id.text.strip
rescue
send_message(action, RESULT[:failure], id,
"Error in #{ACTION[:detach_nic]}, MAC needed in NIC")
return
end
action = VmmAction.new(self, id, :detach_nic, drv_message)
steps=[
# Detach the NIC
{
:driver => :vmm,
:action => :detach_nic,
:parameters => [:deploy_id, mac]
},
# Clean networking setup
{
:driver => :vnm,
:action => :clean,
:parameters => [nic_id]
}
]
action.run(steps)
end
private
def ensure_xpath(xml_data, id, action, xpath)
begin
value = xml_data.elements[xpath].text.strip
raise if value.empty?
value
rescue
send_message(action, RESULT[:failure], id,
"Cannot perform #{action}, expecting #{xpath}")
nil
end
end
end
################################################################################
#
# Virtual Machine Manager Execution Driver - Main Program
#
################################################################################
opts = GetoptLong.new(
[ '--retries', '-r', GetoptLong::OPTIONAL_ARGUMENT ],
[ '--threads', '-t', GetoptLong::OPTIONAL_ARGUMENT ],
[ '--local', '-l', GetoptLong::REQUIRED_ARGUMENT ],
[ '--shell', '-s', GetoptLong::REQUIRED_ARGUMENT ],
[ '--parallel', '-p', GetoptLong::NO_ARGUMENT ]
)
hypervisor = ''
retries = 0
threads = 15
shell = 'bash'
local_actions = {}
single_host = true
begin
opts.each do |opt, arg|
case opt
when '--retries'
retries = arg.to_i
when '--threads'
threads = arg.to_i
when '--local'
local_actions=OpenNebulaDriver.parse_actions_list(arg)
when '--shell'
shell = arg
when '--parallel'
single_host = false
end
end
rescue Exception => e
exit(-1)
end
if ARGV.length >= 1
hypervisor = ARGV.shift
else
exit(-1)
end
exec_driver = ExecDriver.new(hypervisor,
:concurrency => threads,
:retries => retries,
:local_actions => local_actions,
:shell => shell,
:single_host => single_host)
exec_driver.start_driver