mirror of
https://github.com/OpenNebula/one.git
synced 2026-11-20 03:42:52 +09:00
247 lines
8.2 KiB
Ruby
247 lines
8.2 KiB
Ruby
# -------------------------------------------------------------------------- #
|
|
# Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org) #
|
|
# #
|
|
# 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 "OpenNebulaDriver"
|
|
require "CommandManager"
|
|
require 'base64'
|
|
require 'rexml/document'
|
|
|
|
# Author:: dsa-research.org
|
|
# Copyright:: (c) 2011 Universidad Computense de Madrid
|
|
# License:: Apache License
|
|
|
|
# This class provides basic messaging and logging functionality
|
|
# to implement OpenNebula Drivers. A driver is a program that
|
|
# specialize the OpenNebula behavior by interfacing with specific
|
|
# infrastructure functionalities.
|
|
#
|
|
# A Driver inherits this class and only has to provide methods
|
|
# for each action it wants to receive. The method must be associated
|
|
# with the action name through the register_action function
|
|
class VirtualMachineDriver < OpenNebulaDriver
|
|
|
|
# Virtual Machine Driver Protocol constants
|
|
ACTION = {
|
|
:deploy => "DEPLOY",
|
|
:shutdown => "SHUTDOWN",
|
|
:cancel => "CANCEL",
|
|
:save => "SAVE",
|
|
:restore => "RESTORE",
|
|
:migrate => "MIGRATE",
|
|
:poll => "POLL",
|
|
:log => "LOG"
|
|
}
|
|
|
|
POLL_ATTRIBUTE = {
|
|
:usedmemory => "USEDMEMORY",
|
|
:usedcpu => "USEDCPU",
|
|
:nettx => "NETTX",
|
|
:netrx => "NETRX",
|
|
:state => "STATE"
|
|
}
|
|
|
|
VM_STATE = {
|
|
:active => 'a',
|
|
:paused => 'p',
|
|
:error => 'e',
|
|
:deleted => 'd',
|
|
:unknown => '-'
|
|
}
|
|
|
|
HOST_ARG = 1
|
|
|
|
# Register default actions for the protocol.
|
|
#
|
|
# @param [String] directory path inside remotes path where the scripts
|
|
# reside
|
|
# @param [Hash] options options for OpenNebula driver (check the available
|
|
# options in {OpenNebulaDriver#initialize})
|
|
# @option options [Boolean] :threaded (true) enables or disables threads
|
|
def initialize(directory, options={})
|
|
@options={
|
|
:threaded => true
|
|
}.merge!(options)
|
|
|
|
super(directory, @options)
|
|
|
|
@hosts = Array.new
|
|
|
|
register_action(ACTION[:deploy].to_sym, method("deploy"))
|
|
register_action(ACTION[:shutdown].to_sym, method("shutdown"))
|
|
register_action(ACTION[:cancel].to_sym, method("cancel"))
|
|
register_action(ACTION[:save].to_sym, method("save"))
|
|
register_action(ACTION[:restore].to_sym, method("restore"))
|
|
register_action(ACTION[:migrate].to_sym, method("migrate"))
|
|
register_action(ACTION[:poll].to_sym, method("poll"))
|
|
end
|
|
|
|
# Decodes the encoded XML driver message received from the core
|
|
#
|
|
# @param [String] drv_message the driver message
|
|
# @return [REXML::Element] the root element of the decoded XML message
|
|
def decode(drv_message)
|
|
message = Base64.decode64(drv_message)
|
|
xml_doc = REXML::Document.new(message)
|
|
|
|
xml_doc.root
|
|
end
|
|
|
|
# Execute a command associated to an action and id in a remote host.
|
|
def remotes_action(command, id, host, action, remote_dir, std_in=nil)
|
|
super(command,id,host,ACTION[action],remote_dir,std_in)
|
|
end
|
|
|
|
# Execute a command associated to an action and id on localhost
|
|
def local_action(command, id, action)
|
|
super(command,id,ACTION[action])
|
|
end
|
|
|
|
# Virtual Machine Manager Protocol Actions (generic implementation)
|
|
def deploy(id, drv_message)
|
|
error = "Action not implemented by driver #{self.class}"
|
|
send_message(ACTION[:deploy],RESULT[:failure],id,error)
|
|
end
|
|
|
|
def shutdown(id, drv_message)
|
|
error = "Action not implemented by driver #{self.class}"
|
|
send_message(ACTION[:shutdown],RESULT[:failure],id,error)
|
|
end
|
|
|
|
def cancel(id, drv_message)
|
|
error = "Action not implemented by driver #{self.class}"
|
|
send_message(ACTION[:cancel],RESULT[:failure],id,error)
|
|
end
|
|
|
|
def save(id, drv_message)
|
|
error = "Action not implemented by driver #{self.class}"
|
|
send_message(ACTION[:save],RESULT[:failure],id,error)
|
|
end
|
|
|
|
def restore(id, drv_message)
|
|
error = "Action not implemented by driver #{self.class}"
|
|
send_message(ACTION[:restore],RESULT[:failure],id,error)
|
|
end
|
|
|
|
def migrate(id, drv_message)
|
|
error = "Action not implemented by driver #{self.class}"
|
|
send_message(ACTION[:migrate],RESULT[:failure],id,error)
|
|
end
|
|
|
|
def poll(id, drv_message)
|
|
error = "Action not implemented by driver #{self.class}"
|
|
send_message(ACTION[:poll],RESULT[:failure],id,error)
|
|
end
|
|
|
|
private
|
|
# Interface to handle the pending events from the ActionManager Interface
|
|
def delete_running_action(action_id)
|
|
action=@action_running[action_id]
|
|
if action
|
|
@hosts.delete(action[:args][HOST_ARG])
|
|
@action_running.delete(action_id)
|
|
end
|
|
end
|
|
|
|
def get_first_runable
|
|
action_index=nil
|
|
@action_queue.each_with_index do |action, index|
|
|
if action[:args][HOST_ARG]
|
|
if !@hosts.include?(action[:args][HOST_ARG])
|
|
action_index=index
|
|
break
|
|
end
|
|
else
|
|
action_index=index
|
|
break
|
|
end
|
|
end
|
|
|
|
return action_index
|
|
end
|
|
|
|
def get_runable_action
|
|
action_index=get_first_runable
|
|
|
|
if action_index
|
|
action=@action_queue[action_index]
|
|
else
|
|
action=nil
|
|
end
|
|
|
|
if action
|
|
@hosts << action[:args][HOST_ARG] if action[:args][HOST_ARG]
|
|
@action_queue.delete_at(action_index)
|
|
end
|
|
|
|
return action
|
|
end
|
|
|
|
def empty_queue
|
|
get_first_runable==nil
|
|
end
|
|
end
|
|
|
|
################################################################
|
|
################################################################
|
|
|
|
if __FILE__ == $0
|
|
|
|
class TemplateDriver < VirtualMachineDriver
|
|
def initialize
|
|
super('vmm/dummy',
|
|
:concurrency => 15,
|
|
:threaded => true)
|
|
end
|
|
|
|
def deploy(id, host, remote_dfile, not_used)
|
|
#MUST return deploy_id if deployment was successfull
|
|
deploy_id = "-"
|
|
send_message(ACTION[:deploy],RESULT[:success],id,deploy_id)
|
|
end
|
|
|
|
def shutdown(id, host, deploy_id, not_used)
|
|
send_message(ACTION[:shutdown],RESULT[:success],id)
|
|
end
|
|
|
|
def cancel(id, host, deploy_id, not_used)
|
|
send_message(ACTION[:cancel],RESULT[:success],id)
|
|
end
|
|
|
|
def save(id, host, deploy_id, file)
|
|
send_message(ACTION[:save],RESULT[:success],id)
|
|
end
|
|
|
|
def restore(id, host, deploy_id , file)
|
|
send_message(ACTION[:restore],RESULT[:success],id)
|
|
end
|
|
|
|
def migrate(id, host, deploy_id, dest_host)
|
|
send_message(ACTION[:migrate],RESULT[:success],id)
|
|
end
|
|
|
|
def poll(id, host, deploy_id, not_used)
|
|
# monitor_info: string in the form "VAR=VAL VAR=VAL ... VAR=VAL"
|
|
# known VAR are in POLL_ATTRIBUTES. VM states VM_STATES
|
|
monitor_info = "#{POLL_ATTRIBUTE[:state]}=#{VM_STATE[:active]} " \
|
|
"#{POLL_ATTRIBUTE[:nettx]}=12345"
|
|
|
|
send_message(ACTION[:poll],RESULT[:success],id,monitor_info)
|
|
end
|
|
end
|
|
|
|
sd = TemplateDriver.new
|
|
sd.start_driver
|
|
end
|