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",
    :resize      => "RESIZE",
    :backup      => "BACKUP",
    :update_nic   => "UPDATENIC"
}
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



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
102
103
104
105
106
107
 
# File 'lib/VirtualMachineDriver.rb', line 73

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"))
    register_action(ACTION[:resize].to_sym, method("resize"))
    register_action(ACTION[:backup].to_sym, method("backup"))
    register_action(ACTION[:update_nic].to_sym, method("update_nic"))
end

Instance Method Details

#attach_disk(id, drv_message) ⇒ Object 



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

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 



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

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

#backup(id, drv_message) ⇒ Object 



241
242
243
244
 
# File 'lib/VirtualMachineDriver.rb', line 241

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

#cancel(id, drv_message) ⇒ Object 



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

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 



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

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



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

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)



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

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 



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

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 



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

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 



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

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



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

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

#migrate(id, drv_message) ⇒ Object 



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

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 



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

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 



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

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.



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

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 



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

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

#resize(id, drv_message) ⇒ Object 



236
237
238
239
 
# File 'lib/VirtualMachineDriver.rb', line 236

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

#resize_disk(id, drv_message) ⇒ Object 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



231
232
233
234
 
# File 'lib/VirtualMachineDriver.rb', line 231

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_nic(id, drv_message) ⇒ Object 



246
247
248
249
 
# File 'lib/VirtualMachineDriver.rb', line 246

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

#update_sg(id, drv_message) ⇒ Object 



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

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