Class: OvirtSDK4::HostService

Inherits:
MeasurableService show all
Defined in:
lib/ovirtsdk4/services.rb,
lib/ovirtsdk4/services.rb

Instance Method Summary collapse

Methods inherited from Service

#inspect, #to_s

Instance Method Details

#activate(opts = {}) ⇒ Object

Activates the host for use, for example to run virtual machines.

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the activation should be performed asynchronously.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



35373
35374
35375
 
# File 'lib/ovirtsdk4/services.rb', line 35373

def activate(opts = {})
  internal_action(:activate, nil, ACTIVATE, opts)
end

#affinity_labels_service ⇒ AssignedAffinityLabelsService

List of scheduling labels assigned to this host.

Returns:



36555
36556
36557
 
# File 'lib/ovirtsdk4/services.rb', line 36555

def affinity_labels_service
  @affinity_labels_service ||= AssignedAffinityLabelsService.new(self, 'affinitylabels')
end

#approve(opts = {}) ⇒ Object

Approve a pre-installed Hypervisor host for usage in the virtualization environment.

This action also accepts an optional cluster element to define the target cluster for this host.

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the approval should be performed asynchronously.

  • :cluster (Cluster) —

    The cluster where the host will be added after it is approved.

  • :host (Host) —

    The host to approve.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



35407
35408
35409
 
# File 'lib/ovirtsdk4/services.rb', line 35407

def approve(opts = {})
  internal_action(:approve, nil, APPROVE, opts)
end

#approve_using_root_password(opts = {}) ⇒ Object

Approve the specified host to be added to the engine by using the root password (deprecated verb). This occurs when the host registers itself with the engine.

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the approval should be performed asynchronously.

  • :cluster (Cluster) —

    The cluster where the host will be added after it is approved.

  • :host (Host) —

    The host to approve.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



36355
36356
36357
 
# File 'lib/ovirtsdk4/services.rb', line 36355

def approve_using_root_password(opts = {})
  internal_action(:approve, nil, APPROVE_USING_ROOT_PASSWORD, opts)
end

#approve_using_ssh(opts = {}) ⇒ Object

Approve the specified host to be added to the engine by using ssh authentication. This occurs when the host registers itself with the engine.

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the approval should be performed asynchronously.

  • :cluster (Cluster) —

    The cluster where the host will be added after it is approved.

  • :host (Host) —

    The host to approve.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



36467
36468
36469
 
# File 'lib/ovirtsdk4/services.rb', line 36467

def approve_using_ssh(opts = {})
  internal_action(:approve, nil, APPROVE_USING_SSH, opts)
end

#commit_net_config(opts = {}) ⇒ Object

Marks the network configuration as good and persists it inside the host.

An API user commits the network configuration to persist a host network interface attachment or detachment, or persist the creation and deletion of a bonded interface.

Important
 Networking configuration is only committed after the engine has established that host connectivity is not lost as a result of the configuration changes. If host connectivity is lost, the host requires a reboot and automatically reverts to the previous networking configuration.

For example, to commit the network configuration of host with id 123 send a request like this:

POST /ovirt-engine/api/hosts/123/commitnetconfig

With a request body like this:

<action/>

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the action should be performed asynchronously.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



35454
35455
35456
 
# File 'lib/ovirtsdk4/services.rb', line 35454

def commit_net_config(opts = {})
  internal_action(:commitnetconfig, nil, COMMIT_NET_CONFIG, opts)
end

#deactivate(opts = {}) ⇒ Object

Deactivates the host to perform maintenance tasks.

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the deactivation should be performed asynchronously.

  • :reason (String)
  • :stop_gluster_service (Boolean) —

    Indicates if the gluster service should be stopped as part of deactivating the host. It can be used while performing maintenance operations on the gluster host. Default value for this variable is false.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



35487
35488
35489
 
# File 'lib/ovirtsdk4/services.rb', line 35487

def deactivate(opts = {})
  internal_action(:deactivate, nil, DEACTIVATE, opts)
end

#devices_service ⇒ HostDevicesService

A reference to the host devices service. Use this service to view the devices of the host object.

Returns:



36564
36565
36566
 
# File 'lib/ovirtsdk4/services.rb', line 36564

def devices_service
  @devices_service ||= HostDevicesService.new(self, 'devices')
end

#enroll_certificate(opts = {}) ⇒ Object

Enrolls the certificate of the host. Useful in case you get a warning that it is about to expire or has already expired.

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the enrollment should be performed asynchronously.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



35514
35515
35516
 
# File 'lib/ovirtsdk4/services.rb', line 35514

def enroll_certificate(opts = {})
  internal_action(:enrollcertificate, nil, ENROLL_CERTIFICATE, opts)
end

#external_network_provider_configurations_service ⇒ ExternalNetworkProviderConfigurationsService

External network providers provisioned by the system on the host.

Returns:



36573
36574
36575
 
# File 'lib/ovirtsdk4/services.rb', line 36573

def external_network_provider_configurations_service
  @external_network_provider_configurations_service ||= ExternalNetworkProviderConfigurationsService.new(self, 'externalnetworkproviderconfigurations')
end

#fence(opts = {}) ⇒ Object

Controls the host’s power management device.

For example, to start the host. This can be done via:

#!/bin/sh -ex

url="https://engine.example.com/ovirt-engine/api"
user="admin@internal"
password="..."

curl \
--verbose \
--cacert /etc/pki/ovirt-engine/ca.pem \
--user "${user}:${password}" \
--request POST \
--header "Version: 4" \
--header "Content-Type: application/xml" \
--header "Accept: application/xml" \
--data '
<action>
  <fence_type>start</fence_type>
</action>
' \
"${url}/hosts/123/fence"

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the fencing should be performed asynchronously.

  • :fence_type (String)
  • :power_management (PowerManagement)
  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



35571
35572
35573
 
# File 'lib/ovirtsdk4/services.rb', line 35571

def fence(opts = {})
  internal_action(:fence, :power_management, FENCE, opts)
end

#fence_agents_service ⇒ FenceAgentsService

A reference to the fence agents service. Use this service to manage fence and power management agents on the host object.

Returns:



36583
36584
36585
 
# File 'lib/ovirtsdk4/services.rb', line 36583

def fence_agents_service
  @fence_agents_service ||= FenceAgentsService.new(self, 'fenceagents')
end

#force_select_spm(opts = {}) ⇒ Object

To manually set a host as the storage pool manager (SPM).

POST /ovirt-engine/api/hosts/123/forceselectspm

With a request body like this:

<action/>

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the action should be performed asynchronously.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



35609
35610
35611
 
# File 'lib/ovirtsdk4/services.rb', line 35609

def force_select_spm(opts = {})
  internal_action(:forceselectspm, nil, FORCE_SELECT_SPM, opts)
end

#get(opts = {}) ⇒ Host

Gets the host details.

GET /ovirt-engine/api/hosts/123

Parameters:

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

    Additional options.

Options Hash (opts):

  • :all_content (Boolean) —

    Indicates if all of the attributes of the host should be included in the response.

    By default the following attributes are excluded:

    • hosted_engine

    For example, to retrieve the complete representation of host '123':

    GET /ovirt-engine/api/hosts/123?all_content=true
    Note
    		 These attributes are not included by default because retrieving them impacts performance. They are seldom used and require additional queries to the database. Use this parameter with caution and only when specifically required.
  • :filter (Boolean) —

    Indicates if the results should be filtered according to the permissions of the user.

  • :follow (String) —

    Indicates which inner links should be followed. The objects referenced by these links will be fetched as part of the current request. See here for details.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.

Returns:



35663
35664
35665
 
# File 'lib/ovirtsdk4/services.rb', line 35663

def get(opts = {})
  internal_get(GET, opts)
end

#hooks_service ⇒ HostHooksService

A reference to the host hooks service. Use this service to view the hooks available in the host object.

Returns:



36592
36593
36594
 
# File 'lib/ovirtsdk4/services.rb', line 36592

def hooks_service
  @hooks_service ||= HostHooksService.new(self, 'hooks')
end

#install(opts = {}) ⇒ Object

Installs the latest version of VDSM and related software on the host.

The action also performs every configuration steps on the host which is done during adding host to the engine: kdump configuration, hosted-engine deploy, kernel options changes, etc.

The host type defines additional parameters for the action.

Example of installing a host, using curl and JSON, plain:

curl \
--verbose \
--cacert /etc/pki/ovirt-engine/ca.pem \
--request PUT \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "Version: 4" \
--user "admin@internal:..." \
--data '
{
  "root_password": "myrootpassword"
}
' \
"https://engine.example.com/ovirt-engine/api/hosts/123"

Example of installing a host, using curl and JSON, with hosted engine components:

curl \
curl \
--verbose \
--cacert /etc/pki/ovirt-engine/ca.pem \
--request PUT \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "Version: 4" \
--user "admin@internal:..." \
--data '
{
  "root_password": "myrootpassword"
}
' \
"https://engine.example.com/ovirt-engine/api/hosts/123?deploy_hosted_engine=true"
Important
 Since version 4.1.2 of the engine when a host is reinstalled we override the host firewall definitions by default.

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the installation should be performed asynchronously.

  • :deploy_hosted_engine (Boolean) —

    When set to true it means this host should also deploy the self-hosted engine components. A missing value is treated as true i.e deploy. Omitting this parameter means false and will perform no operation in the self-hosted engine area.

  • :host (Host) —

    The override_iptables property is used to indicate if the firewall configuration should be replaced by the default one.

  • :image (String) —

    When installing hypervisor-name, an ISO image file is required.

  • :root_password (String) —

    The password of of the root user, used to connect to the host via SSH.

  • :ssh (Ssh) —

    The SSH details used to connect to the host.

  • :undeploy_hosted_engine (Boolean) —

    When set to true it means this host should un-deploy the self-hosted engine components and this host will not function as part of the High Availability cluster. A missing value is treated as true i.e un-deploy Omitting this parameter means false and will perform no operation in the self-hosted engine area.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



35761
35762
35763
 
# File 'lib/ovirtsdk4/services.rb', line 35761

def install(opts = {})
  internal_action(:install, nil, INSTALL, opts)
end

#install_using_root_password(opts = {}) ⇒ Object

Install VDSM and other packages required to get the host ready to be used in the engine providing the root password. This has been deprecated.

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the installation should be performed asynchronously.

  • :deploy_hosted_engine (Boolean) —

    When set to true it means this host should also deploy the self-hosted engine components. A missing value is treated as true i.e deploy. Omitting this parameter means false and will perform no operation in the self-hosted engine area.

  • :host (Host) —

    The override_iptables property is used to indicate if the firewall configuration should be replaced by the default one.

  • :image (String) —

    When installing hypervisor-name, an ISO image file is required.

  • :root_password (String) —

    The password of of the root user, used to connect to the host via SSH.

  • :ssh (Ssh) —

    The SSH details used to connect to the host.

  • :undeploy_hosted_engine (Boolean) —

    When set to true it means this host should un-deploy the self-hosted engine components and this host will not function as part of the High Availability cluster. A missing value is treated as true i.e un-deploy Omitting this parameter means false and will perform no operation in the self-hosted engine area.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



36405
36406
36407
 
# File 'lib/ovirtsdk4/services.rb', line 36405

def install_using_root_password(opts = {})
  internal_action(:install, nil, INSTALL_USING_ROOT_PASSWORD, opts)
end

#install_using_ssh(opts = {}) ⇒ Object

Install VDSM and other packages required to get the host ready to be used in the engine providing the SSH password.

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the installation should be performed asynchronously.

  • :deploy_hosted_engine (Boolean) —

    When set to true it means this host should also deploy the self-hosted engine components. A missing value is treated as true i.e deploy. Omitting this parameter means false and will perform no operation in the self-hosted engine area.

  • :host (Host) —

    The override_iptables property is used to indicate if the firewall configuration should be replaced by the default one.

  • :image (String) —

    When installing hypervisor-name, an ISO image file is required.

  • :root_password (String) —

    The password of of the root user, used to connect to the host via SSH.

  • :ssh (Ssh) —

    The SSH details used to connect to the host.

  • :undeploy_hosted_engine (Boolean) —

    When set to true it means this host should un-deploy the self-hosted engine components and this host will not function as part of the High Availability cluster. A missing value is treated as true i.e un-deploy Omitting this parameter means false and will perform no operation in the self-hosted engine area.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



36517
36518
36519
 
# File 'lib/ovirtsdk4/services.rb', line 36517

def install_using_ssh(opts = {})
  internal_action(:install, nil, INSTALL_USING_SSH, opts)
end

#iscsi_discover(opts = {}) ⇒ Object

Discovers iSCSI targets on the host, using the initiator details.

For example, to discover iSCSI targets available in myiscsi.example.com, from host 123, send a request like this:

POST /ovirt-engine/api/hosts/123/iscsidiscover

With a request body like this:

<action>
  <iscsi>
    <address>myiscsi.example.com</address>
  </iscsi>
</action>

The result will be like this:

<discovered_targets>
  <iscsi_details>
    <address>10.35.1.72</address>
    <port>3260</port>
    <portal>10.35.1.72:3260,1</portal>
    <target>iqn.2015-08.com.tgt:444</target>
  </iscsi_details>
</discovered_targets>

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the discovery should be performed asynchronously.

  • :discovered_targets (Array<IscsiDetails>) —

    The discovered targets including all connection information.

  • :iscsi (IscsiDetails) —

    The target iSCSI device.

  • :iscsi_targets (Array<String>) —

    The iSCSI targets.

    Since version 4.2 of the engine, this parameter is deprecated, use discovered_targets instead.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



35830
35831
35832
 
# File 'lib/ovirtsdk4/services.rb', line 35830

def iscsi_discover(opts = {})
  internal_action(:iscsidiscover, :iscsi_targets, ISCSI_DISCOVER, opts)
end

#iscsi_login(opts = {}) ⇒ Object

Login to iSCSI targets on the host, using the target details.

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the login should be performed asynchronously.

  • :iscsi (IscsiDetails) —

    The target iSCSI device.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



35859
35860
35861
 
# File 'lib/ovirtsdk4/services.rb', line 35859

def (opts = {})
  internal_action(:iscsilogin, nil, ISCSI_LOGIN, opts)
end

#katello_errata_service ⇒ KatelloErrataService

A reference to the service that can show the applicable errata available on the host. This information is taken from Katello.

Returns:



36602
36603
36604
 
# File 'lib/ovirtsdk4/services.rb', line 36602

def katello_errata_service
  @katello_errata_service ||= KatelloErrataService.new(self, 'katelloerrata')
end

#network_attachments_service ⇒ NetworkAttachmentsService

A reference to the network attachments service. You can use this service to attach Logical networks to host interfaces.

Returns:



36612
36613
36614
 
# File 'lib/ovirtsdk4/services.rb', line 36612

def network_attachments_service
  @network_attachments_service ||= NetworkAttachmentsService.new(self, 'networkattachments')
end

#nics_service ⇒ HostNicsService

A reference to the service that manages the network interface devices on the host.

Returns:



36621
36622
36623
 
# File 'lib/ovirtsdk4/services.rb', line 36621

def nics_service
  @nics_service ||= HostNicsService.new(self, 'nics')
end

#numa_nodes_service ⇒ HostNumaNodesService

A reference to the service that manage NUMA nodes for the host.

Returns:



36630
36631
36632
 
# File 'lib/ovirtsdk4/services.rb', line 36630

def numa_nodes_service
  @numa_nodes_service ||= HostNumaNodesService.new(self, 'numanodes')
end

#permissions_service ⇒ AssignedPermissionsService

A reference to the host permission service. Use this service to manage permissions on the host object.

Returns:



36640
36641
36642
 
# File 'lib/ovirtsdk4/services.rb', line 36640

def permissions_service
  @permissions_service ||= AssignedPermissionsService.new(self, 'permissions')
end

#refresh(opts = {}) ⇒ Object

Refresh the host devices and capabilities.

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the refresh should be performed asynchronously.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



35885
35886
35887
 
# File 'lib/ovirtsdk4/services.rb', line 35885

def refresh(opts = {})
  internal_action(:refresh, nil, REFRESH, opts)
end

#remove(opts = {}) ⇒ Object

Remove the host from the system.

#!/bin/sh -ex

url="https://engine.example.com/ovirt-engine/api"
user="admin@internal"
password="..."

curl \
--verbose \
--cacert /etc/pki/ovirt-engine/ca.pem \
--user "${user}:${password}" \
--request DELETE \
--header "Version: 4" \
"${url}/hosts/1ff7a191-2f3b-4eff-812b-9f91a30c3acc"

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the remove should be performed asynchronously.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



35927
35928
35929
 
# File 'lib/ovirtsdk4/services.rb', line 35927

def remove(opts = {})
  internal_remove(REMOVE, opts)
end

#service(path) ⇒ Service

Locates the service corresponding to the given path.

Parameters:

  • path (String) —

    The path of the service.

Returns:

  • (Service) —

    A reference to the service.

Raises:



36696
36697
36698
36699
36700
36701
36702
36703
36704
36705
36706
36707
36708
36709
36710
36711
36712
36713
36714
36715
36716
36717
36718
36719
36720
36721
36722
36723
36724
36725
36726
36727
36728
36729
36730
36731
36732
36733
36734
36735
36736
36737
36738
36739
36740
36741
36742
36743
36744
36745
36746
36747
36748
36749
36750
36751
36752
36753
36754
36755
36756
36757
36758
36759
36760
36761
36762
36763
36764
36765
36766
36767
36768
36769
36770
36771
36772
36773
36774
36775
36776
36777
36778
36779
36780
36781
36782
36783
36784
36785
36786
36787
36788
36789
36790
36791
 
# File 'lib/ovirtsdk4/services.rb', line 36696

def service(path)
  if path.nil? || path == ''
    return self
  end
  if path == 'affinitylabels'
    return affinity_labels_service
  end
  if path.start_with?('affinitylabels/')
    return affinity_labels_service.service(path[15..-1])
  end
  if path == 'devices'
    return devices_service
  end
  if path.start_with?('devices/')
    return devices_service.service(path[8..-1])
  end
  if path == 'externalnetworkproviderconfigurations'
    return external_network_provider_configurations_service
  end
  if path.start_with?('externalnetworkproviderconfigurations/')
    return external_network_provider_configurations_service.service(path[38..-1])
  end
  if path == 'fenceagents'
    return fence_agents_service
  end
  if path.start_with?('fenceagents/')
    return fence_agents_service.service(path[12..-1])
  end
  if path == 'hooks'
    return hooks_service
  end
  if path.start_with?('hooks/')
    return hooks_service.service(path[6..-1])
  end
  if path == 'katelloerrata'
    return katello_errata_service
  end
  if path.start_with?('katelloerrata/')
    return katello_errata_service.service(path[14..-1])
  end
  if path == 'networkattachments'
    return network_attachments_service
  end
  if path.start_with?('networkattachments/')
    return network_attachments_service.service(path[19..-1])
  end
  if path == 'nics'
    return nics_service
  end
  if path.start_with?('nics/')
    return nics_service.service(path[5..-1])
  end
  if path == 'numanodes'
    return numa_nodes_service
  end
  if path.start_with?('numanodes/')
    return numa_nodes_service.service(path[10..-1])
  end
  if path == 'permissions'
    return permissions_service
  end
  if path.start_with?('permissions/')
    return permissions_service.service(path[12..-1])
  end
  if path == 'statistics'
    return statistics_service
  end
  if path.start_with?('statistics/')
    return statistics_service.service(path[11..-1])
  end
  if path == 'storage'
    return storage_service
  end
  if path.start_with?('storage/')
    return storage_service.service(path[8..-1])
  end
  if path == 'storageconnectionextensions'
    return storage_connection_extensions_service
  end
  if path.start_with?('storageconnectionextensions/')
    return storage_connection_extensions_service.service(path[28..-1])
  end
  if path == 'tags'
    return tags_service
  end
  if path.start_with?('tags/')
    return tags_service.service(path[5..-1])
  end
  if path == 'unmanagednetworks'
    return unmanaged_networks_service
  end
  if path.start_with?('unmanagednetworks/')
    return unmanaged_networks_service.service(path[18..-1])
  end
  raise Error.new("The path \"#{path}\" doesn't correspond to any service")
end

#setup_networks(opts = {}) ⇒ Object

This method is used to change the configuration of the network interfaces of a host.

For example, if you have a host with three network interfaces eth0, eth1 and eth2 and you want to configure a new bond using eth0 and eth1, and put a VLAN on top of it. Using a simple shell script and the curl command line HTTP client that can be done as follows:

#!/bin/sh -ex

url="https://engine.example.com/ovirt-engine/api"
user="admin@internal"
password="..."

curl \
--verbose \
--cacert /etc/pki/ovirt-engine/ca.pem \
--user "${user}:${password}" \
--request POST \
--header "Version: 4" \
--header "Content-Type: application/xml" \
--header "Accept: application/xml" \
--data '
<action>
  <modified_bonds>
    <host_nic>
      <name>bond0</name>
      <bonding>
        <options>
          <option>
            <name>mode</name>
            <value>4</value>
          </option>
          <option>
            <name>miimon</name>
            <value>100</value>
          </option>
        </options>
        <slaves>
          <host_nic>
            <name>eth1</name>
          </host_nic>
          <host_nic>
            <name>eth2</name>
          </host_nic>
        </slaves>
      </bonding>
    </host_nic>
  </modified_bonds>
  <modified_network_attachments>
    <network_attachment>
      <network>
        <name>myvlan</name>
      </network>
      <host_nic>
        <name>bond0</name>
      </host_nic>
      <ip_address_assignments>
        <assignment_method>static</assignment_method>
        <ip_address_assignment>
          <ip>
            <address>192.168.122.10</address>
            <netmask>255.255.255.0</netmask>
          </ip>
        </ip_address_assignment>
      </ip_address_assignments>
      <dns_resolver_configuration>
        <name_servers>
          <name_server>1.1.1.1</name_server>
          <name_server>2.2.2.2</name_server>
        </name_servers>
      </dns_resolver_configuration>
    </network_attachment>
  </modified_network_attachments>
 </action>
' \
"${url}/hosts/1ff7a191-2f3b-4eff-812b-9f91a30c3acc/setupnetworks"
Note
 This is valid for version 4 of the API. In previous versions some elements were represented as XML attributes instead of XML elements. In particular the options and ip elements were represented as follows: 
<options name="mode" value="4"/>
<options name="miimon" value="100"/>
<ip address="192.168.122.10" netmask="255.255.255.0"/>

Using the Python SDK the same can be done with the following code:

# Find the service that manages the collection of hosts:
hosts_service = connection.system_service().hosts_service()

# Find the host:
host = hosts_service.list(search='name=myhost')[0]

# Find the service that manages the host:
host_service = hosts_service.host_service(host.id)

# Configure the network adding a bond with two slaves and attaching it to a
# network with an static IP address:
host_service.setup_networks(
    modified_bonds=[
        types.HostNic(
            name='bond0',
            bonding=types.Bonding(
                options=[
                    types.Option(
                        name='mode',
                        value='4',
                    ),
                    types.Option(
                        name='miimon',
                        value='100',
                    ),
                ],
                slaves=[
                    types.HostNic(
                        name='eth1',
                    ),
                    types.HostNic(
                        name='eth2',
                    ),
                ],
            ),
        ),
    ],
    modified_network_attachments=[
        types.NetworkAttachment(
            network=types.Network(
                name='myvlan',
            ),
            host_nic=types.HostNic(
                name='bond0',
            ),
            ip_address_assignments=[
                types.IpAddressAssignment(
                    assignment_method=types.BootProtocol.STATIC,
                    ip=types.Ip(
                        address='192.168.122.10',
                        netmask='255.255.255.0',
                    ),
                ),
            ],
            dns_resolver_configuration=types.DnsResolverConfiguration(
                name_servers=[
                    '1.1.1.1',
                    '2.2.2.2',
                ],
            ),
        ),
    ],
)

# After modifying the network configuration it is very important to make it
# persistent:
host_service.commit_net_config()
Important
 To make sure that the network configuration has been saved in the host, and that it will be applied when the host is rebooted, remember to call commitnetconfig.

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the action should be performed asynchronously.

  • :check_connectivity (Boolean)
  • :connectivity_timeout (Integer)
  • :modified_bonds (Array<HostNic>)
  • :modified_labels (Array<NetworkLabel>)
  • :modified_network_attachments (Array<NetworkAttachment>)
  • :removed_bonds (Array<HostNic>)
  • :removed_labels (Array<NetworkLabel>)
  • :removed_network_attachments (Array<NetworkAttachment>)
  • :synchronized_network_attachments (Array<NetworkAttachment>) —

    A list of network attachments that will be synchronized.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



36143
36144
36145
 
# File 'lib/ovirtsdk4/services.rb', line 36143

def setup_networks(opts = {})
  internal_action(:setupnetworks, nil, SETUP_NETWORKS, opts)
end

#statistics_service ⇒ StatisticsService

Locates the statistics service.

Returns:



36649
36650
36651
 
# File 'lib/ovirtsdk4/services.rb', line 36649

def statistics_service
  @statistics_service ||= StatisticsService.new(self, 'statistics')
end

#storage_connection_extensions_service ⇒ StorageServerConnectionExtensionsService

A reference to storage connection extensions.

Returns:



36667
36668
36669
 
# File 'lib/ovirtsdk4/services.rb', line 36667

def storage_connection_extensions_service
  @storage_connection_extensions_service ||= StorageServerConnectionExtensionsService.new(self, 'storageconnectionextensions')
end

#storage_service ⇒ HostStorageService

A reference to the service that manages the host’s storage.

Returns:



36658
36659
36660
 
# File 'lib/ovirtsdk4/services.rb', line 36658

def storage_service
  @storage_service ||= HostStorageService.new(self, 'storage')
end

#sync_all_networks(opts = {}) ⇒ Object

To synchronize all networks on the host, send a request like this:

POST /ovirt-engine/api/hosts/123/syncallnetworks

With a request body like this:

<action/>

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the action should be performed asynchronously.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



36181
36182
36183
 
# File 'lib/ovirtsdk4/services.rb', line 36181

def sync_all_networks(opts = {})
  internal_action(:syncallnetworks, nil, SYNC_ALL_NETWORKS, opts)
end

#tags_service ⇒ AssignedTagsService

A reference to the host tags service. Use this service to manage tags on the host object.

Returns:



36676
36677
36678
 
# File 'lib/ovirtsdk4/services.rb', line 36676

def tags_service
  @tags_service ||= AssignedTagsService.new(self, 'tags')
end

#unmanaged_networks_service ⇒ UnmanagedNetworksService

A reference to unmanaged networks.

Returns:



36685
36686
36687
 
# File 'lib/ovirtsdk4/services.rb', line 36685

def unmanaged_networks_service
  @unmanaged_networks_service ||= UnmanagedNetworksService.new(self, 'unmanagednetworks')
end

#unregistered_storage_domains_discover(opts = {}) ⇒ Object

Discovers the block Storage Domains which are candidates to be imported to the setup. For FCP no arguments are required.

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the discovery should be performed asynchronously.

  • :iscsi (IscsiDetails)
  • :storage_domains (Array<StorageDomain>)
  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



36213
36214
36215
 
# File 'lib/ovirtsdk4/services.rb', line 36213

def unregistered_storage_domains_discover(opts = {})
  internal_action(:unregisteredstoragedomainsdiscover, :storage_domains, UNREGISTERED_STORAGE_DOMAINS_DISCOVER, opts)
end

#update(host, opts = {}) ⇒ Host

Update the host properties.

For example, to update a the kernel command line of a host send a request like this:

PUT /ovirt-engine/api/hosts/123

With request body like this:

<host>
  <os>
    <custom_kernel_cmdline>vfio_iommu_type1.allow_unsafe_interrupts=1</custom_kernel_cmdline>
  </os>
</host>

Parameters:

  • host (Host) —

    The host to update.

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the update should be performed asynchronously.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.

Returns:



36260
36261
36262
 
# File 'lib/ovirtsdk4/services.rb', line 36260

def update(host, opts = {})
  internal_update(host, Host, UPDATE, opts)
end

#update_using_root_password(host, opts = {}) ⇒ Host

Update the specified host in the system. This is deprecated and is provided only for backwards compatibility.

Parameters:

  • host (Host) —

    The host to update.

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the update should be performed asynchronously.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.

Returns:



36434
36435
36436
 
# File 'lib/ovirtsdk4/services.rb', line 36434

def update_using_root_password(host, opts = {})
  internal_update(host, Host, UPDATE_USING_ROOT_PASSWORD, opts)
end

#update_using_ssh(host, opts = {}) ⇒ Host

Updates the specified host in the system.

Parameters:

  • host (Host) —

    The host to update.

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the update should be performed asynchronously.

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.

Returns:



36546
36547
36548
 
# File 'lib/ovirtsdk4/services.rb', line 36546

def update_using_ssh(host, opts = {})
  internal_update(host, Host, UPDATE_USING_SSH, opts)
end

#upgrade(opts = {}) ⇒ Object

Upgrades VDSM and selected software on the host.

Parameters:

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

    Additional options.

Options Hash (opts):

  • :async (Boolean) —

    Indicates if the upgrade should be performed asynchronously.

  • :image (String) —

    The image parameter specifies path to image, which is used for upgrade. This parameter is used only to upgrade Vintage Node hosts and it is not relevant for other hosts types.

  • :reboot (Boolean) —

    Indicates if the host should be rebooted after upgrade. By default the host is rebooted.

    Note
    		 This parameter is ignored for hypervisor-name, which is always rebooted after upgrade.
  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



36296
36297
36298
 
# File 'lib/ovirtsdk4/services.rb', line 36296

def upgrade(opts = {})
  internal_action(:upgrade, nil, UPGRADE, opts)
end

#upgrade_check(opts = {}) ⇒ Object

Check if there are upgrades available for the host. If there are upgrades available an icon will be displayed next to host status icon in the Administration Portal. Audit log messages are also added to indicate the availability of upgrades. The upgrade can be started from the webadmin or by using the upgrade host action.

Parameters:

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

    Additional options.

Options Hash (opts):

  • :headers (Hash) — default: {} —

    Additional HTTP headers.

  • :query (Hash) — default: {} —

    Additional URL query parameters.

  • :timeout (Integer) — default: nil —

    The timeout for this request, in seconds. If no value is explicitly given then the timeout set globally for the connection will be used.

  • :wait (Boolean) — default: true —

    If true wait for the response.



36322
36323
36324
 
# File 'lib/ovirtsdk4/services.rb', line 36322

def upgrade_check(opts = {})
  internal_action(:upgradecheck, nil, UPGRADE_CHECK, opts)
end