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 



128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/opennebula/host.rb', line 128

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

#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:



216
217
218
219
220
221
222
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
 
# File 'lib/opennebula/host.rb', line 216

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



285
286
287
 
# File 'lib/opennebula/host.rb', line 285

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

#info ⇒ Object Also known as: info!

Retrieves the information of the given Host.



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

def info()
    super(HOST_METHODS[:info], 'HOST')
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’.



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

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

#monitoring_xml ⇒ String

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

Returns:

  • (String) —

    Monitoring data, in XML



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

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:



206
207
208
 
# File 'lib/opennebula/host.rb', line 206

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

#short_state_str ⇒ Object

Returns the state of the Host (string value)



269
270
271
 
# File 'lib/opennebula/host.rb', line 269

def short_state_str
    SHORT_HOST_STATES[state_str]
end

#state ⇒ Object

Returns the state of the Host (numeric value)



259
260
261
 
# File 'lib/opennebula/host.rb', line 259

def state
    self['STATE'].to_i
end

#state_str ⇒ Object

Returns the state of the Host (string value)



264
265
266
 
# File 'lib/opennebula/host.rb', line 264

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



275
276
277
 
# File 'lib/opennebula/host.rb', line 275

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:



163
164
165
 
# File 'lib/opennebula/host.rb', line 163

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

#wilds ⇒ Object

Get wild VMs in the host



280
281
282
 
# File 'lib/opennebula/host.rb', line 280

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