Class: VirtualMachineDriver

Inherits:
OpenNebulaDriver show all
Defined in:
lib/VirtualMachineDriver.rb

Overview

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

Direct Known Subclasses

TemplateDriver

Constant Summary collapse

ACTION =

Virtual Machine Driver Protocol constants

{
    :deploy      => "DEPLOY",
    :shutdown    => "SHUTDOWN",
    :reboot      => "REBOOT",
    :reset       => "RESET",
    :cancel      => "CANCEL",
    :save        => "SAVE",
    :restore     => "RESTORE",
    :migrate     => "MIGRATE",
    :poll        => "POLL",
    :log         => "LOG",
    :attach_disk => "ATTACHDISK",
    :detach_disk => "DETACHDISK",
    :snapshot_create => "SNAPSHOTCREATE",
    :snapshot_revert => "SNAPSHOTREVERT",
    :snapshot_delete => "SNAPSHOTDELETE",
    :cleanup         => "CLEANUP",
    :attach_nic  => "ATTACHNIC",
    :detach_nic  => "DETACHNIC",
    :disk_snapshot_create => "DISKSNAPSHOTCREATE",
    :resize_disk => "RESIZEDISK",
    :update_sg   => "UPDATESG",
    :update_conf => "UPDATECONF"
}
POLL_ATTRIBUTE = 
OpenNebula::VirtualMachine::Driver::POLL_ATTRIBUTE
VM_STATE = 
OpenNebula::VirtualMachine::Driver::VM_STATE
HOST_ARG = 
1

Constants included from DriverExecHelper

DriverExecHelper::RESULT

Instance Attribute Summary

Attributes inherited from OpenNebulaDriver

#local_scripts_base_path, #local_scripts_path, #remote_scripts_base_path, #remote_scripts_path

Instance Method Summary collapse

Methods inherited from OpenNebulaDriver

#do_action, parse_actions_list, #start_driver

Methods included from DriverExecHelper

#action_command_line, #action_is_local?, #action_script_name, failed?, #get_info_from_execution, #initialize_helper, #log, #log_method, #read_configuration, #send_message

Methods inherited from ActionManager

#cancel_action, #register_action, #start_listener, #trigger_action

Constructor Details

#initialize(directory, options = {}) ⇒ VirtualMachineDriver

Register default actions for the protocol.

Parameters:

  • directory (String) —

    path inside remotes path where the scripts reside

  • options (Hash) (defaults to: {}) —

    options for OpenNebula driver (check the available options in OpenNebulaDriver#initialize)

Options Hash (options):

  • :threaded (Boolean) — default: true —

    enables or disables threads



70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/VirtualMachineDriver.rb', line 70

def initialize(directory, options={})
    @options={
        :threaded    => true,
        :single_host => 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[:reboot].to_sym,      method("reboot"))
    register_action(ACTION[:reset].to_sym,       method("reset"))
    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"))
    register_action(ACTION[:attach_disk].to_sym, method("attach_disk"))
    register_action(ACTION[:detach_disk].to_sym, method("detach_disk"))
    register_action(ACTION[:snapshot_create].to_sym, method("snapshot_create"))
    register_action(ACTION[:snapshot_revert].to_sym, method("snapshot_revert"))
    register_action(ACTION[:snapshot_delete].to_sym, method("snapshot_delete"))
    register_action(ACTION[:cleanup].to_sym,    method("cleanup"))
    register_action(ACTION[:attach_nic].to_sym, method("attach_nic"))
    register_action(ACTION[:detach_nic].to_sym, method("detach_nic"))
    register_action(ACTION[:disk_snapshot_create].to_sym, method("disk_snapshot_create"))
    register_action(ACTION[:resize_disk].to_sym, method("resize_disk"))
    register_action(ACTION[:update_sg].to_sym, method("update_sg"))
    register_action(ACTION[:update_conf].to_sym, method("update_conf"))
end

Instance Method Details

#attach_disk(id, drv_message) ⇒ Object 



170
171
172
173
 
# File 'lib/VirtualMachineDriver.rb', line 170

def attach_disk(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:attach_disk],RESULT[:failure],id,error)
end

#attach_nic(id, drv_message) ⇒ Object 



180
181
182
183
 
# File 'lib/VirtualMachineDriver.rb', line 180

def attach_nic(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:attach_nic],RESULT[:failure],id,error)
end

#cancel(id, drv_message) ⇒ Object 



145
146
147
148
 
# File 'lib/VirtualMachineDriver.rb', line 145

def cancel(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:cancel],RESULT[:failure],id,error)
end

#cleanup(id, drv_message) ⇒ Object 



220
221
222
223
 
# File 'lib/VirtualMachineDriver.rb', line 220

def cleanup(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:cleanup],RESULT[:failure],id,error)
end

#decode(drv_message) ⇒ REXML::Element

Decodes the encoded XML driver message received from the core

Parameters:

  • drv_message (String) —

    the driver message

Returns:

  • (REXML::Element) —

    the root element of the decoded XML message



107
108
109
110
111
112
 
# File 'lib/VirtualMachineDriver.rb', line 107

def decode(drv_message)
    message = Base64.decode64(drv_message)
    xml_doc = REXML::Document.new(message)

    xml_doc.root
end

#deploy(id, drv_message) ⇒ Object

Virtual Machine Manager Protocol Actions (generic implementation)



125
126
127
128
 
# File 'lib/VirtualMachineDriver.rb', line 125

def deploy(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:deploy],RESULT[:failure],id,error)
end

#detach_disk(id, drv_message) ⇒ Object 



175
176
177
178
 
# File 'lib/VirtualMachineDriver.rb', line 175

def detach_disk(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:detach_disk],RESULT[:failure],id,error)
end

#detach_nic(id, drv_message) ⇒ Object 



185
186
187
188
 
# File 'lib/VirtualMachineDriver.rb', line 185

def detach_nic(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:detach_nic],RESULT[:failure],id,error)
end

#disk_snapshot_create(id, drv_message) ⇒ Object 



205
206
207
208
 
# File 'lib/VirtualMachineDriver.rb', line 205

def disk_snapshot_create(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:disk_snapshot_create],RESULT[:failure],id,error)
end

#local_action(command, id, action) ⇒ Object

Execute a command associated to an action and id on localhost



120
121
122
 
# File 'lib/VirtualMachineDriver.rb', line 120

def local_action(command, id, action)
    super(command,id,ACTION[action])
end

#migrate(id, drv_message) ⇒ Object 



160
161
162
163
 
# File 'lib/VirtualMachineDriver.rb', line 160

def migrate(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:migrate],RESULT[:failure],id,error)
end

#poll(id, drv_message) ⇒ Object 



165
166
167
168
 
# File 'lib/VirtualMachineDriver.rb', line 165

def poll(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:poll],RESULT[:failure],id,error)
end

#reboot(id, drv_message) ⇒ Object 



135
136
137
138
 
# File 'lib/VirtualMachineDriver.rb', line 135

def reboot(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:reboot],RESULT[:failure],id,error)
end

#remotes_action(command, id, host, action, remote_dir, std_in = nil) ⇒ Object

Execute a command associated to an action and id in a remote host.



115
116
117
 
# File 'lib/VirtualMachineDriver.rb', line 115

def remotes_action(command, id, host, action, remote_dir, std_in=nil)
    super(command,id,host,ACTION[action],remote_dir,std_in)
end

#reset(id, drv_message) ⇒ Object 



140
141
142
143
 
# File 'lib/VirtualMachineDriver.rb', line 140

def reset(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:reset],RESULT[:failure],id,error)
end

#resize_disk(id, drv_message) ⇒ Object 



210
211
212
213
 
# File 'lib/VirtualMachineDriver.rb', line 210

def resize_disk(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:resize_disk],RESULT[:failure],id,error)
end

#restore(id, drv_message) ⇒ Object 



155
156
157
158
 
# File 'lib/VirtualMachineDriver.rb', line 155

def restore(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:restore],RESULT[:failure],id,error)
end

#save(id, drv_message) ⇒ Object 



150
151
152
153
 
# File 'lib/VirtualMachineDriver.rb', line 150

def save(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:save],RESULT[:failure],id,error)
end

#shutdown(id, drv_message) ⇒ Object 



130
131
132
133
 
# File 'lib/VirtualMachineDriver.rb', line 130

def shutdown(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:shutdown],RESULT[:failure],id,error)
end

#snapshot_create(id, drv_message) ⇒ Object 



190
191
192
193
 
# File 'lib/VirtualMachineDriver.rb', line 190

def snapshot_create(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:snapshot_create],RESULT[:failure],id,error)
end

#snapshot_delete(id, drv_message) ⇒ Object 



200
201
202
203
 
# File 'lib/VirtualMachineDriver.rb', line 200

def snapshot_delete(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:snapshot_delete],RESULT[:failure],id,error)
end

#snapshot_revert(id, drv_message) ⇒ Object 



195
196
197
198
 
# File 'lib/VirtualMachineDriver.rb', line 195

def snapshot_revert(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:snapshot_revert],RESULT[:failure],id,error)
end

#update_conf(id, drv_message) ⇒ Object 



225
226
227
228
 
# File 'lib/VirtualMachineDriver.rb', line 225

def update_conf(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:update_conf],RESULT[:failure],id,error)
end

#update_sg(id, drv_message) ⇒ Object 



215
216
217
218
 
# File 'lib/VirtualMachineDriver.rb', line 215

def update_sg(id, drv_message)
    error = "Action not implemented by driver #{self.class}"
    send_message(ACTION[:update_sg],RESULT[:failure],id,error)
end