Class: OpenNebula::Host

Inherits:
PoolElement show all
Defined in:
lib/opennebula/host.rb

Constant Summary collapse

HOST_METHODS =

Constants and Class Methods

{
    :info       => "host.info",
    :allocate   => "host.allocate",
    :delete     => "host.delete",
    :status     => "host.status",
    :update     => "host.update",
    :monitoring => "host.monitoring",
    :rename     => "host.rename"
}
HOST_STATES = 
%w{INIT MONITORING_MONITORED MONITORED ERROR DISABLED
MONITORING_ERROR MONITORING_INIT MONITORING_DISABLED OFFLINE}
SHORT_HOST_STATES = 
{
    "INIT"                 => "init",
    "MONITORING_MONITORED" => "update",
    "MONITORED"            => "on",
    "ERROR"                => "err",
    "DISABLED"             => "dsbl",
    "MONITORING_ERROR"     => "retry",
    "MONITORING_INIT"      => "init",
    "MONITORING_DISABLED"  => "dsbl",
    "OFFLINE"              => "off"
}
HOST_STATUS = 
{
    "ENABLED"  => 0,
    "DISABLED" => 1,
    "OFFLINE"  => 2
}

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from PoolElement

#id, #name, new_with_id, #replace, #to_str

Methods inherited from XMLElement

#[], #add_element, #attr, #delete_element, #each, #each_xpath, #element_xml, #has_elements?, #initialize_xml, #name, #retrieve_elements, #retrieve_xmlelements, #set_content, #template_like_str, #template_xml, #text, #to_hash, #to_xml, #xml_nil?

Constructor Details

#initialize(xml, client) ⇒ Host

Class constructor



77
78
79
80
81
82
 
# File 'lib/opennebula/host.rb', line 77

def initialize(xml, client)
    super(xml,client)

    @client = client
    @pe_id  = self['ID'].to_i if self['ID']
end

Class Method Details

.build_xml(pe_id = nil) ⇒ Object

Creates a Host description with just its identifier this method should be used to create plain Host objects. id the id of the host

Example:

host = Host.new(Host.build_xml(3),rpc_client)



66
67
68
69
70
71
72
73
74
 
# File 'lib/opennebula/host.rb', line 66

def Host.build_xml(pe_id=nil)
    if pe_id
        host_xml = "<HOST><ID>#{pe_id}</ID></HOST>"
    else
        host_xml = "<HOST></HOST>"
    end

    XMLElement.build_xml(host_xml, 'HOST')
end

Instance Method Details

#allocate(hostname, im, vmm, cluster_id = ClusterPool::NONE_CLUSTER_ID) ⇒ Integer, OpenNebula::Error

Allocates a new Host in OpenNebula

Parameters:

  • hostname (String) —

    Name of the new Host.

  • im (String) —

    Name of the im_driver (information/monitoring)

  • vmm (String) —

    Name of the vmm_driver (hypervisor)

  • cluster_id (String) (defaults to: ClusterPool::NONE_CLUSTER_ID) —

    Id of the cluster, -1 to use default

Returns:



104
105
106
 
# File 'lib/opennebula/host.rb', line 104

def allocate(hostname, im, vmm, cluster_id=ClusterPool::NONE_CLUSTER_ID)
    super(HOST_METHODS[:allocate], hostname, im, vmm, cluster_id)
end

#delete ⇒ Object

Deletes the Host



109
110
111
 
# File 'lib/opennebula/host.rb', line 109

def delete()
    super(HOST_METHODS[:delete])
end

#disable ⇒ Object

Disables the Host



119
120
121
 
# File 'lib/opennebula/host.rb', line 119

def disable()
    set_status("DISABLED")
end

#enable ⇒ Object

Enables the Host



114
115
116
 
# File 'lib/opennebula/host.rb', line 114

def enable()
    set_status("ENABLED")
end

#flush(action) ⇒ Object 



136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
 
# File 'lib/opennebula/host.rb', line 136

def flush(action)
    self.disable

    vm_pool = OpenNebula::VirtualMachinePool.new(@client,
                                        VirtualMachinePool::INFO_ALL_VM)

    rc = vm_pool.info
    if OpenNebula.is_error?(rc)
         puts rc.message
         exit(-1)
    end

    vm_pool.each do |vm|
        hid = vm['HISTORY_RECORDS/HISTORY[last()]/HID']
        if hid == self['ID']
            case action
            when "resched"
                vm.resched
            when "delete-recreate"
                vm.recover(4)
            else
                vm.resched
            end
        end
    end
end

#forceupdate ⇒ Object

Resets monitoring forcing an update



129
130
131
132
133
134
 
# File 'lib/opennebula/host.rb', line 129

def forceupdate()
    rc = offline
    return rc if OpenNebula.is_error?(rc)

    enable
end

#import_wild(name) ⇒ nil, OpenNebula::Error

Imports a wild VM from the host and puts it in running state

Parameters:

  • name (String) —

    Name of the VM to import

Returns:



223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
 
# File 'lib/opennebula/host.rb', line 223

def import_wild(name)
    vms = importable_wilds.select {|vm| vm['VM_NAME'] == name }

    if vms.length == 0
        return OpenNebula::Error.new("No importable wilds with name " <<
            "'#{name}' found.")
    elsif vms.length > 1
        return OpenNebula::Error.new("More than one importable wild " <<
            "with name '#{name}' found.")
    end

    wild = vms.first

    template = Base64.decode64(wild['IMPORT_TEMPLATE'])

    xml = OpenNebula::VirtualMachine.build_xml
    vm = OpenNebula::VirtualMachine.new(xml, @client)

    # vCenter wild VMs has a different process
    # image and vnets objects representing existing nics and disks
    # must be created and referenced
    vcenter_wild_vm = wild.key? "VCENTER_TEMPLATE"
    if vcenter_wild_vm
        require 'vcenter_driver'
        vi_client = VCenterDriver::VIClient.new_from_host(self["ID"])
        importer  = VCenterDriver::VmmImporter.new(@client, vi_client)

        return importer.import({wild: wild, template: template,
                                one_item: vm, host: self['ID']})
    else
        rc = vm.allocate(template)

        return rc if OpenNebula.is_error?(rc)

        vm.deploy(id, false)
        return vm.id
    end
end

#importable_wilds ⇒ Object

Get importable wild VMs in the host



293
294
295
 
# File 'lib/opennebula/host.rb', line 293

def importable_wilds
    wilds.select {|w| Hash === w && w['IMPORT_TEMPLATE'] }
end

#info(decrypt = false) ⇒ Object Also known as: info!

Retrieves the information of the given Host.



89
90
91
 
# File 'lib/opennebula/host.rb', line 89

def info(decrypt = false)
    super(HOST_METHODS[:info], 'HOST', decrypt)
end

#monitoring(xpath_expressions) ⇒ Hash<String, Array<Array<int>>>, OpenNebula::Error

Retrieves this Host’s monitoring data from OpenNebula

Examples:

host.monitoring( ['HOST_SHARE/FREE_CPU', 'HOST_SHARE/RUNNING_VMS'] )

{ "HOST_SHARE/RUNNING_VMS" =>
    [["1337266000", "1"],
     ["1337266044", "1"],
     ["1337266088", "3"]],
  "HOST_SHARE/FREE_CPU" =>
    [["1337266000", "800"],
     ["1337266044", "800"],
     ["1337266088", "800"]]
}

Parameters:

  • xpath_expressions (Array<String>) —

    Elements to retrieve.

Returns:

  • (Hash<String, Array<Array<int>>>, OpenNebula::Error) —

    Hash with the requested xpath expressions, and an Array of ‘timestamp, value’.



194
195
196
 
# File 'lib/opennebula/host.rb', line 194

def monitoring(xpath_expressions)
    return super(HOST_METHODS[:monitoring], xpath_expressions)
end

#monitoring_xml ⇒ String

Retrieves this Host’s monitoring data from OpenNebula, in XML

Returns:

  • (String) —

    Monitoring data, in XML



201
202
203
204
205
 
# File 'lib/opennebula/host.rb', line 201

def monitoring_xml()
    return Error.new('ID not defined') if !@pe_id

    return @client.call(HOST_METHODS[:monitoring], @pe_id)
end

#offline ⇒ Object

Sets the Host offline



124
125
126
 
# File 'lib/opennebula/host.rb', line 124

def offline()
    set_status("OFFLINE")
end

#rename(name) ⇒ nil, OpenNebula::Error

Renames this Host

Parameters:

  • name (String) —

    New name for the Host.

Returns:



213
214
215
 
# File 'lib/opennebula/host.rb', line 213

def rename(name)
    return call(HOST_METHODS[:rename], @pe_id, name)
end

#short_state_str ⇒ Object

Returns the state of the Host (string value)



277
278
279
 
# File 'lib/opennebula/host.rb', line 277

def short_state_str
    SHORT_HOST_STATES[state_str]
end

#state ⇒ Object

Returns the state of the Host (numeric value)



267
268
269
 
# File 'lib/opennebula/host.rb', line 267

def state
    self['STATE'].to_i
end

#state_str ⇒ Object

Returns the state of the Host (string value)



272
273
274
 
# File 'lib/opennebula/host.rb', line 272

def state_str
    HOST_STATES[state]
end

#template_str(indent = true) ⇒ Object

Returns the <TEMPLATE> element in text form

indent

Boolean indents the resulting string, default true



283
284
285
 
# File 'lib/opennebula/host.rb', line 283

def template_str(indent=true)
    template_like_str('TEMPLATE', indent)
end

#update(new_template, append = false) ⇒ nil, OpenNebula::Error

Replaces the template contents

Parameters:

  • new_template (String) —

    New template contents

  • append (true, false) (defaults to: false) —

    True to append new attributes instead of replace the whole template

Returns:



171
172
173
 
# File 'lib/opennebula/host.rb', line 171

def update(new_template, append=false)
    super(HOST_METHODS[:update], new_template, append ? 1 : 0)
end

#wilds ⇒ Object

Get wild VMs in the host



288
289
290
 
# File 'lib/opennebula/host.rb', line 288

def wilds
    [self.to_hash['HOST']['TEMPLATE']['VM']].flatten.compact
end